libqirt/qirt.c

#include "qirt.h"

#include <stdio.h>

#define GC_THREADS
#include <gc.h>
#include <pthread.h>

static qi_bool __debug_enabled = false;
static pthread_t __main_tid;
static char *__recerror_msg = NULL;

#define _RECERROR "max. recursion depth reached"

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();

  memset(ptr, 0, size);

  return ptr;
}

static void *qi_malloc_uncollectable(size_t size)
{
  void *ptr = malloc(size);

  if (!ptr)
    abort();

  memset(ptr, 0, size);

  return ptr;
}

static void *qi_malloc_root(size_t size)
{
  void *ptr = GC_malloc_uncollectable(size);

  if (!ptr)
    abort();

  memset(ptr, 0, size);

  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)
{
  qi_size_t z = strlen(s) + 1;
  char *ptr = GC_MALLOC_ATOMIC(sizeof(char) * z);

  if (!ptr)
    abort();

  ptr[z - 1] = 0;

  strcpy(ptr, s);

  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->data = NULL;
  list->length = 0;

  return list;
}

static qi_list_t *qi_list_make_uncollectable(void)
{
  qi_list_t *list = qi_malloc_uncollectable(sizeof(qi_list_t));
  list->data = NULL;
  list->length = 0;

  return list;
}

static qi_list_t *qi_list_make_root(void)
{
  qi_list_t *list = qi_malloc_root(sizeof(qi_list_t));
  list->data = NULL;
  list->length = 0;

  return list;
}

qi_list_t *qi_list_resize(qi_list_t *list, qi_size_t size)
{
  if (list->length == size)
    return list;

  list->length = size;

  if (size == 0)
  {
    qi_free(list->data);

    list->data = NULL;
  }
  else
    list->data = qi_realloc(list->data, sizeof(void *) * list->length);

  return list;
}

void *qi_list_index(qi_list_t *list, qi_ssize_t index)
{
  if (qi_list_empty(list))
    return NULL;

  if (index < 0)
    index += ((qi_ssize_t)qi_list_length(list));

  if (index < 0 || index >= qi_list_length(list))
    return NULL;

  return qi_list_data(list, index);
}

qi_list_t *qi_list_push(qi_list_t *list, void *value)
{
  qi_list_resize(list, qi_list_length(list) + 1);
  qi_list_data(list, qi_list_length(list) - 1) = value;

  return list;
}

qi_bool qi_list_insert(qi_list_t *list, qi_ssize_t index, void *value)
{
  if (index == -1 || index == (qi_ssize_t)qi_list_length(list))
  {
    qi_list_push(list, value);

    return true;
  }

  if (index < 0)
    index += (qi_ssize_t)qi_list_length(list);

  if (index < 0 || index > qi_list_length(list))
    return false;

  qi_list_resize(list, qi_list_length(list) + 1);

  for (qi_size_t i = qi_list_length(list); index == 0 ? i > 0 : i >= index; i--)
    qi_list_data(list, i) = qi_list_data(list, i - 1);

  qi_list_data(list, index) = value;

  return true;
}

qi_bool qi_list_delete(qi_list_t *list, qi_ssize_t index)
{
  if (qi_list_empty(list))
    return false;

  if (index == -1 || index == (qi_ssize_t)qi_list_length(list))
  {
    qi_list_pop(list);

    return true;
  }

  if (index < 0)
    index += (qi_ssize_t)qi_list_length(list);

  if (index < 0 || index >= qi_list_length(list))
    return false;

  qi_list_data(list, index) = NULL;

  if (qi_list_length(list) == 1)
  {
    qi_list_resize(list, 0);

    return true;
  }

  for (qi_size_t i = index; i < qi_list_length(list) - 1; i++)
    qi_list_data(list, i) = qi_list_data(list, i + 1);

  qi_list_resize(list, qi_list_length(list) - 1);

  return true;
}

qi_bool 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 true;
  }

  if (index < 0 || index >= length)
    return false;

  qi_list_data(list, index) = value;

  return true;
}

void *qi_list_pop(qi_list_t *list)
{
  if (qi_list_empty(list))
    return NULL;

  void *value = qi_list_last(list);

  qi_list_resize(list, qi_list_length(list) - 1);

  return value;
}

qi_bool qi_list_contains(qi_list_t *list, void *value)
{
  if (qi_list_empty(list))
    return false;

  for (qi_size_t i = 0; i < qi_list_length(list); i++)
    if (qi_list_data(list, i) == value)
      return true;

  return false;
}

qi_list_t *qi_list_copy(qi_list_t *list)
{
  qi_list_t *newlist = qi_list_make_n(qi_list_length(list));

  if (qi_list_empty(list))
    return newlist;

  for (qi_size_t i = 0; i < qi_list_length(list); i++)
    newlist->data[i] = list->data[i];

  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_CAP;

  table->entries = qi_calloc(table->capacity, sizeof(qi_table_entry_t));

  table->llh = NULL;
  table->llc = NULL;

  return table;
}

static qi_table_t *qi_table_make_root(void)
{
  qi_table_t *table = qi_malloc_root(sizeof(qi_table_t));
  table->used = 0;

  table->capacity = QI_TABLE_MIN_CAP;
  table->entries = qi_calloc(table->capacity, sizeof(qi_table_entry_t));

  return table;
}

static qi_linkedlist_t *qi_linkedlist_push(qi_linkedlist_t *prev, uint64_t i)
{
  qi_linkedlist_t *ll = qi_malloc(sizeof(qi_linkedlist_t));

  ll->i = i;
  ll->next = NULL;

  if (prev == NULL)
  {
    ll->prev = NULL;

    return ll;
  }

  prev->next = ll;
  ll->prev = prev;

  return ll;
}

static void qi_linkedlist_destroy(qi_linkedlist_t *ll)
{
  qi_linkedlist_t *lln = ll;

  qi_linkedlist_t *temp;
  while (lln != NULL)
  {
    temp = lln->next;

    qi_free(lln);

    lln = temp;
  }
}

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;

#define mm86128h(s) (MM86128((s), strlen((s)), QI_HASH_SEED))

void *qi_table_get(qi_table_t *table, char *key)
{
  if (qi_table_empty(table))
    return NULL;

  uint64_t hash = mm86128h(key);
  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;
}

qi_bool qi_table_has(qi_table_t *table, char *key)
{
  if (qi_table_empty(table))
    return false;

  uint64_t hash = mm86128h(key);
  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_linkedlist_t **llh, qi_linkedlist_t **llc,
                               qi_size_t capacity, qi_size_t *used)
{
  uint64_t hash = mm86128h(key);
  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;

        qi_linkedlist_t *lln = qi_linkedlist_push(*llc, i);
        if (!*llh)
          *llh = lln;

        *llc = lln;

        entries[i].lln = lln;
      }

      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;

  if (!entries[i].lln)
  {
    qi_linkedlist_t *lln = qi_linkedlist_push(*llc, i);
    if (!*llh)
      *llh = lln;

    *llc = lln;

    entries[i].lln = lln;
  }
}

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_CAP;
    qi_table_entry_t *entries = qi_calloc(capacity, sizeof(qi_table_entry_t));
    qi_linkedlist_t *llh = NULL;
    qi_linkedlist_t *llc = NULL;

    qi_table_iterate(table, {
      qi_table_entry_set(entries, entry.key, entry.value, &llh, &llc, capacity, NULL);
    });

    qi_free(table->entries);
    qi_linkedlist_destroy(table->llh);

    table->entries = entries;
    table->llh = llh;
    table->llc = llc;
    table->capacity = capacity;
  }

  qi_table_entry_set(table->entries, key, value, &table->llh, &table->llc, 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;
}

qi_bool qi_table_delete(qi_table_t *table, char *key)
{
  uint64_t hash = mm86128h(key);
  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;

      qi_linkedlist_t *lln = table->entries[i].lln;
      if (lln->prev)
        lln->prev->next = lln->next;
      else
        table->llh = lln->next;

      if (lln->next)
        lln->next->prev = lln->prev;
      else
        table->llc = lln->prev;

      qi_free(lln);

      table->entries[i].lln = NULL;

      table->used--;

      if (table->capacity > QI_TABLE_MIN_CAP &&
          table->used <= table->capacity - QI_TABLE_MIN_CAP)
      {
        qi_size_t capacity = table->capacity - QI_TABLE_MIN_CAP;
        qi_table_entry_t *entries =
            qi_calloc(capacity, sizeof(qi_table_entry_t));
        qi_linkedlist_t *llh = NULL;
        qi_linkedlist_t *llc = NULL;

        qi_table_iterate(table, {
          qi_table_entry_set(entries, entry.key, entry.value, &llh, &llc, capacity, NULL);
        });

        qi_free(table->entries);
        qi_linkedlist_destroy(table->llh);

        table->entries = entries;
        table->llh = llh;
        table->llc = llc;
        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;
}

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;
}

void qi_buffer_append(qi_buffer_t *buf, char c)
{
  buf->used++;

  if (buf->used > buf->allocated)
  {
    buf->allocated++;

    if (!buf->str)
      buf->str = qi_malloc_atomic(sizeof(char) * buf->allocated);
    else
      buf->str = qi_realloc(buf->str, sizeof(char) * buf->allocated);
  }

  buf->str[buf->used - 1] = c;
}

void qi_buffer_append_str(qi_buffer_t *buf, char *s)
{
  while (*s)
    qi_buffer_append(buf, *s++);
}

void qi_buffer_format(qi_buffer_t *buf, const char *fmt, ...)
{
  va_list args;
  va_list largs;

  va_start(largs, fmt);
  va_copy(args, largs);

  qi_size_t size = vsnprintf(NULL, 0, fmt, largs) + 1;
  char *str = qi_malloc_atomic(sizeof(char) * size);

  vsnprintf(str, size, fmt, args);

  va_end(args);
  va_end(largs);

  qi_buffer_append_str(buf, str);

  qi_free(str);
}

void qi_buffer_appendn(qi_buffer_t *buf, char *s, qi_size_t z)
{
  for (qi_size_t i = 0; i < z; i++)
    qi_buffer_append(buf, s[i]);
}

void qi_buffer_append_str_escaped(qi_buffer_t *buf, char *s)
{
  while (*s)
  {
    char c = *s++;
    if (c == '"' || c == '\\')
      qi_buffer_append(buf, '\\');

    qi_buffer_append(buf, c);
  }
}

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;
}

char *qi_buffer_get(qi_buffer_t *buf)
{
  char *str = qi_buffer_read(buf);

  qi_free(buf);

  return str;
}

void qi_buffer_destroy(qi_buffer_t *buf)
{
  if (buf->str)
    qi_free(buf->str);

  qi_free(buf);
}

void _qi_add_defer(qi_state_t *state, qi_ssize_t index, qi_defer_t defer,
                   qi_bool is_local)
{
  if (qi_list_empty(state->scopes))
    return;

  qi_scope_t *scope = NULL;

  if (is_local)
  {
    scope = qi_list_last(state->scopes);

    qi_list_insert(scope->defers, index, (void *)defer);

    return;
  }

  for (qi_ssize_t i = state->scopes->length - 1; i >= 0; i--)
  {
    qi_scope_t *tmp = qi_list_index(state->scopes, i);

    if (i == 0 || tmp->is_sticky)
    {
      scope = tmp;

      break;
    }
    else if (tmp->is_barrier)
      break;

    scope = tmp;
  }

  if (!scope)
    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->is_sticky = false;

  scope->mutex = qi_mutex_create();

  qi_list_push(state->scopes, scope);
}

void qi_new_sticky_scope(qi_state_t *state)
{
  qi_new_scope(state);

  ((qi_scope_t *)qi_list_last(state->scopes))->is_sticky = true;
}

static void qi_scope_run_defers(qi_state_t *state, qi_scope_t *scope)
{
  qi_mutex_lock(scope->mutex);

  qi_list_t *defers = scope->defers;

  if (qi_list_empty(defers))
  {
    qi_mutex_unlock(scope->mutex);

    return;
  }

  scope->defers = qi_list_make();

  qi_mutex_unlock(scope->mutex);

  for (qi_size_t i = 0; i < qi_list_length(defers); i++)
  {
    qi_defer_t defer = (qi_defer_t)(qi_list_data(defers, i));

    defer(state);
  }
}

static qi_bool _qi_old_scope(qi_state_t *state, qi_bool ignore_barriers)
{
  qi_scope_t *scope;

  if (qi_list_empty(state->scopes))
    return false;

  scope = qi_list_last(state->scopes);
  if (!ignore_barriers && scope->is_barrier)
    return false;

  qi_scope_run_defers(state, scope);

  qi_list_pop(state->scopes);

  return true;
}

qi_bool qi_old_scope(qi_state_t *state) { return _qi_old_scope(state, false); }

qi_value_t *qi_call_meta(qi_state_t *state, qi_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->mutex)
      qi_mutex_destroy(value->mutex);

    value->mutex = 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->mutex = NULL;

  return value;
}

static qi_value_t *qi_make_uncollectable_value(qi_type_t type)
{
  qi_value_t *value = qi_malloc_uncollectable(sizeof(qi_value_t));

  value->type = type;
  value->mutex = 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_mutex_lock(state->intern_strs_mutex);

    value = qi_table_get(state->intern_strs, string);

    qi_mutex_unlock(state->intern_strs_mutex);

    if (value)
      return value;
  }

  value = qi_make_value(QI_STRING);
  value->value.string = string;

  if (len <= 24)
  {
    qi_mutex_lock(state->intern_strs_mutex);

    qi_table_set(state->intern_strs, string, value);

    qi_mutex_unlock(state->intern_strs_mutex);
  }

  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 || bytes == NULL)
    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)
{
  char string[2];
  string[0] = c;
  string[1] = 0;

  qi_mutex_lock(state->intern_strs_mutex);

  qi_value_t *value = qi_table_get(state->intern_strs, string);

  qi_mutex_unlock(state->intern_strs_mutex);

  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->mutex = qi_mutex_create();
  value->value.list = !list ? qi_list_make() : 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->mutex = qi_mutex_create();
  value->value.table.table = !table ? qi_table_make() : 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;
}

qi_value_t *qi_make_ref(qi_state_t *state, char *name)
{
  qi_ssize_t scopes_count = qi_list_length(state->scopes);

  qi_scope_t *r = NULL;

  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_mutex_lock(scope->mutex);

      qi_symbol_t *symbol = qi_table_get(scope->scope, name);

      qi_mutex_unlock(scope->mutex);

      if (symbol)
      {
        r = scope;

        break;
      }
    }

  if (!r)
    qi_throw_class(state, state->nameerror, "%s", name);

  qi_value_t *value = qi_make_value(QI_REFERENCE);
  value->value.ref.name = name;
  value->value.ref.scope = r;

  return value;
}

static qi_value_t *qi_get_pseudomethod(qi_state_t *state, qi_value_t *value,
                                       char *name)
{
  qi_mutex_lock(state->pseudomethods_mutex);

  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_mutex_unlock(state->pseudomethods_mutex);

  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_mutex_lock(state->pseudomethods_mutex);

  qi_table_set(state->pseudomethods, name, method);

  qi_mutex_unlock(state->pseudomethods_mutex);

  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, qi_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_typeerror(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_class(state, state->valueerror,
                       "__type returned type name should not match builtin "
                       "type names (got '%s')",
                       name);

    return name;
  }

  if (value->type == QI_TABLE)
  {
    qi_mutex_lock(value->mutex);

    if (qi_has_metatable(value))
    {
      qi_mutex_unlock(value->mutex);

      return (char *)qi_repr_type(QI_OBJECT);
    }

    qi_mutex_unlock(value->mutex);
  }

  return (char *)qi_repr_type(value->type);
}

char *_qi_repr(qi_state_t *state, qi_list_t *tempstack, qi_value_t *value,
               qi_bool quote)
{
  char string[128];
  qi_buffer_t *buffer;
  qi_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_typeerror(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_typeerror(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_get(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_get(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_get(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_mutex_unlock(value->mutex);

        return qi_strdup("[]");
      }

      qi_list_push(tempstack, value);

      buffer = qi_buffer_make();

      qi_buffer_append(buffer, '[');

      for (qi_size_t i = 0; i < qi_list_length(value->value.list); i++)
      {
        qi_buffer_append_str(
            buffer, _qi_repr(state, tempstack,
                             qi_list_data(value->value.list, i), true));

        if (i != qi_list_length(value->value.list) - 1)
          qi_buffer_append_str(buffer, ", ");
      }

      qi_buffer_append(buffer, ']');
    });

    return qi_buffer_get(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, '(');

    if (qi_list_length(value->value.list) == 1)
    {
      qi_buffer_append_str(
          buffer,
          _qi_repr(state, tempstack, qi_list_first(value->value.list), true));

      qi_buffer_append_str(buffer, ", ");
    }
    else
      for (qi_size_t i = 0; i < qi_list_length(value->value.list); i++)
      {
        qi_buffer_append_str(
            buffer, _qi_repr(state, tempstack,
                             qi_list_data(value->value.list, i), true));

        if (i != qi_list_length(value->value.list) - 1)
          qi_buffer_append_str(buffer, ", ");
      }

    qi_buffer_append(buffer, ')');

    return qi_buffer_get(buffer);

  case QI_TABLE:
    if (qi_list_contains(tempstack, value))
      return qi_strdup("{...}");

    LOCKED(value, {
      if (qi_table_empty(value->value.table.table))
      {
        qi_mutex_unlock(value->mutex);

        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_escaped(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_get(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);

  case QI_REFERENCE:
    snprintf(string, sizeof(string), "<reference %s>", value->value.ref.name);

    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);
  fputc('\n', stderr);

  va_end(args);

  if (qi_list_length(state->exceptions) > 1)
  {
    for (qi_ssize_t i = (qi_ssize_t)qi_list_length(state->exceptions) - 2; i >= 0; i--)
    {
      char *s = qi_list_data(state->exceptions, i);

      fprintf(stderr, "  While handling an exception: %s\n", s);
    }
  }

  if (__debug_enabled && !qi_list_empty(state->calltrace))
  {
    fputs("Traceback (more recent call last):\n", stderr);

    for (qi_size_t i = 0; i < qi_list_length(state->calltrace); i++)
    {
      qi_list_t *entry = qi_list_data(state->calltrace, i);

      qi_value_t *func = qi_list_data(entry, 0);
      const char *debug_data = qi_list_data(entry, 1);

      if (debug_data)
        fprintf(stderr, "  %s, call to %s\n", debug_data,
                func->value.function.name);
      else
        fprintf(stderr, "  Call to %s\n", func->value.function.name);
    }
  }

  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 = qi_list_length(state->calltrace);

  qi_list_push(state->traps, trap);

  qi_add_local_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);

    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))
  {
    char *s = value == state->recursionerror ? __recerror_msg : qi_repr(state, value, false);
    qi_list_push(state->exceptions, s);

    while (qi_old_scope(state))
      ;

    qi_fatal(state, "uncaught exception: %s", s);
  }

  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));
}

void qi_throw_class(qi_state_t *state, qi_value_t *class, char *format, ...)
{
  char buffer[512];

  va_list args;
  va_start(args, format);

  vsnprintf(buffer, sizeof(buffer), format, args);

  va_end(args);

  qi_list_t *pargs = qi_list_make_n(1);
  qi_list_data(pargs, 0) = qi_make_string_copy(state, buffer);

  qi_throw(state, qi_call(state, class, pargs));
}

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_mutex_lock(scope->mutex);

      qi_symbol_t *symbol = qi_table_get(scope->scope, name);

      if (symbol)
      {
        qi_value_t *value = symbol->value;

        qi_mutex_unlock(scope->mutex);

        return value;
      }

      qi_mutex_unlock(scope->mutex);
    }

  return NULL;
}

qi_value_t *qi_get(qi_state_t *state, char *name)
{
  qi_value_t *value;
  if (strcmp(name, "nil") == 0)
    return state->nil;
  else if (strcmp(name, "true") == 0)
    return state->_true;
  else if (strcmp(name, "false") == 0)
    return state->_false;
  else 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_class(state, state->nameerror, "%s", name);

  return value;
}

static void _qi_decl(qi_state_t *state, char *name, qi_value_t *value,
                     qi_bool is_constant)
{
  qi_scope_t *scope = qi_list_last(state->scopes);
  qi_symbol_t *symbol;

  qi_mutex_lock(scope->mutex);

  symbol = qi_table_get(scope->scope, name);

  if (symbol)
  {
    if (is_constant || symbol->is_constant)
    {
      qi_mutex_unlock(scope->mutex);

      qi_typeerror(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_mutex_unlock(scope->mutex);
}

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_decl_expr(qi_state_t *state, char *name, qi_value_t *value)
{
  _qi_decl(state, name, value, false);

  return value;
}

qi_value_t *_qi_set(qi_state_t *state, qi_bool is_pf, qi_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_mutex_lock(scope->mutex);

      qi_symbol_t *symbol = qi_table_get(scope->scope, name);

      if (symbol)
      {
        if (is_constant || symbol->is_constant)
        {
          qi_mutex_unlock(scope->mutex);

          qi_typeerror(state, "redeclaration of constant symbol: '%s'",
                       name);
        }

        qi_value_t *old = symbol->value;

        symbol->value = value;

        qi_mutex_unlock(scope->mutex);

        return !is_pf ? old : value;
      }

      qi_mutex_unlock(scope->mutex);
    }

  qi_symbol_t *symbol = NULL;
  qi_scope_t *scope = qi_list_last(state->scopes);

  qi_mutex_lock(scope->mutex);

  symbol = qi_table_get(scope->scope, name);

  if (symbol)
  {
    if (is_constant || symbol->is_constant)
    {
      qi_mutex_unlock(scope->mutex);

      qi_typeerror(state, "redeclaration of constant symbol: '%s'", name);
    }

    qi_value_t *old = symbol->value;

    symbol->value = value;

    qi_mutex_unlock(scope->mutex);

    return !is_pf ? old : value;
  }

  symbol = qi_malloc(sizeof(qi_symbol_t));
  symbol->value = value;
  symbol->is_constant = is_constant;

  qi_table_set(scope->scope, name, symbol);

  qi_mutex_unlock(scope->mutex);

  return value;
}

qi_value_t *qi_deref(qi_state_t *state, qi_value_t *value)
{
  qi_value_t *meta;
  qi_bool fail = false;

  if ((meta = qi_call_meta(state, &fail, value, "__deref", 1, value)))
    return meta;

  if (fail)
    goto leave;

  if (value->type == QI_REFERENCE)
  {
    qi_mutex_lock(value->value.ref.scope->mutex);

    qi_symbol_t *symbol =
        qi_table_get(value->value.ref.scope->scope, value->value.ref.name);
    if (!symbol)
    {
      qi_mutex_unlock(value->value.ref.scope->mutex);

      qi_throw_class(state, state->nameerror, "%s",
                     value->value.ref.name);
    }

    qi_value_t *r = symbol->value;

    qi_mutex_unlock(value->value.ref.scope->mutex);

    return r;
  }

leave:
  qi_typeerror(state, "cannot dereference %s", _qi_type(state, value));

  return 0;
}

qi_value_t *qi_set_ref(qi_state_t *state, qi_bool is_pf, qi_value_t *ref,
                       qi_value_t *value)
{
  qi_value_t *meta;
  qi_bool fail = false;

  if ((meta = qi_call_meta(state, &fail, ref, "__set_ref", 2, ref, value)))
    return meta;

  if (fail)
    goto leave;

  if (ref->type == QI_REFERENCE)
  {
    qi_mutex_lock(ref->value.ref.scope->mutex);

    qi_symbol_t *symbol =
        qi_table_get(ref->value.ref.scope->scope, ref->value.ref.name);

    if (symbol)
    {
      if (symbol->is_constant)
      {
        qi_mutex_unlock(ref->value.ref.scope->mutex);

        qi_typeerror(state,
                     "redeclaration of constant symbol (by reference): '%s'",
                     ref->value.ref.name);
      }

      qi_value_t *old = symbol->value;

      symbol->value = value;

      qi_mutex_unlock(ref->value.ref.scope->mutex);

      return !is_pf ? old : value;
    }

    symbol = qi_malloc(sizeof(qi_symbol_t));
    symbol->value = value;

    qi_table_set(ref->value.ref.scope->scope, ref->value.ref.name, symbol);

    qi_mutex_unlock(ref->value.ref.scope->mutex);
  }

leave:
  qi_typeerror(state, "cannot set %s by reference", _qi_type(state, ref));

  return 0;
}

size_t _qi_length(qi_state_t *state, qi_value_t *value)
{
  qi_value_t *meta;
  qi_bool fail = false;

  if ((meta = qi_call_meta(state, &fail, value, "__len", 1, value)))
  {
    if (meta->type != QI_NUMBER)
      qi_typeerror(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_typeerror(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;
  qi_bool fail = false;
  if (index == NULL)
  {
    if ((meta = qi_call_meta(state, &fail, value, "__delval", 1, value)))
      return meta;
  }
  else 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 == NULL)
    {
      LOCKED(value, {
        value->value.list = qi_list_resize(value->value.list, 0);
      });

      return value;
    }
    else if (index->type == QI_NUMBER)
    {
      qi_bool res;

      LOCKED(value,
             { res = qi_list_delete(value->value.list, index->value.number); });

      if (!res)
        qi_throw_class(state, state->indexerror, "%s",
                       qi_repr(state, index, true));

      return value;
    }
    break;

  case QI_TABLE:
    if (index == NULL)
    {
      LOCKED(value, {
        qi_free(value->value.table.table->entries);

        value->value.table.table->used = 0;
        value->value.table.table->capacity = QI_TABLE_MIN_CAP;
        
        value->value.table.table->entries = qi_calloc(value->value.table.table->capacity, sizeof(qi_table_entry_t));

        qi_linkedlist_destroy(value->value.table.table->llh);

        value->value.table.table->llh = NULL;
        value->value.table.table->llc = NULL;
      });

      return value;
    }
    else if (index->type == QI_STRING)
    {
      qi_bool res;

      LOCKED(value, {
        res = qi_table_delete(value->value.table.table, index->value.string);
      });

      if (!res)
        qi_throw_class(state, state->keyerror, "%s", qi_repr(state, index, true));

      return value;
    }
    break;

  default:
    break;
  }

leave:
  if (index == NULL)
    qi_typeerror(state, "cannot delete-value %s", _qi_type(state, value));
  else
    qi_typeerror(state, "cannot delete index %s with %s",
                 _qi_type(state, value), _qi_type(state, index));

  return NULL;
}

qi_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_typeerror(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_TABLE:
  {
    qi_bool res = false;
    LOCKED(value, {
      res = qi_has_metatable(value) &&
            qi_table_length(qi_get_metatable(value)) != 0;
    });

    if (res)
      return true;
  }
  case QI_STRING:
  case QI_BYTES:
  case QI_LIST:
  case QI_TUPLE:
    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;

  qi_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_typeerror(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 && value->value.bytes->data[i]; i++)
        qi_buffer_append(buffer, value->value.bytes->data[i]);

      return qi_make_string(state, qi_buffer_get(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_typeerror(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_atomic(length);

        if (!qi_list_empty(list))
          for (qi_size_t i = 0; i < length; i++)
          {
            qi_value_t *byte = qi_list_data(list, i);

            if (byte->type != QI_NUMBER)
            {
              qi_mutex_unlock(value->mutex);

              qi_free(temp);

              qi_typeerror(state,
                           "cannot cast %s to %s (expected list of numbers, "
                           "but element #%zu is %s)",
                           _qi_type(state, value), qi_repr_type(type), i,
                           _qi_type(state, byte));
            }

            temp[i] = (unsigned char)(byte->value.number);
          }
      });

      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_typeerror(state, "__list returned non-list value (%s)",
                     _qi_type(state, meta));

      return meta;
    }

    if (fail)
      goto leave;

    switch (value->type)
    {
    case QI_STRING:
    {
      qi_size_t length = strlen(value->value.string);
      qi_list_t *list = qi_list_make_n(length);

      for (qi_size_t i = 0; i < length; i++)
        qi_list_data(list, i) = qi_make_char(state, value->value.string[i]);

      return qi_make_list(state, list);
    }

    case QI_BYTES:
    {
      qi_list_t *list = qi_list_make_n(value->value.bytes->size);

      for (qi_size_t i = 0; i < value->value.bytes->size; i++)
        qi_list_data(list, i) =
            qi_make_number(state, value->value.bytes->data[i]);

      return qi_make_list(state, list);
    }

    case QI_TABLE:
    {
      qi_list_t *keys;

      LOCKED(value, { keys = qi_table_keys(value->value.table.table); });

      for (qi_size_t i = 0; i < qi_list_length(keys); i++)
        qi_list_data(keys, i) = qi_make_string(state, qi_list_data(keys, i));

      return qi_make_list(state, keys);
    }

    case QI_TUPLE:
      return qi_make_list(state, qi_list_copy(value->value.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_typeerror(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_mutex_lock(value->mutex);

      qi_list_t *list = value->value.list;
      if (!qi_list_empty(list))
        for (qi_size_t i = 0; i < qi_list_length(list); i++)
        {
          qi_value_t *pair = qi_list_data(list, i);

          if (pair->type == QI_LIST)
            qi_mutex_lock(pair->mutex);

          if ((pair->type != QI_LIST && pair->type != QI_TUPLE) ||
              qi_list_length(pair->value.list) != 2)
          {
            if (value->type == QI_LIST)
              qi_mutex_unlock(value->mutex);
            if (pair->type == QI_LIST)
              qi_mutex_unlock(pair->mutex);

            qi_typeerror(state,
                         "cannot cast %s to %s (expected sequence of pairs)",
                         _qi_type(state, value), qi_repr_type(type));
          }

          qi_value_t *left = qi_list_data(pair->value.list, 0);

          if (left->type != QI_STRING)
          {
            if (value->type == QI_LIST)
              qi_mutex_unlock(value->mutex);
            if (pair->type == QI_LIST)
              qi_mutex_unlock(pair->mutex);

            qi_typeerror(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 = qi_list_data(pair->value.list, 1);

          if (pair->type == QI_LIST)
            qi_mutex_unlock(pair->mutex);

          qi_table_set(table, left->value.string, right);
        }

      if (value->type == QI_LIST)
        qi_mutex_unlock(value->mutex);

      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_typeerror(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;

      LOCKED(value, { list = qi_list_copy(value->value.list); });

      return qi_make_tuple(state, list);
    }

    case QI_BYTES:
    {
      qi_list_t *list = qi_list_make_n(value->value.bytes->size);

      for (qi_size_t i = 0; i < value->value.bytes->size; i++)
        qi_list_data(list, i) =
            qi_make_number(state, value->value.bytes->data[i]);

      return qi_make_tuple(state, list);
    }

    case QI_STRING:
    {
      qi_size_t length = strlen(value->value.string);
      qi_list_t *list = qi_list_make_n(length);

      for (qi_size_t i = 0; i < length; i++)
        qi_list_data(list, i) = qi_make_char(state, value->value.string[i]);

      return qi_make_tuple(state, list);
    }

    default:
      break;
    }
  }

  case QI_REFERENCE:
  {
    qi_value_t *meta;
    if ((meta = qi_call_meta(state, &fail, value, "__ref", 1, value)))
    {
      if (meta->type != QI_REFERENCE)
        qi_typeerror(state, "__ref returned non-reference value (%s)",
                     _qi_type(state, meta));

      return meta;
    }

    if (fail)
      goto leave;

    switch (value->type)
    {
    case QI_STRING:
      return qi_make_ref(state, value->value.string);

    default:
      break;
    }
  }
  break;

  default:
    break;
  }

leave:
  qi_typeerror(state, "cannot cast %s to %s", _qi_type(state, value),
               qi_repr_type(type));

  return NULL;
}

qi_bool qi_is_iter(qi_state_t *state, qi_value_t *value)
{
  return qi_get_method(state, value, "__begin") != NULL &&
         qi_get_method(state, value, "__next") != NULL &&
         qi_get_method(state, value, "__end") != NULL;
}

qi_value_t *qi_iter(qi_state_t *state, qi_value_t *value)
{
  if (qi_is_iter(state, value))
    return qi_iter_begin(state, value);

  qi_value_t *meta;
  qi_bool fail = false;
  if ((meta = qi_call_meta(state, &fail, value, "__iter", 1, value)))
  {
    if (!qi_is_iter(state, meta))
      qi_typeerror(state, "__iter returned not an iterator (%s)",
                   _qi_type(state, meta));

    return meta;
  }

  if (fail)
    goto leave;

  if (value->type == QI_LIST || value->type == QI_TUPLE ||
      value->type == QI_BYTES || value->type == QI_TABLE || value->type == QI_STRING)
  {
    qi_list_t *pargs = qi_list_make_n(1);
    qi_list_data(pargs, 0) = value;

    return qi_call(state, state->listiterator, pargs);
  }

leave:
  qi_typeerror(state, "cannot iterate %s", _qi_type(state, value));

  return NULL;
}

qi_value_t *qi_index(qi_state_t *state, qi_value_t *value, qi_value_t *index)
{
  qi_value_t *meta;
  qi_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_class(state, state->indexerror, "%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_class(state, state->indexerror, "%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_class(state, state->indexerror, "%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_class(state, state->indexerror, "%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_class(state, state->keyerror, "%s", qi_repr(state, index, true));

      return indexed;
    }
    break;

  default:
    break;
  }

leave:
  qi_typeerror(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, qi_bool is_pf, qi_value_t *value,
                         qi_value_t *index, qi_value_t *newvalue)
{
  qi_value_t *meta;
  qi_bool fail = false;

  if (value->type == QI_TABLE && index->type == QI_STRING)
  {
    qi_bool has_mt = false;

    LOCKED(value, {
      has_mt = qi_has_metatable(value) &&
               qi_table_has(qi_get_metatable(value), index->value.string);
    });

    if (has_mt)
    {
      qi_value_t *old;

      LOCKED(value, {
        if (!is_pf)
          old = qi_table_get(qi_get_metatable(value), index->value.string);

        qi_table_set(qi_get_metatable(value), index->value.string, newvalue);
      });

      return !is_pf && old ? old : newvalue;
    }
  }

  if ((meta = qi_call_meta(state, &fail, value, "__index_set", 3, value, index,
                           newvalue)))
    return meta;

  if (fail)
    goto leave;

  switch (value->type)
  {
  case QI_LIST:
    if (index->type == QI_NUMBER)
    {
      qi_value_t *old;

      LOCKED(value, {
        if (!is_pf)
          old = qi_list_index(value->value.list,
                              (qi_ssize_t)(index->value.number));

        qi_list_set(value->value.list, (qi_ssize_t)(index->value.number),
                    newvalue);
      });

      if (!newvalue)
        qi_throw_class(state, state->indexerror, "%s",
                       qi_repr(state, index, true));

      return !is_pf && old ? old : newvalue;
    }
    break;

  case QI_TABLE:
    if (index->type == QI_STRING)
    {
      qi_value_t *old;

      LOCKED(value, {
        if (!is_pf)
          old = qi_table_get(value->value.table.table, index->value.string);

        qi_table_set(value->value.table.table, index->value.string, newvalue);
      });

      return !is_pf && old ? old : newvalue;
    }
    break;

  default:
    break;
  }

leave:
  qi_typeerror(state, "cannot set index %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 (qi_list_length(state->calltrace) >= state->rlimit)
    qi_throw(state, state->recursionerror);

  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_typeerror(state, "cannot call %s", _qi_type(state, value));
  }

  if (value->value.function._this)
  {
    qi_list_t *temp = !pargs ? qi_list_make() : qi_list_copy(pargs);
    qi_list_insert(temp, 0, value->value.function._this);

    pargs = temp;
  }

  qi_size_t pargc = !pargs ? 0 : qi_list_length(pargs);

  if (pargc < value->value.function.pargc)
    qi_typeerror(state,
                 "not enough positional arguments in call to '%s': need at "
                 "least %zu, got %zu",
                 value->value.function.name, value->value.function.pargc,
                 pargc);

  qi_push_trace(state, value, debug_data);

  if (!value->value.function.is_builtin)
  {
    qi_new_sticky_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);

  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);
}

static qi_bool _qi_guarded_equals(qi_state_t *state, qi_size_t depth,
                                  qi_list_t *tempstack, 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_typeerror(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_typeerror(state, "__equals returned non-boolean value (%s)",
                   _qi_type(state, meta));

    return meta->value.boolean;
  }

  if (depth >= state->rlimit)
    qi_throw(state, state->recursionerror);

  if (a == b)
    return true;

  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:
    if (qi_list_contains(tempstack, a) || qi_list_contains(tempstack, b))
      return true;

    qi_list_push(tempstack, a);
    qi_list_push(tempstack, b);

    if (a->value.list == b->value.list)
      return true;

    qi_mutex_lock(a->mutex);
    qi_mutex_lock(b->mutex);

    if (qi_list_length(a->value.list) != qi_list_length(b->value.list))
    {
      qi_mutex_unlock(a->mutex);
      qi_mutex_unlock(b->mutex);

      return false;
    }

    for (qi_size_t i = 0; i < qi_list_length(a->value.list); i++)
      if (!_qi_guarded_equals(state, depth + 1, tempstack,
                              qi_list_index(a->value.list, i),
                              qi_list_index(b->value.list, i)))
      {
        qi_mutex_unlock(a->mutex);
        qi_mutex_unlock(b->mutex);

        return false;
      }

    qi_mutex_unlock(a->mutex);
    qi_mutex_unlock(b->mutex);

    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_guarded_equals(state, depth + 1, tempstack,
                              qi_list_index(a->value.list, i),
                              qi_list_index(b->value.list, i)))
        return false;

    return true;

  case QI_TABLE:
    if (qi_list_contains(tempstack, a) || qi_list_contains(tempstack, b))
      return true;

    qi_list_push(tempstack, a);
    qi_list_push(tempstack, b);

    if (a->value.table.table == b->value.table.table)
      return true;

    qi_mutex_lock(a->mutex);
    qi_mutex_lock(b->mutex);

    if (qi_table_length(a->value.table.table) !=
        qi_table_length(b->value.table.table))
    {
      qi_mutex_unlock(a->mutex);
      qi_mutex_unlock(b->mutex);

      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_mutex_unlock(a->mutex);
        qi_mutex_unlock(b->mutex);

        return false;
      }

      if (!_qi_guarded_equals(state, depth + 1, tempstack, a_value, b_value))
      {
        qi_mutex_unlock(a->mutex);
        qi_mutex_unlock(b->mutex);

        return false;
      }
    });

    qi_mutex_unlock(a->mutex);
    qi_mutex_unlock(b->mutex);

    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;

  case QI_REFERENCE:
    return strcmp(a->value.ref.name, b->value.ref.name) == 0 &&
           a->value.ref.scope == b->value.ref.scope;

  default:
    return true;
  }

  return true;
}

qi_bool _qi_equals(qi_state_t *state, qi_value_t *a, qi_value_t *b)
{
  return _qi_guarded_equals(state, 0, qi_list_make(), a, b);
}

qi_bool _qi_in(qi_state_t *state, qi_value_t *a, qi_value_t *b)
{
  qi_value_t *meta;
  qi_bool fail = false;

  if ((meta = qi_call_meta(state, &fail, b, "__in", 2, b, a)))
  {
    if (meta->type != QI_BOOLEAN)
      qi_typeerror(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_BYTES && b->type == QI_BYTES)
  {
    if (a->value.bytes->size == 0)
      return true;

    if (b->value.bytes->size == 0)
      return false;

    for (qi_size_t i = 0; i < b->value.bytes->size; i++)
    {
      if (b->value.bytes->size - i < a->value.bytes->size)
        return false;

      if (memcmp(b->value.bytes->data + i, a->value.bytes->data, a->value.bytes->size) == 0)
        return true;
    }

    return false;
  }
  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_mutex_unlock(b->mutex);

        return false;
      }

      for (qi_size_t i = 0; i < qi_list_length(list); i++)
        if (_qi_equals(state, a, qi_list_data(list, i)))
        {
          qi_mutex_unlock(b->mutex);

          return true;
        }
    });

    return false;
  }
  else if (b->type == QI_TUPLE)
  {
    qi_list_t *list = b->value.list;

    if (qi_list_empty(list))
      return false;

    for (qi_size_t i = 0; i < qi_list_length(list); i++)
      if (_qi_equals(state, a, qi_list_data(list, i)))
        return true;

    return false;
  }
  else if (a->type == QI_STRING && b->type == QI_TABLE)
  {
    qi_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_typeerror(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;
  qi_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 b;
    else if (!*b->value.string)
      return a;

    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_STRING && b->type == QI_NUMBER && *a->value.string &&
           !a->value.string[1])
  {
    char buf[2];
    buf[0] = *a->value.string + b->value.number;
    buf[1] = 0;

    return qi_make_string_copy(state, buf);
  }
  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 b;
    else if (b->value.bytes->size == 0)
      return a;

    qi_size_t size = a->value.bytes->size + b->value.bytes->size;
    unsigned char *bytes = qi_malloc_atomic(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 a;

    qi_list_t *newlist = qi_list_make();

    if (a->type == QI_LIST)
    {
      qi_mutex_lock(a->mutex);
      qi_mutex_lock(b->mutex);

      if (!a->value.list->length && !b->value.list->length)
      {
        qi_mutex_unlock(a->mutex);
        qi_mutex_unlock(b->mutex);

        return qi_make_list(state, newlist);
      }
    }

    for (qi_size_t i = 0; i < qi_list_length(a->value.list); i++)
      qi_list_push(newlist, qi_list_data(a->value.list, i));

    if (a->type == QI_LIST)
      qi_mutex_unlock(a->mutex);

    for (qi_size_t i = 0; i < qi_list_length(b->value.list); i++)
      qi_list_push(newlist, qi_list_data(b->value.list, i));

    if (a->type == QI_LIST)
      qi_mutex_unlock(b->mutex);

    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_mutex_lock(a->mutex);
    qi_mutex_lock(b->mutex);

    qi_table_iterate(a->value.table.table,
                     { qi_table_set(newtable, entry.key, entry.value); });

    qi_mutex_unlock(a->mutex);

    qi_table_iterate(b->value.table.table,
                     { qi_table_set(newtable, entry.key, entry.value); });

    qi_mutex_unlock(b->mutex);

    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_typeerror(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;
  qi_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_STRING && b->type == QI_NUMBER && *a->value.string &&
      !a->value.string[1])
  {
    char buf[2];
    buf[0] = *a->value.string - b->value.number;
    buf[1] = 0;

    return qi_make_string_copy(state, buf);
  }
  else if (a->type == QI_NUMBER && b->type == QI_NUMBER)
    return qi_make_number(state, a->value.number - b->value.number);

leave:
  qi_typeerror(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;
  qi_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);
  else if (a->type == QI_STRING && b->type == QI_NUMBER)
  {
    qi_size_t n = (qi_size_t)fabs(b->value.number);

    if (n < 1)
      return state->empty_string;
    else if (n == 1)
      return a;

    qi_buffer_t *buffer = qi_buffer_make();

    for (qi_size_t i = 0; i < n; i++)
      qi_buffer_append_str(buffer, a->value.string);

    return qi_make_string(state, qi_buffer_get(buffer));
  }
  else if ((a->type == QI_LIST || a->type == QI_TUPLE) && b->type == QI_NUMBER)
  {
    qi_size_t n = (qi_size_t)fabs(b->value.number);

    if (a->type == QI_TUPLE && n == 1)
      return a;

    if (a->type == QI_LIST)
      qi_mutex_lock(a->mutex);

    qi_size_t l = a->value.list->length;
    qi_list_t *r = NULL;

    if (l < 1 || n < 1)
    {
      if (a->type == QI_TUPLE)
        return state->empty_tuple;

      goto empty;
    }

    qi_size_t rl = l * n;

    r = qi_list_make_n(rl);

    for (qi_size_t i = 0, j = 0; i < rl; i++)
    {
      r->data[i] = a->value.list->data[j];

      j++;

      if (j >= l)
        j = 0;
    }

  empty:
    if (a->type == QI_LIST)
      qi_mutex_unlock(a->mutex);

    return a->type == QI_LIST ? qi_make_list(state, r) : qi_make_tuple(state, r);
  }
  else if (a->type == QI_BYTES && b->type == QI_NUMBER)
  {
    qi_size_t n = (qi_size_t)fabs(b->value.number);

    if (n == 1)
      return a;
    else if (n < 1)
      return state->empty_bytes;

    qi_size_t l = a->value.bytes->size;
    if (l < 1)
      return state->empty_bytes;

    qi_size_t rl = l * n;
    unsigned char *r = qi_malloc_atomic(rl);

    for (qi_size_t i = 0, j = 0; i < rl; i++)
    {
      r[i] = a->value.bytes->data[j];

      j++;

      if (j >= l)
        j = 0;
    }

    return qi_make_bytes(state, r, rl);
  }

leave:
  qi_typeerror(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;
  qi_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_typeerror(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;
  qi_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_typeerror(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;
  qi_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_typeerror(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;
  qi_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_typeerror(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;
  qi_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_typeerror(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;
  qi_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_typeerror(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;
  qi_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_typeerror(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;
  qi_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_typeerror(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;
  qi_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_typeerror(state, "unsupported operand types for >>: %s and %s",
               _qi_type(state, a), _qi_type(state, b));

  return NULL;
}

qi_bool _qi_lt(qi_state_t *state, qi_value_t *a, qi_value_t *b)
{
  qi_value_t *meta;
  qi_bool fail = false;
  if ((meta = qi_call_meta(state, &fail, a, "__lt", 2, a, b)))
  {
    if (meta->type != QI_BOOLEAN)
      qi_typeerror(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_typeerror(state, "unsupported operand types for <: %s and %s",
               _qi_type(state, a), _qi_type(state, b));

  return false;
}

qi_bool _qi_gt(qi_state_t *state, qi_value_t *a, qi_value_t *b)
{
  qi_value_t *meta;
  qi_bool fail = false;
  if ((meta = qi_call_meta(state, &fail, a, "__gt", 2, a, b)))
  {
    if (meta->type != QI_BOOLEAN)
      qi_typeerror(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_typeerror(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;
  qi_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_typeerror(state, "unsupported operand type for unary -: %s",
               _qi_type(state, a));

  return NULL;
}

qi_value_t *qi_unary_plus(qi_state_t *state, qi_value_t *a)
{
  qi_value_t *meta;
  qi_bool fail = false;
  if ((meta = qi_call_meta(state, &fail, a, "__unary_plus", 1, a)))
    return meta;

  if (fail)
    goto leave;

  if (a->type == QI_NUMBER)
    return a;

leave:
  qi_typeerror(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;
  qi_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_typeerror(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->mutex = 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->exceptions = qi_list_make();
  newstate->scopes = qi_list_copy(state->scopes);
  qi_set_barrier(newstate);

  newstate->calltrace = qi_list_copy(state->calltrace);

  return newstate;
}

void qi_exit(qi_state_t *state, int code)
{
  while (_qi_old_scope(state, true))
    ;

  qi_finalize();

  exit(code);
}

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);
}

qi_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_mutex_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_mutex_destroy(void *mutex)
{
  pthread_mutex_destroy((pthread_mutex_t *)mutex);
  qi_free(mutex);
}

void qi_mutex_lock(void *mutex)
{
  pthread_mutex_lock((pthread_mutex_t *)mutex);
}

qi_bool qi_mutex_trylock(void *mutex)
{
  if (pthread_mutex_trylock((pthread_mutex_t *)mutex) == 0)
    return true;

  return false;
}

void qi_mutex_unlock(void *mutex)
{
  pthread_mutex_unlock((pthread_mutex_t *)mutex);
}

void *qi_cond_create(void)
{
  pthread_cond_t *cond = qi_malloc_atomic(sizeof(pthread_cond_t));
  if (pthread_cond_init(cond, NULL) != 0)
    return NULL;

  return (void *)cond;
}

void qi_cond_destroy(void *cond)
{
  pthread_cond_destroy((pthread_cond_t *)cond);
  qi_free(cond);
}

void qi_cond_wait(void *cond, void *mutex)
{
  pthread_cond_wait((pthread_cond_t *)cond, (pthread_mutex_t *)mutex);
}

void qi_cond_signal(void *cond) { pthread_cond_signal((pthread_cond_t *)cond); }

void qi_cond_broadcast(void *cond)
{
  pthread_cond_broadcast((pthread_cond_t *)cond);
}

qi_value_t *qi_builtin_print(qi_state_t *state, qi_size_t pargc,
                             qi_list_t *pargs)
{
  qi_bool first = true;

  for (int i = 0; i < pargc; i++)
  {
    qi_value_t *a = qi_list_data(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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_TABLE)
    qi_typeerror(state, "expected first argument to be: table, but got: %s",
                 _qi_type(state, a));

  if (b->type != QI_TABLE)
    qi_typeerror(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_data(pargs, 0);

  if (a->type != QI_TABLE)
    qi_typeerror(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_data(pargs, 0);

  if (a->type != QI_TABLE)
    qi_typeerror(state, "expected first argument to be: table, but got: %s",
                 _qi_type(state, a));

  qi_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_data(pargs, 0);

  if (a->type != QI_TABLE)
    qi_typeerror(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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_TABLE)
    qi_typeerror(state, "expected first argument to be: table, but got: %s",
                 _qi_type(state, a));

  if (b->type != QI_STRING)
    qi_typeerror(state,
                 "expected second argument to be: string, but got: %s",
                 _qi_type(state, b));

  qi_value_t *value;
  qi_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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_TABLE)
    qi_typeerror(state, "expected first argument to be: table, but got: %s",
                 _qi_type(state, a));

  if (b->type != QI_STRING)
    qi_typeerror(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_mutex_unlock(a->mutex);

        qi_throw_class(state, state->keyerror, "%s", b->value.string);
      }
  });

  return state->nil;
}

qi_value_t *qi_builtin_set_pseudomethod(qi_state_t *state, qi_size_t pargc,
                                        qi_list_t *pargs)
{
  qi_value_t *a = qi_list_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_STRING)
    qi_typeerror(state, "expected first argument to be: string, but got: %s",
                 _qi_type(state, a));

  if (b->type != QI_FUNCTION)
    qi_typeerror(state,
                 "expected second argument to be: function, but got: %s",
                 _qi_type(state, b));

  char *name = a->value.string;

  qi_value_t *method = qi_make_function(state, name, b->value.function.pargc,
                                        b->value.function.handle, NULL);
  method->value.function.is_pm = true;

  qi_mutex_lock(state->pseudomethods_mutex);

  qi_table_set(state->pseudomethods, name, method);

  qi_mutex_unlock(state->pseudomethods_mutex);

  return method;
}

qi_value_t *qi_builtin_has_pseudomethod(qi_state_t *state, qi_size_t pargc,
                                        qi_list_t *pargs)
{
  qi_value_t *a = qi_list_data(pargs, 0);

  if (a->type != QI_STRING)
    qi_typeerror(state, "expected first argument to be: string, but got: %s",
                 _qi_type(state, a));

  qi_mutex_lock(state->pseudomethods_mutex);

  qi_bool res = qi_table_has(state->pseudomethods, a->value.string);

  qi_mutex_unlock(state->pseudomethods_mutex);

  return res ? state->_true : state->_false;
}

qi_value_t *qi_builtin_unset_pseudomethod(qi_state_t *state, qi_size_t pargc,
                                          qi_list_t *pargs)
{
  qi_value_t *a = qi_list_data(pargs, 0);

  if (a->type != QI_STRING)
    qi_typeerror(state, "expected first argument to be: string, but got: %s",
                 _qi_type(state, a));

  qi_mutex_lock(state->pseudomethods_mutex);

  qi_bool res = qi_table_delete(state->pseudomethods, a->value.string);

  qi_mutex_unlock(state->pseudomethods_mutex);

  if (!res)
    qi_typeerror(state, "no such pseudomethod: '%s'", a->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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);
  qi_value_t *c = qi_list_data(pargs, 2);
  if (!c)
    c = state->zero;
  else if (c->type != QI_NUMBER)
    qi_typeerror(state, "expected third argument to be: number, but got: %s",
                 _qi_type(state, c));

  if (a->type != QI_STRING)
    qi_typeerror(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_class(state, state->indexerror, "illegal scope index: %s",
                     qi_repr(state, c, true));
  }
  else
    scope = qi_list_first(state->scopes);

  qi_mutex_lock(scope->mutex);

  symbol = qi_table_get(scope->scope, name);
  if (symbol)
  {
    if (symbol->is_constant)
    {
      qi_mutex_unlock(scope->mutex);

      qi_typeerror(state, "redeclaration of constant symbol: '%s'", name);
    }

    qi_value_t *ret = symbol->value;
    symbol->value = b;

    qi_mutex_unlock(scope->mutex);

    return ret;
  }

  symbol = qi_malloc(sizeof(qi_symbol_t));
  symbol->value = b;
  symbol->is_constant = false;

  qi_table_set(scope->scope, name, symbol);

  qi_mutex_unlock(scope->mutex);

  return b;
}

qi_value_t *qi_builtin_unset_global(qi_state_t *state, qi_size_t pargc,
                                    qi_list_t *pargs)
{
  qi_value_t *a = qi_list_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);
  if (!b)
    b = state->zero;
  else if (b->type != QI_NUMBER)
    qi_typeerror(state,
                 "expected second argument to be: number, but got: %s",
                 _qi_type(state, b));

  if (a->type != QI_STRING)
    qi_typeerror(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)(b->value.number);
  qi_scope_t *scope;

  if (offset > 0)
  {
    scope = qi_list_index(state->scopes, -((qi_ssize_t)offset));

    if (!scope)
      qi_throw_class(state, state->indexerror, "illegal scope index: %s",
                     qi_repr(state, b, true));
  }
  else
    scope = qi_list_first(state->scopes);

  qi_mutex_lock(scope->mutex);

  symbol = qi_table_get(scope->scope, name);
  if (symbol)
  {
    if (symbol->is_constant)
    {
      qi_mutex_unlock(scope->mutex);

      qi_typeerror(state, "cannot unset constant symbol: '%s'", name);
    }

    qi_value_t *ret = symbol->value;

    qi_table_delete(scope->scope, name);

    qi_mutex_unlock(scope->mutex);

    return ret;
  }

  qi_mutex_unlock(scope->mutex);

  return state->nil;
}

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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);
  if (!b)
    b = state->zero;
  else if (b->type != QI_NUMBER)
    qi_typeerror(state,
                 "expected second argument to be: number, but got: %s",
                 _qi_type(state, b));

  if (a->type != QI_STRING)
    qi_typeerror(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_class(state, state->indexerror, "illegal scope index: %s",
                     qi_repr(state, b, true));
  }
  else
    scope = qi_list_first(state->scopes);

  qi_mutex_lock(scope->mutex);

  qi_symbol_t *symbol = qi_table_get(scope->scope, name);

  if (symbol)
    ret = symbol->value;

  qi_mutex_unlock(scope->mutex);

  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_mutex_lock(scope->mutex);

  qi_table_iterate(scope->scope, {
    qi_symbol_t *symbol = entry.value;

    qi_table_set(table, entry.key, symbol->value);
  });

  qi_mutex_unlock(scope->mutex);

  return qi_make_table(state, table);
}

qi_value_t *qi_builtin_get_rlimit(qi_state_t *state, qi_size_t pargc,
                                  qi_list_t *pargs)
{
  return qi_make_number(state, state->rlimit);
}

qi_value_t *qi_builtin_set_rlimit(qi_state_t *state, qi_size_t pargc,
                                  qi_list_t *pargs)
{
  qi_value_t *a = qi_list_data(pargs, 0);

  if (a->type != QI_NUMBER)
    qi_typeerror(state, "expected first argument to be: number, but got: %s",
                 _qi_type(state, a));

  state->rlimit = (size_t)a->value.number;

  return state->nil;
}

#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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_STRING)
    qi_typeerror(state, "expected first argument to be: string, but got: %s",
                 _qi_type(state, a));

  if (b->type != QI_STRING)
    qi_typeerror(state,
                 "expected second argument to be: string, but got: %s",
                 _qi_type(state, b));

  if (!is_valid_mode(b->value.string))
    qi_throw_class(state, state->valueerror, "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_class(state, state->ioerror, "cannot open file: %s", qi_repr(state, a, true));

  return qi_make_file(state, file, b->value.string);
}

static unsigned char *_read_stdin(qi_size_t *count)
{
  *count = 0;

  qi_buffer_t *buffer = qi_buffer_make();

  int c;
  while ((c = fgetc(stdin)) != EOF)
    qi_buffer_append(buffer, c), (*count)++;

  return (unsigned char *)qi_buffer_get(buffer);
}

#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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_FILE)
    qi_typeerror(state, "expected first argument to be: file, but got: %s",
                 _qi_type(state, a));

  if (b->type != QI_NUMBER)
    qi_typeerror(state,
                 "expected second argument to be: number, but got: %s",
                 _qi_type(state, b));

  if (!a->value.file.is_open)
    qi_throw_class(state, state->ioerror, "file is already closed");

  if (!is_valid_read_mode(a->value.file.mode))
    qi_throw_class(state, state->ioerror, "file is not readable");

  qi_size_t size;
  if (b->value.number < 0)
  {
    if (a->value.file.fd == stdin)
    {
      qi_size_t count;
      unsigned char *data = _read_stdin(&count);

      return qi_make_bytes(state, data, count);
    }

    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_atomic(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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_FILE)
    qi_typeerror(state, "expected first argument to be: file, but got: %s",
                 _qi_type(state, a));

  if (b->type != QI_NUMBER)
    qi_typeerror(state,
                 "expected second argument to be: number, but got: %s",
                 _qi_type(state, b));

  if (!a->value.file.is_open)
    qi_throw_class(state, state->ioerror, "file is already closed");

  if (!is_valid_read_mode(a->value.file.mode))
    qi_throw_class(state, state->ioerror, "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_class(state, state->ioerror, "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_data(pargs, 0);

  if (a->type != QI_FILE)
    qi_typeerror(state, "expected first argument to be: file, but got: %s",
                 _qi_type(state, a));

  if (!a->value.file.is_open)
    qi_throw_class(state, state->ioerror, "file is already closed");

  if (!is_valid_read_mode(a->value.file.mode))
    qi_throw_class(state, state->ioerror, "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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_FILE)
    qi_typeerror(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_typeerror(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_class(state, state->ioerror, "file is already closed");

  if (!is_valid_write_mode(a->value.file.mode))
    qi_throw_class(state, state->ioerror, "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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_FILE)
    qi_typeerror(state, "expected first argument to be: file, but got: %s",
                 _qi_type(state, a));

  if (b->type == QI_STRING || b->type == QI_LIST)
    b = qi_to_bytes(state, b);

  if (b->type != QI_BYTES)
    qi_typeerror(state, "expected second argument to be: bytes, but got: %s",
                 _qi_type(state, b));

  if (!a->value.file.is_open)
    qi_throw_class(state, state->ioerror, "file is already closed");

  if (!is_valid_write_mode(a->value.file.mode))
    qi_throw_class(state, state->ioerror, "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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_FILE)
    qi_typeerror(state, "expected first argument to be: file, but got: %s",
                 _qi_type(state, a));

  if (b->type != QI_STRING)
    qi_typeerror(state,
                 "expected second argument to be: string, but got: %s",
                 _qi_type(state, b));

  if (!a->value.file.is_open)
    qi_throw_class(state, state->ioerror, "file is already closed");

  if (!is_valid_write_mode(a->value.file.mode))
    qi_throw_class(state, state->ioerror, "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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);
  qi_value_t *c = qi_list_data(pargs, 2);

  if (a->type != QI_FILE)
    qi_typeerror(state, "expected first argument to be: file, but got: %s",
                 _qi_type(state, a));

  if (b->type != QI_NUMBER)
    qi_typeerror(state,
                 "expected second argument to be: number, but got: %s",
                 _qi_type(state, b));

  if (c->type != QI_NUMBER)
    qi_typeerror(state, "expected third argument to be: number, but got: %s",
                 _qi_type(state, c));

  if (!a->value.file.is_open)
    qi_throw_class(state, state->ioerror, "file is already 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_data(pargs, 0);

  if (a->type != QI_FILE)
    qi_typeerror(state, "expected first argument to be: file, but got: %s",
                 _qi_type(state, a));

  if (!a->value.file.is_open)
    qi_throw_class(state, state->ioerror, "file is already 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_data(pargs, 0);

  if (a->type != QI_FILE)
    qi_typeerror(state, "expected first argument to be: file, but got: %s",
                 _qi_type(state, a));

  if (!a->value.file.is_open)
    qi_throw_class(state, state->ioerror, "file is already 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_data(pargs, 0);

  if (a->type != QI_FILE)
    qi_typeerror(state, "expected first argument to be: file, but got: %s",
                 _qi_type(state, a));

  if (!a->value.file.is_open)
    qi_throw_class(state, state->ioerror, "file is already closed");

  if (a->value.file.fd == stdin || a->value.file.fd == stderr ||
      a->value.file.fd == stdout)
    qi_throw_class(state, state->ioerror, "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_data(pargs, 0);

  if (a->type != QI_FILE)
    qi_typeerror(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_data(pargs, 0);

  if (a->type != QI_NUMBER)
    qi_typeerror(state, "expected first argument to be: number, but got: %s",
                 _qi_type(state, a));

  unsigned char c = (int)(a->value.number);
  if (c == 0)
    qi_throw_class(state, state->valueerror, "illegal character code");

  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_data(pargs, 0);

  if (a->type != QI_STRING || strlen(a->value.string) != 1)
    qi_throw_class(
        state, state->typeerror, "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_data(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_data(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_data(pargs, 0);

  if (a->type != QI_LIST)
    qi_typeerror(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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_LIST)
    qi_typeerror(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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);
  qi_value_t *c = qi_list_data(pargs, 2);

  if (a->type != QI_LIST)
    qi_typeerror(state, "expected first argument to be: list, but got: %s",
                 _qi_type(state, a));

  if (b->type != QI_NUMBER)
    qi_typeerror(state,
                 "expected second argument to be: number, but got: %s",
                 _qi_type(state, b));

  qi_bool res = false;

  LOCKED(a, { res = qi_list_insert(a->value.list, b->value.number, c); });

  if (!res)
    qi_throw_class(state, state->indexerror, "%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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_LIST)
    qi_typeerror(state, "expected first argument to be: list, but got: %s",
                 _qi_type(state, a));

  if (b->type != QI_NUMBER)
    qi_typeerror(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_data(pargs, 0);

  if (a->type != QI_LIST)
    qi_typeerror(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_class(state, state->indexerror, "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_data(pargs, 0);

  if (a->type != QI_TABLE)
    qi_typeerror(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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_TABLE)
    qi_typeerror(state, "expected first argument to be: table, but got: %s",
                 _qi_type(state, a));

  if (b->type != QI_STRING)
    b = qi_to_string(state, b);

  qi_del(state, a, b);

  return a;
}

qi_value_t *qi_builtin_table_get(qi_state_t *state, qi_size_t pargc,
                                 qi_list_t *pargs)
{
  qi_value_t *a = qi_list_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);
  qi_value_t *c = pargc >= 3 ? qi_list_data(pargs, 2) : state->nil;

  if (a->type != QI_TABLE)
    qi_typeerror(state, "expected first argument to be: table, but got: %s",
                 _qi_type(state, a));

  if (b->type != QI_STRING)
    b = qi_to_string(state, b);

  LOCKED(a, {
    qi_value_t *tmp = NULL;

    if ((tmp = qi_table_get(a->value.table.table, b->value.string)))
      c = tmp;
  });

  return c;
}

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_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_FUNCTION)
    qi_typeerror(state,
                 "expected first argument to be: function, but got: %s",
                 _qi_type(state, a));

  if (b->type != QI_LIST && b->type != QI_TUPLE)
    qi_typeerror(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_data(pargs, 0);

  if (a->type != QI_FUNCTION)
    qi_typeerror(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_data(pargs, 0);

  if (a->type != QI_FUNCTION)
    qi_typeerror(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_data(pargs, 0);

  if (a->type != QI_DATA)
    qi_typeerror(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_data(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_data(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_data(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_data(pargs, 0);

  return qi_to_number(state, a);
}

qi_value_t *qi_builtin_int(qi_state_t *state, qi_size_t pargc,
                           qi_list_t *pargs)
{
  qi_value_t *a = qi_list_data(pargs, 0);

  qi_value_t *value = qi_to_number(state, a);
  value->value.number = (long)value->value.number;

  return value;
}

qi_value_t *qi_builtin_bytes(qi_state_t *state, qi_size_t pargc,
                             qi_list_t *pargs)
{
  qi_value_t *a = qi_list_data(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_data(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_data(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_data(pargs, 0);

  return qi_to_table(state, a);
}

qi_value_t *qi_builtin_ref(qi_state_t *state, qi_size_t pargc,
                           qi_list_t *pargs)
{
  qi_value_t *a = qi_list_data(pargs, 0);

  return qi_to_ref(state, a);
}

qi_value_t *qi_builtin_iter(qi_state_t *state, qi_size_t pargc,
                            qi_list_t *pargs)
{
  qi_value_t *a = qi_list_data(pargs, 0);

  return qi_iter(state, a);
}

qi_value_t *qi_builtin_iter_next(qi_state_t *state, qi_size_t pargc,
                                 qi_list_t *pargs)
{
  qi_value_t *a = qi_list_data(pargs, 0);

  if (!qi_is_iter(state, a))
    qi_typeerror(state,
                 "expected first argument to be an iterator, but got: %s",
                 _qi_type(state, a));

  return qi_iter_next(state, a);
}

qi_value_t *qi_builtin_iter_end(qi_state_t *state, qi_size_t pargc,
                                qi_list_t *pargs)
{
  qi_value_t *a = qi_list_data(pargs, 0);

  if (!qi_is_iter(state, a))
    qi_typeerror(state,
                 "expected first argument to be an iterator, but got: %s",
                 _qi_type(state, a));

  return qi_make_boolean(state, qi_iter_end(state, a));
}

qi_value_t *qi_builtin_deref(qi_state_t *state, qi_size_t pargc,
                             qi_list_t *pargs)
{
  qi_value_t *a = qi_list_data(pargs, 0);

  if (a->type != QI_REFERENCE)
    qi_typeerror(state,
                 "expected first argument to be: reference, but got: %s",
                 _qi_type(state, a));

  return qi_deref(state, a);
}

qi_value_t *qi_builtin_ref_set(qi_state_t *state, qi_size_t pargc,
                               qi_list_t *pargs)
{
  qi_value_t *a = qi_list_data(pargs, 0);
  qi_value_t *b = qi_list_data(pargs, 1);

  if (a->type != QI_REFERENCE)
    qi_typeerror(state,
                 "expected first argument to be: reference, but got: %s",
                 _qi_type(state, a));

  return qi_set_ref(state, false, a, b);
}

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_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_n(2);
    qi_list_data(new_pargs, 0) = qi_list_first(pargs);
    qi_list_data(new_pargs, 1) = 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_n(3);
  qi_list_data(new_pargs, 0) = qi_list_first(pargs);
  qi_list_data(new_pargs, 1) = qi_make_number(state, 0);
  qi_list_data(new_pargs, 2) = qi_make_number(state, SEEK_SET);

  return qi_builtin_fseek(state, 3, new_pargs);
}

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_table_get(qi_state_t *state, qi_size_t pargc,
                                      qi_list_t *pargs)
{
  return qi_builtin_table_get(state, pargc, pargs);
}

#include "qistd.c"

static qi_bool is_little_endian()
{
  unsigned int x = 1;
  int e = (int)(((char *)&x)[0]);

  return e ? true : false;
}

static void qi_state_setup(qi_state_t *state)
{
  QI_HASH_SEED = time(NULL);

  state->nil = qi_make_uncollectable_value(QI_NULL);

  state->_true = qi_make_uncollectable_value(QI_BOOLEAN);
  state->_true->value.boolean = true;

  state->_false = qi_make_uncollectable_value(QI_BOOLEAN);
  state->_false->value.boolean = false;

  state->zero = qi_make_uncollectable_value(QI_NUMBER);
  state->zero->value.number = 0;

  state->one = qi_make_uncollectable_value(QI_NUMBER);
  state->one->value.number = 1;

  for (int i = 1; i <= 8; i++)
  {
    state->nnumbers[i - 1] = qi_make_uncollectable_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_uncollectable_value(QI_NUMBER);
    state->numbers[i]->value.number = i;
  }

  state->intern_strs = qi_table_make_root();
  state->intern_strs_mutex = qi_mutex_create();

  for (int c = 1; c < 256; c++)
  {
    char buf[2];
    buf[0] = c;
    buf[1] = 0;

    char *s = qi_strdup(buf);

    qi_value_t *value = qi_make_uncollectable_value(QI_STRING);
    value->value.string = s;

    qi_table_set(state->intern_strs, s, value);
  }

  qi_value_t *recerror_string = qi_make_uncollectable_value(QI_STRING);
  recerror_string->value.string = __recerror_msg;

  qi_table_set(state->intern_strs, __recerror_msg, recerror_string);

  state->pseudomethods = qi_table_make_root();
  state->pseudomethods_mutex = qi_mutex_create();

  state->nan = qi_make_uncollectable_value(QI_NUMBER);
  state->nan->value.number = NAN;

  state->infinity = qi_make_uncollectable_value(QI_NUMBER);
  state->infinity->value.number = INFINITY;

  state->ninfinity = qi_make_uncollectable_value(QI_NUMBER);
  state->ninfinity->value.number = -INFINITY;

  state->empty_string = qi_make_uncollectable_value(QI_STRING);
  state->empty_string->value.string = qi_strdup("");

  state->empty_bytes = qi_make_uncollectable_value(QI_BYTES);
  state->empty_bytes->value.bytes = qi_malloc_atomic(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_uncollectable_value(QI_TUPLE);
  state->empty_tuple->value.list = qi_list_make_uncollectable();

  state->_stdin = qi_make_uncollectable_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_uncollectable_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_uncollectable_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_root();
  state->exceptions = qi_list_make_root();
  state->scopes = qi_list_make_root();
  qi_new_sticky_scope(state);

  state->calltrace = qi_list_make_root();
  state->rlimit = QI_DEFAULT_RLIMIT;

  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, "__LIBQIRT",
                qi_make_string(state, (char *)LIBQIRT_INFO));
  qi_decl_const(state, "ENDIANNESS", qi_make_string(state, is_little_endian() ? "little" : "big"));

  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_pseudomethod", 2, qi_builtin_set_pseudomethod);
  qi_add_builtin(state, "has_pseudomethod", 1, qi_builtin_has_pseudomethod);
  qi_add_builtin(state, "unset_pseudomethod", 1, qi_builtin_unset_pseudomethod);

  qi_add_builtin(state, "set_global", 2, qi_builtin_set_global);
  qi_add_builtin(state, "unset_global", 1, qi_builtin_unset_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, "get_rlimit", 0, qi_builtin_get_rlimit);
  qi_add_builtin(state, "set_rlimit", 1, qi_builtin_set_rlimit);

  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, "table_get", 2, qi_builtin_table_get);

  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, "int", 1, qi_builtin_int);
  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_builtin(state, "ref", 1, qi_builtin_ref);
  qi_add_builtin(state, "iter", 1, qi_builtin_iter);
  qi_add_builtin(state, "iter_next", 1, qi_builtin_iter_next);
  qi_add_builtin(state, "iter_end", 1, qi_builtin_iter_end);

  qi_add_builtin(state, "deref", 1, qi_builtin_deref);
  qi_add_builtin(state, "ref_set", 2, qi_builtin_ref_set);

  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, "table.get", 1, qi_pseudomethod_table_get);

  qi_add_pseudomethod(state, "function.call", 1, qi_pseudomethod_func_call);

  state->_debug_data = NULL;

  qi_init_std(state);

  state->listiterator = qi_get(state, "ListIterator");
  state->typeerror = qi_get(state, "TypeError");
  state->valueerror = qi_get(state, "ValueError");
  state->indexerror = qi_get(state, "IndexError");
  state->keyerror = qi_get(state, "KeyError");

  {
    state->recursionerror = qi_get(state, "RecursionError");

    qi_list_t *pargs = qi_list_make_n(1);
    qi_list_data(pargs, 0) = qi_make_string(state, _RECERROR);

    state->recursionerror = qi_call(state, state->recursionerror, pargs);
  }

  state->nameerror = qi_get(state, "NameError");
  state->ioerror = qi_get(state, "IOError");
}

static void _qi_state_init(qi_state_t **state, qi_bool enable_debug)
{
  GC_INIT();
  GC_set_java_finalization(1);
  *state = qi_malloc(sizeof(qi_state_t));
  __debug_enabled = enable_debug;
  __recerror_msg = qi_strdup("RecursionError: " _RECERROR);
  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); }

unsigned long qi_rt_version(void)
{
  return LIBQIRT_VER;
}