qic/qic.c

#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define QIC_VERSION "qic v01 " __DATE__

size_t GID = 0;
char *PREFIX = NULL;

void *malloc_checked(size_t s) {
  void *p = malloc(s);

  if (!p) {
    fprintf(stderr, "fatal: out of memory.\n");
    abort();
  }

  memset(p, 0, s);

  return p;
}

void *realloc_checked(void *p, size_t s) {
  p = realloc(p, s);

  if (!p) {
    fprintf(stderr, "fatal: out of memory.\n");
    abort();
  }

  return p;
}

void *calloc_checked(size_t k, size_t s) {
  void *p = calloc(k, s);

  if (!p) {
    fprintf(stderr, "fatal: out of memory.\n");
    abort();
  }

  return p;
}

typedef struct {
  void **data;

  size_t length;
} list_t;

list_t *list_new(void) {
  list_t *list = malloc_checked(sizeof(list_t));
  list->data = NULL;
  list->length = 0;

  return list;
}

list_t *list_copy(list_t *list) {
  list_t *nlist = malloc_checked(sizeof(list_t));
  nlist->length = list->length;
  nlist->data = realloc_checked(nlist->data, nlist->length * sizeof(void *));

  memcpy(nlist->data, list->data, nlist->length * sizeof(void *));

  return nlist;
}

void list_push(list_t *l, void *v) {
  size_t i = l->length++;

  l->data = realloc_checked(l->data, l->length * sizeof(void *));

  l->data[i] = v;
}

void *list_pop(list_t *l) {
  if (!l->length)
    return NULL;

  return l->data[--l->length];
}

void *list_index(list_t *l, ssize_t index) {
  if (!l->length)
    return NULL;

  if (index < 0)
    index += ((ssize_t)l->length);

  if (index < 0 || index >= l->length)
    return NULL;

  return l->data[index];
}

void list_set(list_t *l, ssize_t index, void *v) {
  if (!l->length)
    return;

  if (index < 0)
    index += ((ssize_t)l->length);

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

  l->data[index] = v;
}

typedef struct {
  size_t *data;

  size_t length;
} int_stack_t;

int_stack_t *stack_new(void) {
  int_stack_t *stack = malloc_checked(sizeof(list_t));
  stack->data = NULL;
  stack->length = 0;

  return stack;
}

void stack_push(int_stack_t *l, size_t v) {
  size_t i = l->length++;

  l->data = realloc_checked(l->data, l->length * sizeof(size_t));
  l->data[i] = v;
}

size_t stack_pop(int_stack_t *l) {
  if (!l->length)
    return 0;

  return l->data[--l->length];
}

struct entry_t {
  char *key;
  void *value;
};

struct table_t {
  struct entry_t *entries;

  size_t used;
  size_t capacity;
};

typedef struct entry_t entry_t;
typedef struct table_t table_t;

table_t *table_new() {
  table_t *table = malloc_checked(sizeof(table_t));
  table->used = 0;

  table->capacity = 32;
  table->entries = calloc_checked(table->capacity, sizeof(entry_t));

  return table;
}

unsigned long ht_hash(const char *key) {
  unsigned long hash = 5381;
  int c;

  while ((c = *key++))
    hash = ((hash << 5) + hash) + c;

  return hash;
}

void *table_get(table_t *table, char *key) {
  if (!table->used)
    return NULL;

  unsigned long hash = ht_hash(key);
  size_t index = hash % table->capacity;

  size_t i = index;

  while (table->entries[i].key) {
    if (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;
}

int table_has(table_t *table, char *key) {
  if (!table->used)
    return 0;

  unsigned long hash = ht_hash(key);
  size_t index = hash % table->capacity;

  size_t i = index;

  while (table->entries[i].key) {
    if (strcmp(table->entries[i].key, key) == 0)
      return 1;

    i++;

    if (i >= table->capacity)
      i = 0;

    if (i == index)
      break;
  }

  return 0;
}

static void table_entry_set(entry_t *entries, char *key, void *value,
                            size_t capacity, size_t *used) {
  unsigned long hash = ht_hash(key);
  size_t index = hash % capacity;

  size_t i = index;

  while (entries[i].key) {
    if (strcmp(entries[i].key, key) == 0) {
      entries[i].value = value;

      return;
    }

    i++;

    if (i >= capacity)
      i = 0;

    if (i == index)
      break;
  }

  if (used)
    (*used)++;

  entries[i].key = key;
  entries[i].value = value;
}

table_t *table_set(table_t *table, char *key, void *value) {
  if (table->used >= table->capacity) {
    size_t capacity = table->capacity + 32;
    entry_t *entries = calloc_checked(capacity, sizeof(entry_t));

    for (size_t i = 0; i < table->capacity; i++) {
      entry_t entry = table->entries[i];

      if (entry.key)
        table_entry_set(entries, entry.key, entry.value, capacity, NULL);
    }

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

  table_entry_set(table->entries, key, value, table->capacity, &table->used);

  return table;
}

#define table_iterate(table, code)                                             \
  {                                                                            \
    if ((table)->used) {                                                       \
      size_t i = 0;                                                            \
      while (i < (table)->capacity) {                                          \
        entry_t entry = (table)->entries[i];                                   \
        if (entry.key) {                                                       \
          code;                                                                \
        }                                                                      \
        i++;                                                                   \
      }                                                                        \
    }                                                                          \
  }

typedef struct {
  char *str;

  size_t size;
} buffer_t;

buffer_t *buffer_new(void) {
  buffer_t *buf = malloc_checked(sizeof(buffer_t));

  buf->str = NULL;
  buf->size = 0;

  return buf;
}

void buffer_append(buffer_t *buf, char c) {
  buf->size++;
  buf->str = realloc_checked(buf->str, sizeof(char) * buf->size);
  buf->str[buf->size - 1] = c;
}

char *buffer_read(buffer_t *buf) {
  if (buf->size == 0 || buf->str[buf->size - 1])
    buffer_append(buf, 0);

  return buf->str;
}

void buffer_appends(buffer_t *buf, char *s) {
  for (size_t i = 0; i < strlen(s); i++)
    buffer_append(buf, s[i]);
}

void buffer_appendb(buffer_t *dst, buffer_t *src) {
  for (size_t i = 0; i < src->size; i++)
    buffer_append(dst, src->str[i]);
}

void buffer_fmt(buffer_t *buf, const char *fmt, ...) {
  va_list args;
  va_list largs;

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

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

  vsnprintf(str, size, fmt, args);

  va_end(args);
  va_end(largs);

  buffer_appends(buf, str);
}

typedef struct {
  enum {
    T_EOF,

    T_NUMBER,
    T_STRING,
    T_FSTRING,
    T_USTRING,
    T_BSTRING,
    T_NAME,

    T_TRUE,
    T_FALSE,
    T_NIL,

    T_VAR,
    T_LET,
    T_CONST,
    T_ENUM,
    T_IF,
    T_ELSE,
    T_ELIF,
    T_SWITCH,
    T_CASE,
    T_DEFAULT,
    T_FOR,
    T_OF,
    T_BREAK,
    T_CONTINUE,
    T_PASS,
    T_FUNC,
    T_USE,
    T_RETURN,
    T_DEFER,
    T_REQUIRE,
    T_TRY,
    T_CATCH,
    T_FINALLY,
    T_THROW,
    T_GOTO,
    T_CLASS,
    T_DEL,
    T_WITH,
    T_AS,
    T_IS,
    T_IN,

    T_LPAR,
    T_RPAR,
    T_LSB,
    T_RSB,
    T_LCB,
    T_RCB,

    T_EQUALS,
    T_NOTEQUALS,
    T_PLUSASSIGN,
    T_MINUSASSIGN,
    T_SLASHASSIGN,
    T_STARASSIGN,
    T_SLASHSLASHASSIGN,
    T_PERCENTASSIGN,
    T_STARSTARASSIGN,
    T_BARASSIGN,
    T_ANDASSIGN,
    T_RAISEASSIGN,
    T_LTLTASSIGN,
    T_GTGTASSIGN,
    T_BARBAR,
    T_ANDAND,
    T_STARSTAR,
    T_PLUSPLUS,
    T_MINUSMINUS,
    T_SLASHSLASH,
    T_COLONASSIGN,
    T_ARROW,

    T_PLUS,
    T_MINUS,
    T_QM,
    T_COLON,
    T_BAR,
    T_AND,
    T_LT,
    T_LTLT,
    T_GT,
    T_GTGT,
    T_LE,
    T_GE,
    T_STAR,
    T_SLASH,
    T_PERCENT,
    T_COMMA,
    T_DOT,
    T_BANG,
    T_RAISE,
    T_TILDE,
    T_AT,

    T_INLINE,
    T_HEADER,
    T_INCLUDE,

    T_MACRO,

    T_ASSIGN,
    T_SEMI,

    T_MVAR
  } tag;

  char *text;
  size_t z;

  size_t fi;
  size_t pos;
} token_t;

token_t *token(int tag, char *text) {
  token_t *tok = malloc_checked(sizeof(token_t));
  tok->tag = tag;
  tok->text = text;

  return tok;
}

#define TK(tk) (token(T_##tk, NULL))
#define WS()                                                                   \
  while (source[*pos] == ' ' || source[*pos] == '\t' ||                        \
         source[*pos] == '\n' || source[*pos] == '\r') {                       \
    (*pos)++;                                                                  \
  }

void consume_ignored(char *source, size_t *pos) {
  WS();

  while (source[*pos] == '#') {
    (*pos)++;

    for (;;) {
      if (!source[*pos])
        break;

      if (source[*pos] == '\n') {
        (*pos)++;

        break;
      }

      (*pos)++;
    }

    WS();
  }
}

list_t *FILES;
list_t *REQUIRED;

int is_required(char *path) {
  for (size_t i = 0; i < REQUIRED->length; i++)
    if (strcmp(REQUIRED->data[i], path) == 0)
      return 1;

  return 0;
}

char *traverse(char *source, size_t pos, size_t *line, size_t *col) {
  if (line)
    *line = 1;
  if (col)
    *col = 1;

  size_t p = 0;

  for (size_t i = 0; i < pos; i++) {
    if (source[i] == '\n') {
      if (line)
        (*line)++;
      if (col)
        (*col) = 1;

      p = i + 1;
    } else if (col)
      (*col)++;
  }

  return &source[p];
}

void format_error(char *filename, char *source, size_t pos, char *fmt, ...) {
  size_t line, col;
  char *src = traverse(source, pos, &line, &col);

  va_list args;
  va_start(args, fmt);

  fprintf(stderr, "%s (%zu:%zu): ", filename, line, col);
  vfprintf(stderr, fmt, args);
  fputc('\n', stderr);

  va_end(args);

  if (!*src)
    return;

  int empty = 1;
  for (size_t i = 0; src[i] && src[i] != '\n'; i++)
    if (!isspace(src[i])) {
      empty = 0;
      break;
    }

  if (empty)
    return;

  fputc('\t', stderr);

  for (size_t i = 0; src[i] && src[i] != '\n' && i < 64; i++)
    fputc(src[i], stderr);

  fputc('\n', stderr);
  fputc('\t', stderr);

  for (size_t i = 1; i < col && i < 64; i++)
    fputc(' ', stderr);

  fputs("^\n", stderr);
}

#define GETFNAME(fi) ((char *)((list_t *)list_index(FILES, fi))->data[0])
#define GETSRC(fi) ((char *)((list_t *)list_index(FILES, fi))->data[1])

#define LEX_ERROR(fmt, ...)                                                    \
  {                                                                            \
    format_error(GETFNAME(-1), source, *pos, fmt, ##__VA_ARGS__);              \
    exit(1);                                                                   \
  }

token_t *tokenize_string(char *source, size_t *pos, size_t *size) {
  char term = source[(*pos)++];
  int hx = 0;

  buffer_t *text = buffer_new();

  while (source[*pos] != term) {
    if (!source[*pos])
      LEX_ERROR("unterminated string literal");

    char c = source[(*pos)++];
    if (c == '\n' && term != '`')
      LEX_ERROR("unterminated string literal");

    if (term != '`' && c == '\\') {
      char nc = source[(*pos)++];

      if (!nc)
        continue;

      switch (nc) {
      case 'x': {
        char buf[3];
        int k = 0;

        while (k < 2) {
          if (!source[*pos] || !strchr("0123456789abcdefABCDEF", source[*pos]))
            break;

          buf[k++] = source[(*pos)++];
        }

        if (k != 2)
          LEX_ERROR("malformed \\x escape sequence");

        buf[k] = 0;

        buffer_fmt(text, "\\x%s", buf);

        hx = 1;

        if (size)
          (*size)++;
      }
        continue;

      case 'n':
        buffer_appends(text, "\\n");
        break;

      case 't':
        buffer_appends(text, "\\t");
        break;

      case 'r':
        buffer_appends(text, "\\r");
        break;

      case 'a':
        buffer_appends(text, "\\a");
        break;

      case 'b':
        buffer_appends(text, "\\b");
        break;

      case 'e':
        buffer_appends(text, "\\x1b");
        break;

      case 's':
        buffer_appends(text, " ");
        break;

      case '"':
        buffer_appends(text, "\\\"");
        break;

      case '?':
        buffer_appends(text, "\\\?");
        break;

      case '\\':
        buffer_appends(text, "\\\\");
        break;

      case '\n':
        buffer_appends(text, "\\n");
        break;

      default:
        if (hx) {
          hx = 0;

          if (strchr("0123456789abcdefABCDEF", nc) != NULL) {
            buffer_fmt(text, "\\x%x", nc);

            hx = 1;

            if (size)
              (*size)++;

            continue;
          }
        }

        buffer_append(text, nc);
        break;
      }

      if (hx)
        hx = 0;
      if (size)
        (*size)++;

      continue;
    }

    if (c == '"' || c == '\\' || c == '?')
      buffer_append(text, '\\');
    else if (c == '\n') {
      buffer_appends(text, "\\n");

      if (size)
        (*size)++;

      continue;
    }

    if (size)
      (*size)++;

    if (hx) {
      hx = 0;

      if (strchr("0123456789abcdefABCDEF", c) != NULL) {
        buffer_fmt(text, "\\x%x", c);

        hx = 1;

        continue;
      }
    }

    buffer_append(text, c);
  }

  (*pos)++;

  return token(T_STRING, buffer_read(text));
}

int NEEDS_UTF8 = 0;

token_t *next_token(char *source, size_t *pos) {
  if (!source[*pos])
    return token(T_EOF, NULL);

  if (source[*pos] == '"' || source[*pos] == '\'' || source[*pos] == '`')
    return tokenize_string(source, pos, NULL);
  else if (source[*pos] == 'f' &&
           (source[(*pos) + 1] == '"' || source[(*pos) + 1] == '\'' ||
            source[(*pos) + 1] == '`')) {
    (*pos)++;

    token_t *t = tokenize_string(source, pos, NULL);
    t->tag = T_FSTRING;

    return t;
  } else if (source[*pos] == 'u' &&
             (source[(*pos) + 1] == '"' || source[(*pos) + 1] == '\'' ||
              source[(*pos) + 1] == '`')) {
    (*pos)++;

    token_t *t = tokenize_string(source, pos, NULL);
    t->tag = T_USTRING;

    NEEDS_UTF8 = 1;

    return t;
  } else if (source[*pos] == 'b' &&
             (source[(*pos) + 1] == '"' || source[(*pos) + 1] == '\'' ||
              source[(*pos) + 1] == '`')) {
    (*pos)++;

    size_t z = 0;

    token_t *t = tokenize_string(source, pos, &z);
    t->tag = T_BSTRING;
    t->z = z;

    return t;
  } else if (source[*pos] == '0' &&
             (source[(*pos) + 1] == 'x' || source[(*pos) + 1] == 'b' ||
              source[(*pos) + 1] == 'o')) {
    buffer_t *number = buffer_new();
    buffer_append(number, source[(*pos)++]);

    char b = source[(*pos)++];

    buffer_append(number, b);

    while (source[*pos] && strchr(b == 'x'   ? "0123456789abcdefABCDEF"
                                  : b == 'b' ? "01"
                                             : "01234567",
                                  source[*pos]) != NULL)
      buffer_append(number, source[(*pos)++]);

    if (number->size < 3)
      LEX_ERROR("illegal number literal (trailing base)");

    return token(T_NUMBER, buffer_read(number));
  } else if ((source[*pos] == '.' && isdigit(source[(*pos) + 1])) ||
             isdigit(source[*pos])) {
    buffer_t *number = buffer_new();
    int dot = 0;
    int sub = 0;
    int skip = 0;

    if (source[*pos] == '.') {
      buffer_append(number, '0');

      skip = 1;
    }

    do {
      if (skip)
        skip = 0;
      else
        buffer_append(number, source[(*pos)++]);

      if (!dot && source[*pos] == '.') {
        buffer_append(number, source[(*pos)++]);

        if (!isdigit(source[*pos]))
          LEX_ERROR(
              "illegal number literal (missing part after floating point)");

        dot = 1;
      } else if (!sub && source[*pos] == '_') {
        (*pos)++;

        if (!isdigit(source[*pos]))
          LEX_ERROR("illegal number literal (missing part after underscore)");

        sub = 1;
      } else if (sub)
        sub = 0;
    } while (isdigit(source[*pos]));

    return token(T_NUMBER, buffer_read(number));
  } else if (source[*pos] == '$') {
    (*pos)++;

    buffer_t *name = buffer_new();
    if (source[*pos] == '$' || source[*pos] == '{' || source[*pos] == ':' ||
        source[*pos] == '*')
      buffer_append(name, source[(*pos)++]);
    else {
      if (!source[*pos] || !isalpha(source[*pos]))
        LEX_ERROR("illegal macro variable (missing or malformed part after "
                  "dollar sign)");

      do {
        buffer_append(name, source[(*pos)++]);
      } while (isalpha(source[*pos]) || source[*pos] == '_' ||
               isdigit(source[*pos]));
    }

    return token(T_MVAR, buffer_read(name));
  } else if (isalpha(source[*pos]) || source[*pos] == '_') {
    buffer_t *text = buffer_new();

    do {
      buffer_append(text, source[(*pos)++]);
    } while (isalpha(source[*pos]) || source[*pos] == '_' ||
             isdigit(source[*pos]));

    char *name = buffer_read(text);

    if (strcmp(name, "var") == 0)
      return TK(VAR);
    else if (strcmp(name, "let") == 0)
      return TK(LET);
    else if (strcmp(name, "const") == 0)
      return TK(CONST);
    else if (strcmp(name, "enum") == 0)
      return TK(ENUM);
    else if (strcmp(name, "if") == 0)
      return TK(IF);
    else if (strcmp(name, "else") == 0)
      return TK(ELSE);
    else if (strcmp(name, "elif") == 0)
      return TK(ELIF);
    else if (strcmp(name, "switch") == 0)
      return TK(SWITCH);
    else if (strcmp(name, "case") == 0)
      return TK(CASE);
    else if (strcmp(name, "default") == 0)
      return TK(DEFAULT);
    else if (strcmp(name, "for") == 0)
      return TK(FOR);
    else if (strcmp(name, "break") == 0)
      return TK(BREAK);
    else if (strcmp(name, "continue") == 0)
      return TK(CONTINUE);
    else if (strcmp(name, "func") == 0)
      return TK(FUNC);
    else if (strcmp(name, "use") == 0)
      return TK(USE);
    else if (strcmp(name, "return") == 0)
      return TK(RETURN);
    else if (strcmp(name, "defer") == 0)
      return TK(DEFER);
    else if (strcmp(name, "pass") == 0)
      return TK(PASS);
    else if (strcmp(name, "require") == 0)
      return TK(REQUIRE);
    else if (strcmp(name, "try") == 0)
      return TK(TRY);
    else if (strcmp(name, "catch") == 0)
      return TK(CATCH);
    else if (strcmp(name, "finally") == 0)
      return TK(FINALLY);
    else if (strcmp(name, "throw") == 0)
      return TK(THROW);
    else if (strcmp(name, "goto") == 0)
      return TK(GOTO);
    else if (strcmp(name, "class") == 0)
      return TK(CLASS);
    else if (strcmp(name, "del") == 0)
      return TK(DEL);
    else if (strcmp(name, "is") == 0)
      return TK(IS);
    else if (strcmp(name, "with") == 0)
      return TK(WITH);
    else if (strcmp(name, "as") == 0)
      return TK(AS);
    else if (strcmp(name, "in") == 0)
      return TK(IN);
    else if (strcmp(name, "of") == 0)
      return TK(OF);
    else if (strcmp(name, "inline") == 0)
      return TK(INLINE);
    else if (strcmp(name, "header") == 0)
      return TK(HEADER);
    else if (strcmp(name, "include") == 0)
      return TK(INCLUDE);
    else if (strcmp(name, "macro") == 0)
      return TK(MACRO);
    else if (strcmp(name, "true") == 0)
      return TK(TRUE);
    else if (strcmp(name, "false") == 0)
      return TK(FALSE);
    else if (strcmp(name, "nil") == 0)
      return TK(NIL);

    return token(T_NAME, name);
  } else if (strncmp(&source[*pos], "==", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(EQUALS);
  else if (strncmp(&source[*pos], "!=", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(NOTEQUALS);
  else if (strncmp(&source[*pos], "+=", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(PLUSASSIGN);
  else if (strncmp(&source[*pos], "-=", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(MINUSASSIGN);
  else if (strncmp(&source[*pos], "*=", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(STARASSIGN);
  else if (strncmp(&source[*pos], "/=", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(SLASHASSIGN);
  else if (strncmp(&source[*pos], "//=", 3) == 0 && ++(*pos) && ++(*pos) &&
           ++(*pos))
    return TK(SLASHSLASHASSIGN);
  else if (strncmp(&source[*pos], "%=", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(PERCENTASSIGN);
  else if (strncmp(&source[*pos], "**=", 3) == 0 && ++(*pos) && ++(*pos) &&
           ++(*pos))
    return TK(STARSTARASSIGN);
  else if (strncmp(&source[*pos], "|=", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(BARASSIGN);
  else if (strncmp(&source[*pos], "&=", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(ANDASSIGN);
  else if (strncmp(&source[*pos], "^=", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(RAISEASSIGN);
  else if (strncmp(&source[*pos], "<<=", 3) == 0 && ++(*pos) && ++(*pos) &&
           ++(*pos))
    return TK(LTLTASSIGN);
  else if (strncmp(&source[*pos], ">>=", 3) == 0 && ++(*pos) && ++(*pos) &&
           ++(*pos))
    return TK(GTGTASSIGN);
  else if (strncmp(&source[*pos], "||", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(BARBAR);
  else if (strncmp(&source[*pos], "&&", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(ANDAND);
  else if (strncmp(&source[*pos], "++", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(PLUSPLUS);
  else if (strncmp(&source[*pos], "--", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(MINUSMINUS);
  else if (strncmp(&source[*pos], "//", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(SLASHSLASH);
  else if (strncmp(&source[*pos], "**", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(STARSTAR);
  else if (strncmp(&source[*pos], "<<", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(LTLT);
  else if (strncmp(&source[*pos], ">>", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(GTGT);
  else if (strncmp(&source[*pos], "<=", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(LE);
  else if (strncmp(&source[*pos], ">=", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(GE);
  else if (strncmp(&source[*pos], ":=", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(COLONASSIGN);
  else if (strncmp(&source[*pos], "=>", 2) == 0 && ++(*pos) && ++(*pos))
    return TK(ARROW);
  else if (source[*pos] == '(' && ++(*pos))
    return TK(LPAR);
  else if (source[*pos] == ')' && ++(*pos))
    return TK(RPAR);
  else if (source[*pos] == '[' && ++(*pos))
    return TK(LSB);
  else if (source[*pos] == ']' && ++(*pos))
    return TK(RSB);
  else if (source[*pos] == '{' && ++(*pos))
    return TK(LCB);
  else if (source[*pos] == '}' && ++(*pos)) {
    if (source[*pos] == '$' && ++(*pos))
      return token(T_MVAR, strdup("}"));

    return TK(RCB);
  } else if (source[*pos] == '+' && ++(*pos))
    return TK(PLUS);
  else if (source[*pos] == '-' && ++(*pos))
    return TK(MINUS);
  else if (source[*pos] == '*' && ++(*pos))
    return TK(STAR);
  else if (source[*pos] == '/' && ++(*pos))
    return TK(SLASH);
  else if (source[*pos] == '%' && ++(*pos))
    return TK(PERCENT);
  else if (source[*pos] == '?' && ++(*pos))
    return TK(QM);
  else if (source[*pos] == ':' && ++(*pos))
    return TK(COLON);
  else if (source[*pos] == '=' && ++(*pos))
    return TK(ASSIGN);
  else if (source[*pos] == ';' && ++(*pos))
    return TK(SEMI);
  else if (source[*pos] == ',' && ++(*pos))
    return TK(COMMA);
  else if (source[*pos] == '.' && ++(*pos))
    return TK(DOT);
  else if (source[*pos] == '<' && ++(*pos))
    return TK(LT);
  else if (source[*pos] == '>' && ++(*pos))
    return TK(GT);
  else if (source[*pos] == '!' && ++(*pos))
    return TK(BANG);
  else if (source[*pos] == '|' && ++(*pos))
    return TK(BAR);
  else if (source[*pos] == '&' && ++(*pos))
    return TK(AND);
  else if (source[*pos] == '^' && ++(*pos))
    return TK(RAISE);
  else if (source[*pos] == '~' && ++(*pos))
    return TK(TILDE);
  else if (source[*pos] == '@' && ++(*pos))
    return TK(AT);

  LEX_ERROR("unexpected input")
}

list_t *tokenize(char *source) {
  size_t pos = 0;
  list_t *toks = list_new();

  do {
    consume_ignored(source, &pos);

    size_t tok_pos = pos;

    token_t *tok = next_token(source, &pos);
    tok->fi = FILES->length - 1;
    tok->pos = tok_pos;

    list_push(toks, tok);

    if (tok->tag == T_EOF)
      break;
  } while (1);

  return toks;
}

int DEBUG = 0;
list_t *DEBUGDATA;
list_t *FUNCNAMES;

struct _node_t {
  enum {
    N_TOPLEVEL,
    N_PROGRAM,
    N_EXPRSTMT,

    N_BLOCK,

    N_EXPRS_BEGIN,

    N_COMMA,

    N_NOT,
    N_NEGATE,
    N_UNARY_PLUS,
    N_BNOT,

    N_LITERAL,
    N_LIST,
    N_LISTGEN,
    N_TABLEGEN,
    N_TUPLE,
    N_NILTUPLE,
    N_TABLE,

    N_CALL,
    N_MEMBER,
    N_INDEX,
    N_SLICE,

    N_ADD,
    N_SUB,
    N_MUL,
    N_DIV,
    N_IDIV,
    N_MOD,
    N_POW,
    N_SHL,
    N_SHR,
    N_XOR,
    N_BOR,
    N_BAND,

    N_ASSIGN,
    N_ASSIGN_ADD,
    N_ASSIGN_SUB,
    N_ASSIGN_MUL,
    N_ASSIGN_DIV,
    N_ASSIGN_IDIV,
    N_ASSIGN_MOD,
    N_ASSIGN_POW,
    N_ASSIGN_BOR,
    N_ASSIGN_BAND,
    N_ASSIGN_XOR,
    N_ASSIGN_SHL,
    N_ASSIGN_SHR,
    N_DECL,

    N_EQUALS,
    N_NOTEQUALS,
    N_IS,
    N_IN,
    N_NOTIS,
    N_NOTIN,

    N_LT,
    N_GT,
    N_LE,
    N_GE,

    N_INC,
    N_DEC,
    N_PINC,
    N_PDEC,

    N_IFEXPR,
    N_FUNCEXPR,
    N_SWITCHEXPR,

    N_LOGOR,
    N_LOGAND,

    N_CATCH,

    N_EXPRS_END,

    N_STAR,

    N_VAR,
    N_LET,
    N_VARUNPACK,
    N_LETUNPACK,
    N_CONST,
    N_ENUM,
    N_IF,
    N_SWITCH,
    N_FOR,
    N_FOROF,
    N_FOROFVAR,
    N_FOROFUNPACK,
    N_FOROFVARUNPACK,
    N_BREAK,
    N_CONTINUE,
    N_FUNCDEF,
    N_RETURN,
    N_DEFER,
    N_PASS,
    N_REQUIRE,
    N_TRY,
    N_THROW,
    N_LABEL,
    N_GOTO,
    N_CLASS,
    N_DEL,
    N_WITH,

    N_INLINE,
    N_HEADER,
    N_INCLUDE,

    N_BUFFER,

    N_MACRO_CALL,
    N_MVAR,

    N_MIF,
    N_MFOR,
    N_MREPEAT,
    N_MSET,
    N_MPUSH,
    N_MSTMT,
    N_MEXPR
  } tag;

  struct _node_t *a;
  struct _node_t *b;
  struct _node_t *c;
  struct _node_t *d;

  list_t *l;
  list_t *l2;

  table_t *h;
  table_t *h2;

  token_t *t;
  token_t *t2;

  buffer_t *buf;

  size_t fi;
  size_t pos;
};
typedef struct _node_t node_t;

node_t *node_pos(node_t *node, size_t fi, size_t pos) {
  node->fi = fi;
  node->pos = pos;

  return node;
}

node_t *node_copy(node_t *node) {
  node_t *nnode = malloc_checked(sizeof(node_t));
  memcpy(nnode, node, sizeof(node_t));

  return nnode;
}

node_t *nodet(int tag, token_t *t) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->t = t;

  return node;
}

#define NODET(n, a)                                                            \
  (node_pos(nodet(N_##n, (a)),                                                 \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *nodel(int tag, list_t *l) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->l = l;

  return node;
}

#define NODEL(n, a)                                                            \
  (node_pos(nodel(N_##n, (a)),                                                 \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *nodetl(int tag, token_t *t, list_t *l) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->t = t;
  node->l = l;

  return node;
}

#define NODETL(n, t, l)                                                        \
  (node_pos(nodetl(N_##n, (t), (l)),                                           \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *nodeh(int tag, table_t *h) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->h = h;

  return node;
}

#define NODEH(n, a)                                                            \
  (node_pos(nodeh(N_##n, (a)),                                                 \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *node0(int tag) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;

  return node;
}

#define NODE0(n)                                                               \
  (node_pos(node0(N_##n),                                                      \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *node1(int tag, node_t *a) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->a = a;

  return node;
}

#define NODE1(n, a)                                                            \
  (node_pos(node1(N_##n, (a)),                                                 \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *node1l(int tag, node_t *a, list_t *l) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->a = a;
  node->l = l;

  return node;
}

#define NODE1l(n, a, l)                                                        \
  (node_pos(node1l(N_##n, (a), (l)),                                           \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *node1l2(int tag, node_t *a, list_t *l, list_t *l2) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->a = a;
  node->l = l;
  node->l2 = l2;

  return node;
}

#define NODE1l2(n, a, l, l2)                                                   \
  (node_pos(node1l2(N_##n, (a), (l), (l2)),                                    \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *node1t(int tag, node_t *a, token_t *t) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->a = a;
  node->t = t;

  return node;
}

#define NODE1t(n, a, t)                                                        \
  (node_pos(node1t(N_##n, (a), (t)),                                           \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *node2(int tag, node_t *a, node_t *b) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->a = a;
  node->b = b;

  return node;
}

#define NODE2(n, a, b)                                                         \
  (node_pos(node2(N_##n, (a), (b)),                                            \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *node2l(int tag, node_t *a, node_t *b, list_t *l) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->a = a;
  node->b = b;
  node->l = l;

  return node;
}

#define NODE2l(n, a, b, l)                                                     \
  (node_pos(node2l(N_##n, (a), (b), (l)),                                      \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *node2t(int tag, node_t *a, node_t *b, token_t *t) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->a = a;
  node->b = b;
  node->t = t;

  return node;
}

#define NODE2t(n, a, b, c)                                                     \
  (node_pos(node2t(N_##n, (a), (b), (c)),                                      \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *node3(int tag, node_t *a, node_t *b, node_t *c) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->a = a;
  node->b = b;
  node->c = c;

  return node;
}

#define NODE3(n, a, b, c)                                                      \
  (node_pos(node3(N_##n, (a), (b), (c)),                                       \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *node3t(int tag, node_t *a, node_t *b, node_t *c, token_t *t) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->a = a;
  node->b = b;
  node->c = c;
  node->t = t;

  return node;
}

#define NODE3t(n, a, b, c, d)                                                  \
  (node_pos(node3t(N_##n, (a), (b), (c), (d)),                                 \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *node4(int tag, node_t *a, node_t *b, node_t *c, node_t *d) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->a = a;
  node->b = b;
  node->c = c;
  node->d = d;

  return node;
}

#define NODE4(n, a, b, c, d)                                                   \
  (node_pos(node4(N_##n, (a), (b), (c), (d)),                                  \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *nodef(int tag, token_t *name, table_t *params, table_t *captured,
              node_t *body) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = tag;
  node->t = name;
  node->h = params;
  node->h2 = captured;
  node->a = body;

  return node;
}

#define NODEF(n, a, b, c, d)                                                   \
  (node_pos(nodef(N_##n, (a), (b), (c), (d)),                                  \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi,   \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos))

node_t *nodeb(buffer_t *buf) {
  node_t *node = malloc_checked(sizeof(node_t));

  node->tag = N_BUFFER;
  node->buf = buf;

  return node;
}

typedef struct {
  char *name;

  list_t *params;
  list_t *body;
  int variable;
} macro_t;

list_t *MACROS;

#define LABELLOOP(n)                                                           \
  node_t *ln = (n);                                                            \
  ln->t2 = label;

#define AT(tk)                                                                 \
  (*pos < tokens->length && ((token_t *)tokens->data[*pos])->tag == T_##tk)
#define ATP(tk, p)                                                             \
  ((*pos) + p < tokens->length &&                                              \
   ((token_t *)tokens->data[(*pos) + p])->tag == T_##tk)
#define MATCH(tk) (AT(tk) && ++(*pos))
#define PARSE_ERROR(fmt, ...)                                                  \
  {                                                                            \
    format_error(                                                              \
        GETFNAME(                                                              \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi),  \
        GETSRC(                                                                \
            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi),  \
        ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos, fmt, \
        ##__VA_ARGS__);                                                        \
    exit(1);                                                                   \
  }
#define EXPECT(tk, s)                                                          \
  {                                                                            \
    if (!MATCH(tk))                                                            \
      PARSE_ERROR("expected %s", (s));                                         \
  }

node_t *parse_expr(list_t *tokens, size_t *pos);

list_t *parse_sequence(list_t *tokens, size_t *pos, int term) {
  list_t *seq = list_new();

  do {
    if (term != -1 && *pos < tokens->length &&
        ((token_t *)tokens->data[*pos])->tag == term)
      break;

    if (MATCH(STAR))
      list_push(seq, NODE1(STAR, parse_expr(tokens, pos)));
    else
      list_push(seq, parse_expr(tokens, pos));
  } while (MATCH(COMMA));

  return seq;
}

node_t *parse_func(list_t *tokens, size_t *pos, int is_expr);

char *unescape(char *s);

node_t *parse_primary(list_t *tokens, size_t *pos) {
  if (MATCH(MVAR))
    return NODET(MVAR, tokens->data[(*pos) - 1]);
  else if (MATCH(CATCH)) {
    node_t *a = parse_expr(tokens, pos);

    return NODE1(CATCH, a);
  } else if (MATCH(FUNC))
    return parse_func(tokens, pos, 1);
  else if (MATCH(LPAR)) {
    if (MATCH(RPAR))
      return NODE0(NILTUPLE);

    node_t *a = parse_expr(tokens, pos);

    if (MATCH(COMMA)) {
      list_t *l = list_new();
      list_push(l, a);

      if (!AT(RPAR))
        do {
          node_t *n = parse_expr(tokens, pos);

          list_push(l, n);
        } while (MATCH(COMMA));

      a = NODEL(TUPLE, l);
    }

    EXPECT(RPAR, ")");

    return a;
  } else if (MATCH(LSB)) {
    list_t *a = parse_sequence(tokens, pos, T_RSB);

    node_t *loop = NULL;
    node_t *cond = NULL;

    if (MATCH(FOR)) {
      int is_var = MATCH(VAR);

      if (MATCH(LSB)) {
        list_t *l = list_new();

        do {
          if (!AT(NAME))
            PARSE_ERROR("expected identifier");

          list_push(l, ((token_t *)tokens->data[(*pos)++])->text);
        } while (MATCH(COMMA));

        EXPECT(RSB, "]");
        EXPECT(OF, "of");

        if (is_var)
          loop = NODE2l(FOROFVARUNPACK, parse_expr(tokens, pos), NODEL(LIST, a),
                        l);
        else
          loop =
              NODE2l(FOROFUNPACK, parse_expr(tokens, pos), NODEL(LIST, a), l);
      } else {
        if (!AT(NAME))
          PARSE_ERROR("expected identifier");

        token_t *t = tokens->data[(*pos)++];

        EXPECT(OF, "of");

        if (is_var)
          loop = NODE2t(FOROFVAR, parse_expr(tokens, pos), NODEL(LIST, a), t);
        else
          loop = NODE2t(FOROF, parse_expr(tokens, pos), NODEL(LIST, a), t);
      }

      if (MATCH(IF))
        cond = parse_expr(tokens, pos);
    }

    EXPECT(RSB, "]");

    if (loop)
      return NODE2(LISTGEN, loop, cond);

    return NODEL(LIST, a);
  } else if (MATCH(LCB)) {
    list_t *pairs = list_new();

    do {
      if (AT(RCB))
        break;

      node_t *key = parse_expr(tokens, pos);

      EXPECT(COLON, ":");

      node_t *val = parse_expr(tokens, pos);

      list_t *pair = list_new();
      list_push(pair, key);
      list_push(pair, val);

      list_push(pairs, pair);
    } while (MATCH(COMMA));

    node_t *loop = NULL;
    node_t *cond = NULL;

    if (MATCH(FOR)) {
      int is_var = MATCH(VAR);

      if (MATCH(LSB)) {
        list_t *l = list_new();

        do {
          if (!AT(NAME))
            PARSE_ERROR("expected identifier");

          list_push(l, ((token_t *)tokens->data[(*pos)++])->text);
        } while (MATCH(COMMA));

        EXPECT(RSB, "]");
        EXPECT(OF, "of");

        if (is_var)
          loop = NODE2l(FOROFVARUNPACK, parse_expr(tokens, pos),
                        NODEL(LIST, pairs), l);
        else
          loop = NODE2l(FOROFUNPACK, parse_expr(tokens, pos),
                        NODEL(LIST, pairs), l);
      } else {
        if (!AT(NAME))
          PARSE_ERROR("expected identifier");

        token_t *t = tokens->data[(*pos)++];

        EXPECT(OF, "of");

        if (is_var)
          loop =
              NODE2t(FOROFVAR, parse_expr(tokens, pos), NODEL(LIST, pairs), t);
        else
          loop = NODE2t(FOROF, parse_expr(tokens, pos), NODEL(LIST, pairs), t);
      }

      if (MATCH(IF))
        cond = parse_expr(tokens, pos);
    }

    EXPECT(RCB, "}");

    if (loop)
      return NODE2(TABLEGEN, loop, cond);

    return NODEL(TABLE, pairs);
  } else if (MATCH(NUMBER) || MATCH(STRING) || MATCH(FSTRING) ||
             MATCH(USTRING) || MATCH(BSTRING) || MATCH(NAME) || MATCH(TRUE) ||
             MATCH(FALSE) || MATCH(NIL))
    return NODET(LITERAL, tokens->data[(*pos) - 1]);

  if (MATCH(RPAR)) {
    PARSE_ERROR("extraneous )");
  } else if (MATCH(RSB)) {
    PARSE_ERROR("extraneous ]");
  } else if (MATCH(RCB)) {
    PARSE_ERROR("extraneous }");
  } else {
    PARSE_ERROR("expected expression");
  }

  return NULL;
}

size_t get_lineno(token_t *tok) {
  size_t line, col;
  traverse(GETSRC(tok->fi), tok->pos, &line, &col);

  return line;
}

#define CLIFF                                                                  \
  (get_lineno(((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])) !=  \
   get_lineno(                                                                 \
       ((token_t *)tokens                                                      \
            ->data[(*pos) >= tokens->length ? tokens->length - 1 : (*pos)])))
#define CLIFF_AHEAD                                                            \
  (get_lineno((                                                                \
       (token_t *)tokens                                                       \
           ->data[(*pos) >= tokens->length ? tokens->length - 1 : (*pos)])) != \
   get_lineno(((token_t *)tokens                                               \
                   ->data[(*pos) + 1 >= tokens->length ? tokens->length - 1    \
                                                       : (*pos) + 1])))

node_t *_parse_stmt(list_t *tokens, size_t *pos, int allow_comma);
#define parse_stmt(t, p) (_parse_stmt((t), (p), 0))
#define parse_stmt_c(t, p) (_parse_stmt((t), (p), 1))

node_t *parse_call(list_t *tokens, size_t *pos) {
  node_t *a = parse_primary(tokens, pos);

  if (a->tag == N_LITERAL && a->t->tag == T_NAME && !CLIFF && !CLIFF_AHEAD &&
      AT(BANG) && ATP(LPAR, 1)) {
    MATCH(BANG);
    MATCH(LPAR);

    list_t *args = list_new();

    if (!AT(RPAR))
      do {
        node_t *n = parse_stmt(tokens, pos);

        if (n->tag == N_BLOCK)
          n->tag = N_PROGRAM;
        else if (n->tag == N_EXPRSTMT)
          n = n->a;

        list_push(args, n);
      } while (MATCH(COMMA));

    EXPECT(RPAR, ")");

    return NODETL(MACRO_CALL, a->t, args);
  }

  do {
    if (!CLIFF && MATCH(LPAR)) {
      list_t *b = NULL;

      if (!AT(RPAR))
        b = parse_sequence(tokens, pos, -1);

      EXPECT(RPAR, ")");

      a = NODE1l(CALL, a, b);

      continue;
    } else if (!CLIFF && MATCH(LSB)) {
      if (MATCH(COLON)) {
        a = NODE3(SLICE, a, NULL, parse_expr(tokens, pos));

        EXPECT(RSB, "]");

        continue;
      }

      node_t *b = parse_expr(tokens, pos);

      if (MATCH(COLON)) {
        node_t *c = NULL;

        if (!AT(RSB))
          c = parse_expr(tokens, pos);

        EXPECT(RSB, "]");

        a = NODE3(SLICE, a, b, c);

        continue;
      }

      EXPECT(RSB, "]");

      a = NODE2(INDEX, a, b);

      continue;
    } else if (!CLIFF && MATCH(DOT)) {
      if (!AT(NAME))
        PARSE_ERROR("expected identifier after .");

      a = NODE1t(MEMBER, a, tokens->data[(*pos)++]);

      continue;
    }

    break;
  } while (1);

  return a;
}

node_t *parse_postfix(list_t *tokens, size_t *pos) {
  node_t *a = parse_call(tokens, pos);

  if (CLIFF)
    return a;

  if (MATCH(PLUSPLUS))
    return NODE1(INC, a);
  else if (MATCH(MINUSMINUS))
    return NODE1(DEC, a);
  else if (MATCH(SWITCH)) {
    EXPECT(LCB, "{");

    list_t *cases = list_new();
    node_t *default_case = NULL;

    for (;;) {
      if (MATCH(DEFAULT)) {
        MATCH(ARROW);

        default_case = parse_expr(tokens, pos);

        break;
      }

      if (AT(RCB))
        break;

      node_t *expr = parse_expr(tokens, pos);

      MATCH(ARROW);

      list_t *pair = list_new();
      list_push(pair, expr);
      list_push(pair, parse_expr(tokens, pos));

      list_push(cases, pair);
    }

    EXPECT(RCB, "}");

    if (!cases->length && !default_case)
      PARSE_ERROR("empty switch expression");

    return NODE2l(SWITCHEXPR, a, default_case, cases);
  }

  return a;
}

node_t *parse_unary(list_t *tokens, size_t *pos) {
  if (MATCH(MINUS)) {
    node_t *a = parse_unary(tokens, pos);

    return NODE1(NEGATE, a);
  } else if (MATCH(PLUS)) {
    node_t *a = parse_unary(tokens, pos);

    return NODE1(UNARY_PLUS, a);
  } else if (MATCH(BANG)) {
    node_t *a = parse_unary(tokens, pos);

    return NODE1(NOT, a);
  } else if (MATCH(TILDE)) {
    node_t *a = parse_unary(tokens, pos);

    return NODE1(BNOT, a);
  } else if (MATCH(PLUSPLUS)) {
    node_t *a = parse_postfix(tokens, pos);

    return NODE1(PINC, a);
  } else if (MATCH(MINUSMINUS)) {
    node_t *a = parse_postfix(tokens, pos);

    return NODE1(PDEC, a);
  }

  return parse_postfix(tokens, pos);
}

node_t *parse_pow(list_t *tokens, size_t *pos) {
  node_t *a = parse_unary(tokens, pos);

  do {
    if (MATCH(STARSTAR)) {
      node_t *b = parse_unary(tokens, pos);

      a = NODE2(POW, a, b);

      continue;
    }

    break;
  } while (1);

  return a;
}

node_t *parse_mul(list_t *tokens, size_t *pos) {
  node_t *a = parse_pow(tokens, pos);

  do {
    if (MATCH(STAR)) {
      node_t *b = parse_pow(tokens, pos);

      a = NODE2(MUL, a, b);

      continue;
    } else if (MATCH(SLASH)) {
      node_t *b = parse_pow(tokens, pos);

      a = NODE2(DIV, a, b);

      continue;
    } else if (MATCH(SLASHSLASH)) {
      node_t *b = parse_pow(tokens, pos);

      a = NODE2(IDIV, a, b);

      continue;
    } else if (MATCH(PERCENT)) {
      node_t *b = parse_pow(tokens, pos);

      a = NODE2(MOD, a, b);

      continue;
    }

    break;
  } while (1);

  return a;
}

node_t *parse_add(list_t *tokens, size_t *pos) {
  node_t *a = parse_mul(tokens, pos);

  do {
    if (MATCH(PLUS)) {
      node_t *b = parse_mul(tokens, pos);

      a = NODE2(ADD, a, b);

      continue;
    } else if (MATCH(MINUS)) {
      node_t *b = parse_mul(tokens, pos);

      a = NODE2(SUB, a, b);

      continue;
    }

    break;
  } while (1);

  return a;
}

node_t *parse_shift(list_t *tokens, size_t *pos) {
  node_t *a = parse_add(tokens, pos);

  do {
    if (MATCH(LTLT)) {
      node_t *b = parse_add(tokens, pos);

      a = NODE2(SHL, a, b);

      continue;
    } else if (MATCH(GTGT)) {
      node_t *b = parse_add(tokens, pos);

      a = NODE2(SHR, a, b);

      continue;
    }

    break;
  } while (1);

  return a;
}

node_t *parse_relation(list_t *tokens, size_t *pos) {
  node_t *a = parse_shift(tokens, pos);

  do {
    if (MATCH(LT)) {
      node_t *b = parse_shift(tokens, pos);

      a = NODE2(LT, a, b);

      continue;
    } else if (MATCH(GT)) {
      node_t *b = parse_shift(tokens, pos);

      a = NODE2(GT, a, b);

      continue;
    } else if (MATCH(LE)) {
      node_t *b = parse_shift(tokens, pos);

      a = NODE2(LE, a, b);

      continue;
    } else if (MATCH(GE)) {
      node_t *b = parse_shift(tokens, pos);

      a = NODE2(GE, a, b);

      continue;
    }

    break;
  } while (1);

  return a;
}

node_t *parse_equality(list_t *tokens, size_t *pos) {
  node_t *a = parse_relation(tokens, pos);

  do {
    if (MATCH(EQUALS)) {
      node_t *b = parse_relation(tokens, pos);

      a = NODE2(EQUALS, a, b);

      continue;
    } else if (MATCH(NOTEQUALS)) {
      node_t *b = parse_relation(tokens, pos);

      a = NODE2(NOTEQUALS, a, b);

      continue;
    } else if (MATCH(IS)) {
      node_t *b = parse_relation(tokens, pos);

      a = NODE2(IS, a, b);

      continue;
    } else if (AT(BANG) && ATP(IS, 1)) {
      EXPECT(BANG, "!");
      EXPECT(IS, "is");

      node_t *b = parse_relation(tokens, pos);

      a = NODE2(NOTIS, a, b);

      continue;
    } else if (MATCH(IN)) {
      node_t *b = parse_relation(tokens, pos);

      a = NODE2(IN, a, b);

      continue;
    } else if (AT(BANG) && ATP(IN, 1)) {
      EXPECT(BANG, "!");
      EXPECT(IN, "in");

      node_t *b = parse_relation(tokens, pos);

      a = NODE2(NOTIN, a, b);

      continue;
    }

    break;
  } while (1);

  return a;
}

node_t *parse_bitand(list_t *tokens, size_t *pos) {
  node_t *a = parse_equality(tokens, pos);

  while (MATCH(AND)) {
    node_t *b = parse_equality(tokens, pos);

    a = NODE2(BAND, a, b);
  }

  return a;
}

node_t *parse_bitxor(list_t *tokens, size_t *pos) {
  node_t *a = parse_bitand(tokens, pos);

  while (MATCH(RAISE)) {
    node_t *b = parse_bitand(tokens, pos);

    a = NODE2(XOR, a, b);
  }

  return a;
}

node_t *parse_bitor(list_t *tokens, size_t *pos) {
  node_t *a = parse_bitxor(tokens, pos);

  while (MATCH(BAR)) {
    node_t *b = parse_bitxor(tokens, pos);

    a = NODE2(BOR, a, b);
  }

  return a;
}

node_t *parse_logand(list_t *tokens, size_t *pos) {
  node_t *a = parse_bitor(tokens, pos);

  if (MATCH(ANDAND)) {
    node_t *b = parse_logand(tokens, pos);

    return NODE2(LOGAND, a, b);
  }

  return a;
}

node_t *parse_logor(list_t *tokens, size_t *pos) {
  node_t *a = parse_logand(tokens, pos);

  if (MATCH(BARBAR)) {
    node_t *b = parse_logor(tokens, pos);

    return NODE2(LOGOR, a, b);
  }

  return a;
}

node_t *parse_assignment(list_t *tokens, size_t *pos);

node_t *parse_conditional(list_t *tokens, size_t *pos) {
  node_t *a = parse_logor(tokens, pos);

  if (MATCH(QM)) {
    node_t *b = parse_assignment(tokens, pos);

    EXPECT(COLON, ":");

    node_t *c = parse_assignment(tokens, pos);

    return NODE3(IFEXPR, a, b, c);
  }

  return a;
}

node_t *parse_assignment(list_t *tokens, size_t *pos) {
  node_t *a = parse_conditional(tokens, pos);

  if (MATCH(COLONASSIGN)) {
    node_t *b = parse_assignment(tokens, pos);

    return NODE2(DECL, a, b);
  } else if (MATCH(ASSIGN)) {
    node_t *b = parse_assignment(tokens, pos);

    return NODE2(ASSIGN, a, b);
  } else if (MATCH(PLUSASSIGN)) {
    node_t *b = parse_assignment(tokens, pos);

    return NODE2(ASSIGN_ADD, a, b);
  } else if (MATCH(MINUSASSIGN)) {
    node_t *b = parse_assignment(tokens, pos);

    return NODE2(ASSIGN_SUB, a, b);
  } else if (MATCH(STARASSIGN)) {
    node_t *b = parse_assignment(tokens, pos);

    return NODE2(ASSIGN_MUL, a, b);
  } else if (MATCH(SLASHASSIGN)) {
    node_t *b = parse_assignment(tokens, pos);

    return NODE2(ASSIGN_DIV, a, b);
  } else if (MATCH(SLASHSLASHASSIGN)) {
    node_t *b = parse_assignment(tokens, pos);

    return NODE2(ASSIGN_IDIV, a, b);
  } else if (MATCH(PERCENTASSIGN)) {
    node_t *b = parse_assignment(tokens, pos);

    return NODE2(ASSIGN_MOD, a, b);
  } else if (MATCH(STARSTARASSIGN)) {
    node_t *b = parse_assignment(tokens, pos);

    return NODE2(ASSIGN_POW, a, b);
  } else if (MATCH(BARASSIGN)) {
    node_t *b = parse_assignment(tokens, pos);

    return NODE2(ASSIGN_BOR, a, b);
  } else if (MATCH(ANDASSIGN)) {
    node_t *b = parse_assignment(tokens, pos);

    return NODE2(ASSIGN_BAND, a, b);
  } else if (MATCH(RAISEASSIGN)) {
    node_t *b = parse_assignment(tokens, pos);

    return NODE2(ASSIGN_XOR, a, b);
  } else if (MATCH(LTLTASSIGN)) {
    node_t *b = parse_assignment(tokens, pos);

    return NODE2(ASSIGN_SHL, a, b);
  } else if (MATCH(GTGTASSIGN)) {
    node_t *b = parse_assignment(tokens, pos);

    return NODE2(ASSIGN_SHR, a, b);
  }

  return a;
}

node_t *parse_expr(list_t *tokens, size_t *pos) {
  return parse_assignment(tokens, pos);
}

node_t *parse_comma_expr(list_t *tokens, size_t *pos) {
  node_t *a = parse_expr(tokens, pos);

  if (MATCH(COMMA)) {
    list_t *exprs = list_new();
    list_push(exprs, a);

    do {
      list_push(exprs, parse_expr(tokens, pos));
    } while (MATCH(COMMA));

    a = NODEL(COMMA, exprs);
  }

  return a;
}

node_t *parse_block(list_t *tokens, size_t *pos) {
  EXPECT(LCB, "{");

  list_t *stmts = list_new();
  while (!AT(EOF) && !AT(RCB)) {
    list_push(stmts, parse_stmt_c(tokens, pos));

    MATCH(SEMI);
  }

  EXPECT(RCB, "}");

  return NODEL(PROGRAM, stmts);
}

#define BLOCK()                                                                \
  (CLIFF || MATCH(COLON) ? parse_stmt(tokens, pos) : parse_block(tokens, pos))
#define STMT_OR_BLOCK()                                                        \
  (MATCH(COLON) ? parse_stmt(tokens, pos)                                      \
   : AT(LCB)    ? parse_block(tokens, pos)                                     \
                : parse_stmt(tokens, pos))

node_t *parse_if(list_t *tokens, size_t *pos) {
  node_t *a = parse_comma_expr(tokens, pos);
  node_t *b = BLOCK();
  node_t *c = NULL;

  if (MATCH(ELSE))
    c = STMT_OR_BLOCK();
  else if (MATCH(ELIF))
    c = parse_if(tokens, pos);

  return NODE3(IF, a, b, c);
}

node_t *parse_var(list_t *tokens, size_t *pos, int is_let) {
  table_t *h = table_new();

  do {
    if (!AT(NAME))
      PARSE_ERROR("expected identifier");

    char *k = ((token_t *)tokens->data[(*pos)++])->text;
    node_t *v = NULL;

    if (is_let) {
      EXPECT(ASSIGN, "=");

      v = parse_expr(tokens, pos);
    } else if (MATCH(ASSIGN))
      v = parse_expr(tokens, pos);

    table_set(h, k, v);
  } while (MATCH(COMMA));

  if (is_let)
    return NODEH(LET, h);

  return NODEH(VAR, h);
}

node_t *parse_unpack(list_t *tokens, size_t *pos, int tag) {
  EXPECT(LSB, "[");

  list_t *l = list_new();

  do {
    if (!AT(NAME))
      PARSE_ERROR("expected identifier");

    list_push(l, ((token_t *)tokens->data[(*pos)++])->text);
  } while (MATCH(COMMA));

  EXPECT(RSB, "]");
  EXPECT(ASSIGN, "=");

  node_t *a = parse_expr(tokens, pos);

  if (tag == N_LETUNPACK)
    return NODE1l(LETUNPACK, a, l);

  return NODE1l(VARUNPACK, a, l);
}

node_t *parse_func(list_t *tokens, size_t *pos, int is_expr) {
  token_t *name = NULL;

  if (!is_expr) {
    if (!AT(NAME))
      PARSE_ERROR("expected identifier");

    name = tokens->data[(*pos)++];
  }

  table_t *params = NULL;

  if (MATCH(LPAR)) {
    if (!AT(RPAR)) {
      int flag = 0;

      params = table_new();

      size_t argc = 0;

      do {
        if (!AT(NAME))
          PARSE_ERROR("expected identifier");

        char *l = ((token_t *)tokens->data[(*pos)++])->text;
        node_t *r = NULL;

        if (!flag && AT(ASSIGN))
          flag = 1;

        if (flag) {
          EXPECT(ASSIGN, "=");

          r = parse_expr(tokens, pos);
        }

        list_t *pair = list_new();

        size_t *argcp = malloc_checked(sizeof(size_t));
        memcpy(argcp, &argc, sizeof(size_t));

        argc++;

        list_push(pair, argcp);
        list_push(pair, r);

        table_set(params, l, pair);
      } while (MATCH(COMMA));
    }

    EXPECT(RPAR, ")");
  }

  table_t *captured = NULL;

  if (MATCH(USE)) {
    EXPECT(LPAR, "(");

    captured = table_new();

    do {
      if (!AT(NAME))
        PARSE_ERROR("expected identifier");

      token_t *name = tokens->data[(*pos)++];

      table_set(captured, name->text, NODET(LITERAL, name));
    } while (MATCH(COMMA));

    EXPECT(RPAR, ")");
  }

  int colon = AT(COLON);

  node_t *body = !colon && !AT(LCB) ? parse_stmt(tokens, pos) : BLOCK();

  if (colon && body->tag == N_EXPRSTMT)
    body = NODE1(RETURN, body->a);

  if (is_expr)
    return NODEF(FUNCEXPR, NULL, params, captured, body);

  return NODEF(FUNCDEF, name, params, captured, body);
}

node_t *_parse_stmt(list_t *tokens, size_t *pos, int allow_comma) {
  if (MATCH(LCB)) {
    list_t *stmts = list_new();

    while (!AT(EOF) && !AT(RCB)) {
      node_t *n = parse_stmt_c(tokens, pos);

      MATCH(SEMI);

      list_push(stmts, n);
    }

    EXPECT(RCB, "}");

    return NODEL(BLOCK, stmts);
  } else if (MATCH(VAR)) {
    if (AT(LSB))
      return parse_unpack(tokens, pos, N_VARUNPACK);

    return parse_var(tokens, pos, 0);
  } else if (MATCH(LET)) {
    if (AT(LSB))
      return parse_unpack(tokens, pos, N_LETUNPACK);

    return parse_var(tokens, pos, 1);
  } else if (MATCH(CONST)) {
    table_t *h = table_new();

    do {
      if (!AT(NAME))
        PARSE_ERROR("expected identifier");

      char *k = ((token_t *)tokens->data[(*pos)++])->text;

      if (k[0] != '_' && !(k[0] >= 'A' && k[0] <= 'Z'))
        PARSE_ERROR("compile-time constant identifiers must begin with an "
                    "uppercase letter or with an underscore, but '%s' does not",
                    k);

      if (table_get(h, k))
        PARSE_ERROR("duplicated compile-time constant definition: '%s'", k);

      EXPECT(ASSIGN, "=");

      node_t *v = parse_expr(tokens, pos);

      table_set(h, k, v);
    } while (MATCH(COMMA));

    return NODEH(CONST, h);
  } else if (MATCH(ENUM)) {
    table_t *h = table_new();

    EXPECT(LCB, "{");

    do {
      if (!AT(NAME))
        PARSE_ERROR("expected identifier");

      char *k = ((token_t *)tokens->data[(*pos)++])->text;

      if (k[0] != '_' && !(k[0] >= 'A' && k[0] <= 'Z'))
        PARSE_ERROR("compile-time constant identifiers must begin with an "
                    "uppercase letter or with an underscore, but '%s' does not",
                    k);

      if (table_get(h, k))
        PARSE_ERROR("duplicated compile-time constant definition: '%s'", k);

      node_t *v = NULL;

      if (MATCH(ASSIGN))
        v = parse_expr(tokens, pos);

      table_set(h, k, v);
    } while (MATCH(COMMA));

    EXPECT(RCB, "}");

    return NODEH(ENUM, h);
  } else if (MATCH(IF))
    return parse_if(tokens, pos);
  else if (MATCH(SWITCH)) {
    token_t *label = NULL;

    if (MATCH(AT)) {
      if (!AT(NAME))
        PARSE_ERROR("expected identifier");

      label = tokens->data[(*pos)++];
    }

    node_t *a = parse_expr(tokens, pos);

    EXPECT(LCB, "{");

    list_t *cases = list_new();
    int has_default = 0;

    for (;;) {
      if (AT(RCB))
        break;

      node_t *expr = NULL;
      list_t *stmts = list_new();

      if (MATCH(DEFAULT)) {
        if (has_default)
          PARSE_ERROR("duplicated default case in switch");

        has_default = 1;
      } else {
        EXPECT(CASE, "case");

        expr = parse_expr(tokens, pos);
      }

      MATCH(COLON);

      while (!AT(CASE) && !AT(DEFAULT) && !AT(RCB))
        list_push(stmts, parse_stmt(tokens, pos));

      list_t *pair = list_new();
      list_push(pair, expr);
      list_push(pair, NODEL(PROGRAM, stmts));

      list_push(cases, pair);
    }

    EXPECT(RCB, "}");

    if (!cases->length)
      PARSE_ERROR("empty switch statement");

    LABELLOOP(NODE1l(SWITCH, a, cases));

    return ln;
  } else if (MATCH(FOR)) {
    token_t *label = NULL;

    if (MATCH(AT)) {
      if (!AT(NAME))
        PARSE_ERROR("expected identifier");

      label = tokens->data[(*pos)++];
    }

    node_t *a = NULL;
    node_t *b = NULL;
    node_t *c = NULL;

    if (!AT(LCB) && !AT(COLON) && !CLIFF) {
      if (MATCH(LSB)) {
        list_t *l = list_new();

        do {
          if (!AT(NAME))
            PARSE_ERROR("expected identifier");

          list_push(l, ((token_t *)tokens->data[(*pos)++])->text);
        } while (MATCH(COMMA));

        EXPECT(RSB, "]");
        EXPECT(OF, "of");

        a = parse_expr(tokens, pos);
        b = BLOCK();

        LABELLOOP(NODE2l(FOROFUNPACK, a, b, l));

        return ln;
      }

      if (AT(NAME) && ATP(OF, 1)) {
        token_t *t = tokens->data[(*pos)++];

        EXPECT(OF, "of");

        a = parse_expr(tokens, pos);
        b = BLOCK();

        LABELLOOP(NODE2t(FOROF, a, b, t));

        return ln;
      }

      if (MATCH(VAR)) {
        if (MATCH(LSB)) {
          list_t *l = list_new();

          do {
            if (!AT(NAME))
              PARSE_ERROR("expected identifier");

            list_push(l, ((token_t *)tokens->data[(*pos)++])->text);
          } while (MATCH(COMMA));

          EXPECT(RSB, "]");
          EXPECT(OF, "of");

          a = parse_expr(tokens, pos);
          b = BLOCK();

          LABELLOOP(NODE2l(FOROFVARUNPACK, a, b, l));

          return ln;
        }

        if (AT(NAME) && ATP(OF, 1)) {
          token_t *t = tokens->data[(*pos)++];

          EXPECT(OF, "of");

          a = parse_expr(tokens, pos);
          b = BLOCK();

          LABELLOOP(NODE2t(FOROFVAR, a, b, t));

          return ln;
        }

        a = parse_var(tokens, pos, 0);
        EXPECT(SEMI, ";");
        b = parse_comma_expr(tokens, pos);

        if (MATCH(SEMI))
          c = parse_comma_expr(tokens, pos);
      } else {
        a = parse_comma_expr(tokens, pos);

        if (MATCH(SEMI)) {
          b = parse_comma_expr(tokens, pos);

          if (MATCH(SEMI))
            c = parse_comma_expr(tokens, pos);
        }
      }
    }

    node_t *d = BLOCK();

    LABELLOOP(NODE4(FOR, a, b, c, d));

    return ln;
  } else if (MATCH(BREAK)) {
    if ((AT(NUMBER) || AT(NAME)) && !CLIFF)
      return NODET(BREAK, tokens->data[(*pos)++]);

    return NODE0(BREAK);
  } else if (MATCH(CONTINUE)) {
    if ((AT(NUMBER) || AT(NAME)) && !CLIFF)
      return NODET(CONTINUE, tokens->data[(*pos)++]);

    return NODE0(CONTINUE);
  } else if (MATCH(FUNC))
    return parse_func(tokens, pos, 0);
  else if (MATCH(RETURN)) {
    node_t *a = NULL;

    if (!AT(EOF) && !AT(RCB) && !CLIFF) {
      a = parse_expr(tokens, pos);

      if (!CLIFF_AHEAD && MATCH(COMMA)) {
        list_t *l = list_new();
        list_push(l, a);

        do {
          list_push(l, parse_expr(tokens, pos));
        } while (!CLIFF_AHEAD && MATCH(COMMA));

        a = NODEL(TUPLE, l);
      }
    }

    return NODE1(RETURN, a);
  } else if (MATCH(DEFER)) {
    node_t *a;

    if (AT(LCB))
      a = BLOCK();
    else
      a = parse_stmt(tokens, pos);

    return NODE1(DEFER, a);
  } else if (MATCH(PASS))
    return NODE0(PASS);
  else if (MATCH(TRY)) {
    node_t *a = BLOCK();
    token_t *t = NULL;

    EXPECT(CATCH, "catch");

    if (!AT(COLON) && !AT(LCB) && !CLIFF) {
      if (!AT(NAME))
        PARSE_ERROR("expected identifier");

      t = tokens->data[(*pos)++];
    }

    node_t *b = BLOCK();
    node_t *c = NULL;

    if (MATCH(FINALLY))
      c = BLOCK();

    return NODE3t(TRY, a, b, c, t);
  } else if (MATCH(THROW)) {
    node_t *a = NULL;

    if (!CLIFF && !AT(COMMA) && !AT(RPAR) && !AT(RCB) && !AT(EOF))
      a = parse_expr(tokens, pos);

    return NODE1(THROW, a);
  } else if (MATCH(GOTO)) {
    if (!AT(NAME))
      PARSE_ERROR("expected identifier");

    token_t *t = tokens->data[(*pos)++];

    return NODET(GOTO, t);
  } else if (AT(NAME) && ATP(COLON, 1) && !CLIFF_AHEAD) {
    token_t *t = tokens->data[(*pos)++];

    EXPECT(COLON, ":");

    return NODET(LABEL, t);
  } else if (MATCH(CLASS)) {
    if (!AT(NAME))
      PARSE_ERROR("expected identifier");

    token_t *t = tokens->data[(*pos)++];

    list_t *l = NULL;

    if (MATCH(LPAR)) {
      l = list_new();

      do {
        if (!AT(NAME))
          PARSE_ERROR("expected identifier");

        token_t *t = tokens->data[(*pos)++];

        list_push(l, t);
      } while (MATCH(COMMA));

      EXPECT(RPAR, ")");
    }

    list_t *triples = list_new();

    if (!CLIFF && !AT(EOF) && !AT(SEMI)) {
      EXPECT(LCB, "{");

      for (;;) {
        int is_out = 0;
        int is_static = 0;

        if (AT(RCB))
          break;

        if (MATCH(LET))
          is_out = 1;
        else if (MATCH(CONST))
          is_static = 1;

        if (!AT(NAME))
          PARSE_ERROR("expected identifier");

        list_t *triple = list_new();

        token_t *t = tokens->data[(*pos)++];
        list_push(triple, t);

        int *flagp = malloc_checked(sizeof(int));
        int flag = is_static ? 2 : is_out ? 1 : 0;

        memcpy(flagp, &flag, sizeof(int));

        if (MATCH(ASSIGN)) {
          list_push(triple, flagp);
          list_push(triple, parse_expr(tokens, pos));
        } else {
          list_push(triple, flagp);
          list_push(triple, parse_func(tokens, pos, 1));
        }

        list_push(triples, triple);
      }

      EXPECT(RCB, "}");
    }

    list_t *pair = list_new();
    list_push(pair, l);
    list_push(pair, triples);

    return NODETL(CLASS, t, pair);
  } else if (MATCH(DEL)) {
    node_t *a = parse_expr(tokens, pos);

    return NODE1(DEL, a);
  } else if (MATCH(WITH)) {
    node_t *a = parse_expr(tokens, pos);

    EXPECT(AS, "as");

    if (!AT(NAME))
      PARSE_ERROR("expected identifier");

    token_t *t = tokens->data[(*pos)++];
    node_t *b = STMT_OR_BLOCK();

    return NODE2t(WITH, a, b, t);
  } else if (MATCH(INLINE)) {
    if (!AT(STRING))
      PARSE_ERROR("expected string");

    token_t *t = tokens->data[(*pos)++];

    return NODET(INLINE, t);
  }

  return NODE1(EXPRSTMT, allow_comma ? parse_comma_expr(tokens, pos)
                                     : parse_expr(tokens, pos));
}

#define ATM(t)                                                                 \
  (AT(MVAR) && strcmp(((token_t *)tokens->data[*pos])->text, t) == 0)
#define MATCHM(t) (ATM(t) && MATCH(MVAR))

node_t *parse_mexpr(list_t *tokens, size_t *pos);

node_t *parse_mprimary(list_t *tokens, size_t *pos) {
  if (MATCH(STAR))
    return NODET(LITERAL, token(T_NAME, strdup("*")));
  else if (MATCHM("{")) {
    node_t *a = parse_stmt(tokens, pos);

    if (!MATCHM("}"))
      PARSE_ERROR("expected }$");

    if (a->tag == N_EXPRSTMT)
      a = a->a;

    return NODE1(MSTMT, a);
  } else if (MATCH(LPAR)) {
    node_t *a = parse_mexpr(tokens, pos);

    EXPECT(RPAR, ")");

    return a;
  } else if (MATCH(NAME) || MATCH(TRUE) || MATCH(FALSE) || MATCH(NIL)) {
    token_t *t = tokens->data[(*pos) - 1];

    int macro = 0;
    if (!CLIFF && !CLIFF_AHEAD && AT(BANG) && ATP(LPAR, 1)) {
      MATCH(BANG);

      macro = 1;
    }

    if (!CLIFF && MATCH(LPAR)) {
      list_t *args = list_new();

      if (!AT(RPAR))
        do {
          list_push(args, parse_mexpr(tokens, pos));
        } while (MATCH(COMMA));

      EXPECT(RPAR, ")");

      if (macro)
        return NODETL(MACRO_CALL, t, args);

      return NODETL(CALL, t, args);
    }

    return NODET(LITERAL, t);
  } else if (MATCH(NUMBER) || MATCH(STRING))
    return NODET(LITERAL, tokens->data[(*pos) - 1]);

  PARSE_ERROR("expected m-expression");

  return NULL;
}

node_t *parse_mexpr(list_t *tokens, size_t *pos) {
  if (MATCH(MINUS)) {
    node_t *a = parse_mexpr(tokens, pos);

    return NODE1(NEGATE, a);
  }

  node_t *a = parse_mprimary(tokens, pos);

  do {
    if (MATCH(BAR)) {
      node_t *b = parse_mprimary(tokens, pos);

      a = NODE2(LOGOR, a, b);

      continue;
    } else if (MATCH(AND)) {
      node_t *b = parse_mprimary(tokens, pos);

      a = NODE2(LOGAND, a, b);

      continue;
    } else if (MATCH(PLUS)) {
      node_t *b = parse_mprimary(tokens, pos);

      a = NODE2(ADD, a, b);

      continue;
    } else if (MATCH(MINUS)) {
      node_t *b = parse_mprimary(tokens, pos);

      a = NODE2(SUB, a, b);

      continue;
    } else if (MATCH(STAR)) {
      node_t *b = parse_mprimary(tokens, pos);

      a = NODE2(MUL, a, b);

      continue;
    } else if (MATCH(SLASH)) {
      node_t *b = parse_mprimary(tokens, pos);

      a = NODE2(DIV, a, b);

      continue;
    } else if (MATCH(ASSIGN)) {
      node_t *b = parse_mprimary(tokens, pos);

      a = NODE2(EQUALS, a, b);

      continue;
    } else if (MATCH(LT)) {
      node_t *b = parse_mprimary(tokens, pos);

      a = NODE2(LT, a, b);

      continue;
    } else if (MATCH(GT)) {
      node_t *b = parse_mprimary(tokens, pos);

      a = NODE2(GT, a, b);

      continue;
    }

    break;
  } while (1);

  return a;
}

node_t *parse_mstmt(list_t *tokens, size_t *pos);

node_t *parse_mif(list_t *tokens, size_t *pos, int sub) {
  node_t *a = parse_mexpr(tokens, pos);
  list_t *l = list_new();
  list_t *l2 = NULL;

  while (!AT(EOF) && !ATM("else") && !ATM("elif") && !ATM("endif"))
    list_push(l, parse_mstmt(tokens, pos));

  if (MATCHM("elif")) {
    l2 = list_new();

    list_push(l2, parse_mif(tokens, pos, 1));
  } else if (MATCHM("else")) {
    l2 = list_new();

    while (!AT(EOF) && !ATM("endif"))
      list_push(l2, parse_mstmt(tokens, pos));
  }

  if (!sub && !MATCHM("endif"))
    PARSE_ERROR("expected $endif");

  return NODE1l2(MIF, a, l, l2);
}

node_t *parse_mstmt(list_t *tokens, size_t *pos) {
  if (MATCHM("if"))
    return parse_mif(tokens, pos, 0);
  else if (MATCHM("for")) {
    node_t *a = parse_mexpr(tokens, pos);
    list_t *l = list_new();

    while (!AT(EOF) && !ATM("endfor"))
      list_push(l, parse_mstmt(tokens, pos));

    if (!MATCHM("endfor"))
      PARSE_ERROR("expected $endfor");

    return NODE1l(MFOR, a, l);
  } else if (MATCHM("repeat")) {
    node_t *a = parse_mexpr(tokens, pos);
    list_t *l = list_new();

    while (!AT(EOF) && !ATM("endrep"))
      list_push(l, parse_mstmt(tokens, pos));

    if (!MATCHM("endrep"))
      PARSE_ERROR("expected $endrep");

    return NODE1l(MREPEAT, a, l);
  } else if (MATCHM("set")) {
    if (!AT(NAME))
      PARSE_ERROR("expected identifier");

    token_t *t = tokens->data[(*pos)++];
    node_t *a = parse_mexpr(tokens, pos);

    return NODE1t(MSET, a, t);
  } else if (MATCHM("push")) {
    if (!AT(NAME))
      PARSE_ERROR("expected identifier");

    token_t *t = tokens->data[(*pos)++];
    node_t *a = parse_mexpr(tokens, pos);

    return NODE1t(MPUSH, a, t);
  } else if (MATCHM("$")) {
    node_t *a = parse_stmt(tokens, pos);

    if (a->tag == N_EXPRSTMT)
      a = a->a;

    return NODE1(MSTMT, a);
  } else if (MATCHM("{")) {
    list_t *stmts = list_new();

    while (!AT(EOF) && !ATM("}")) {
      list_push(stmts, parse_stmt(tokens, pos));

      MATCH(SEMI);
    }

    if (!MATCHM("}"))
      PARSE_ERROR("expected }$");

    return NODE1(MSTMT, nodel(N_PROGRAM, stmts));
  } else if (MATCHM(":"))
    return NODE1(MEXPR, parse_mexpr(tokens, pos));

  node_t *a = parse_stmt(tokens, pos);

  if (a->tag == N_EXPRSTMT)
    a = a->a;

  return a;
}

list_t *macros_get(char *name) {
  list_t *val = NULL;

  for (ssize_t i = MACROS->length - 1; i >= 0; i--)
    if ((val = table_get(MACROS->data[i], name)))
      break;

  return val;
}

node_t *parse_program(list_t *tokens, size_t *pos) {
  if (AT(EOF))
    PARSE_ERROR("empty program");

  list_t *stmts = list_new();

  int flag = 0;

  while (!AT(EOF) && *pos < tokens->length) {
    node_t *n = NULL;

    if (MATCH(REQUIRE)) {
      if (flag)
        PARSE_ERROR("misplaced require statement")

      list_t *paths = list_new();

      do {
        if (!AT(STRING) && !AT(NAME))
          PARSE_ERROR("expected string or identifier");

        list_push(paths, tokens->data[(*pos)++]);
      } while (MATCH(COMMA));

      n = NODEL(REQUIRE, paths);
    } else if (MATCH(HEADER)) {
      if (flag)
        PARSE_ERROR("misplaced header statement")

      if (!AT(STRING))
        PARSE_ERROR("expected string");

      token_t *text = tokens->data[(*pos)++];

      n = NODET(HEADER, text);
    } else if (MATCH(INCLUDE)) {
      if (flag)
        PARSE_ERROR("misplaced include statement")

      if (!AT(STRING))
        PARSE_ERROR("expected string");

      token_t *text = tokens->data[(*pos)++];

      n = NODET(INCLUDE, text);
    } else if (MATCH(MACRO)) {
      if (!AT(NAME))
        PARSE_ERROR("expected identifier");

      char *name = ((token_t *)tokens->data[(*pos)++])->text;

      EXPECT(LPAR, "(");

      int variable = 0;
      list_t *params = list_new();

      if (!AT(RPAR)) {
        if (MATCH(STAR))
          variable = 1;
        else
          do {
            if (!AT(NAME))
              PARSE_ERROR("expected identifier");

            list_push(params, tokens->data[(*pos)++]);
          } while (MATCH(COMMA));
      }

      EXPECT(RPAR, ")");

      list_t *body = list_new();

      if (MATCH(COLON) || !AT(LCB))
        list_push(body, parse_mstmt(tokens, pos));
      else {
        EXPECT(LCB, "{");

        while (!AT(EOF) && !AT(RCB))
          list_push(body, parse_mstmt(tokens, pos));

        EXPECT(RCB, "}");
      }

      list_t *ms = macros_get(name);
      if (!ms) {
        ms = list_new();

        table_set(list_index(MACROS, -1), name, ms);
      }

      macro_t *m = malloc_checked(sizeof(macro_t));
      m->name = name;
      m->params = params;
      m->body = body;
      m->variable = variable;

      list_push(ms, m);
    } else {
      n = parse_stmt_c(tokens, pos);
      flag = 1;
    }

    MATCH(SEMI);

    if (n)
      list_push(stmts, n);
  }

  return NODEL(TOPLEVEL, stmts);
}

node_t *parse(char *source) {
  size_t pos = 0;

  return parse_program(tokenize(source), &pos);
}

#define NEWGID() size_t gid = GID++

#define EMIT(fmt, ...) buffer_fmt(buf, (fmt), ##__VA_ARGS__);
#define BINOP(s)                                                               \
  {                                                                            \
    EMIT("qi_" s "(state, ");                                                  \
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);              \
    EMIT(", ");                                                                \
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b);              \
    EMIT(")");                                                                 \
  }
#define UNOP(s)                                                                \
  {                                                                            \
    EMIT("qi_" s "(state, ");                                                  \
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);              \
    EMIT(")");                                                                 \
  }
#define ASSIGNIN(buf, lhs, rhs, prefix)                                        \
  {                                                                            \
    if ((lhs)->tag == N_LITERAL && (lhs)->t->tag == T_NAME) {                  \
      buffer_fmt(buf, "qi_set(state, " #prefix ", \"%s\", ", (lhs)->t->text);  \
      rhs;                                                                     \
      buffer_fmt(buf, ")");                                                    \
    } else if ((lhs)->tag == N_INDEX) {                                        \
      buffer_fmt(buf, "qi_index_set(state, " #prefix ", ");                    \
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, (lhs)->a);           \
      buffer_fmt(buf, ", ");                                                   \
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, (lhs)->b);           \
      buffer_fmt(buf, ", ");                                                   \
      rhs;                                                                     \
      buffer_fmt(buf, ")");                                                    \
    } else if ((lhs)->tag == N_MEMBER) {                                       \
      buffer_fmt(buf, "qi_index_set(state, " #prefix ", ");                    \
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, (lhs)->a);           \
      buffer_fmt(buf, ", qi_make_string(state, \"%s\"), ", (lhs)->t->text);    \
      rhs;                                                                     \
      buffer_fmt(buf, ")");                                                    \
    } else                                                                     \
      COMPILE_ERROR("illegal assignment left-hand side");                      \
  }
#define ASSIGN(lhs, rhs) ASSIGNIN(buf, lhs, rhs, false)
#define DECLIN(buf, lhs, rhs)                                                  \
  {                                                                            \
    if ((lhs)->tag == N_LITERAL && (lhs)->t->tag == T_NAME) {                  \
      buffer_fmt(buf, "qi_decl_expr(state, \"%s\", ", (lhs)->t->text);         \
      rhs;                                                                     \
      buffer_fmt(buf, ")");                                                    \
    } else                                                                     \
      COMPILE_ERROR("illegal declaration left-hand side");                     \
  }
#define DECL(lhs, rhs) DECLIN(buf, lhs, rhs)
#define COMPASSIGN(lhs, s, rhs)                                                \
  {                                                                            \
    ASSIGN(node->a, {                                                          \
      EMIT("qi_%s(state, ", s);                                                \
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, (lhs));              \
      EMIT(", ");                                                              \
      rhs;                                                                     \
      EMIT(")");                                                               \
    });                                                                        \
  }
#define COMPASSIGNP(lhs, s, rhs)                                               \
  {                                                                            \
    ASSIGNIN(                                                                  \
        buf, node->a,                                                          \
        {                                                                      \
          EMIT("qi_%s(state, ", s);                                            \
          compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, (lhs));          \
          EMIT(", ");                                                          \
          rhs;                                                                 \
          EMIT(")");                                                           \
        },                                                                     \
        true);                                                                 \
  }
#define COMPILE_ERROR(fmt, ...)                                                \
  {                                                                            \
    format_error(GETFNAME(node->fi), GETSRC(node->fi), node->pos, fmt,         \
                 ##__VA_ARGS__);                                               \
    exit(1);                                                                   \
  }
#define COMPILE_NOTE(fmt, ...)                                                 \
  {                                                                            \
    format_error(GETFNAME(node->fi), GETSRC(node->fi), node->pos, fmt,         \
                 ##__VA_ARGS__);                                               \
  }

void compile_node(buffer_t *gbuf, buffer_t *buf, list_t *ctx, table_t *ltab,
                  list_t *lstk, list_t *sstk, list_t *lbl, node_t *node);

char *tempvar() {
  NEWGID();

  char *s = malloc_checked(sizeof(char) * (64 + strlen(PREFIX)));
  snprintf(s, 64 + strlen(PREFIX), "__%s%zu", PREFIX, gid);

  return s;
}

void compile_list(buffer_t *gbuf, buffer_t *buf, list_t *ctx, table_t *ltab,
                  list_t *lstk, list_t *sstk, list_t *lbl, list_t *seq) {
  if (!seq || seq->length < 1) {
    EMIT("NULL");

    return;
  }

  int has_star = 0;

  for (size_t i = 0; i < seq->length; i++)
    if (((node_t *)seq->data[i])->tag == N_STAR) {
      has_star = 1;
      break;
    }

  buffer_t *tbuf = buffer_new();

  NEWGID();

  buffer_fmt(tbuf, "inline static qi_list_t *__%s%d(qi_state_t *state) {\n",
             PREFIX, gid);
  if (has_star)
    buffer_fmt(tbuf, "qi_list_t *list = qi_list_make();\n");
  else
    buffer_fmt(tbuf, "qi_list_t *list = qi_list_make_n(%d);\n", seq->length);

  for (size_t i = 0; i < seq->length; i++) {
    node_t *node = seq->data[i];

    if (!has_star) {
      buffer_fmt(tbuf, "qi_list_data(list, %d) = ", i);
      compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node);
      buffer_fmt(tbuf, ";\n");

      continue;
    }

    if (node->tag == N_STAR) {
      char *varname = tempvar();

      buffer_fmt(tbuf, "qi_value_t *%s = qi_iter(state, ", varname);
      compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->a);
      buffer_fmt(tbuf, ");\n");

      buffer_fmt(tbuf,
                 "for (qi_size_t i = 0; i < %s->value.list->length; i++)\n",
                 varname);
      buffer_fmt(tbuf,
                 "qi_list_push(list, qi_index(state, %s, qi_make_number(state, "
                 "i)));\n",
                 varname);
    } else {
      buffer_fmt(tbuf, "qi_list_push(list, ");
      compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node);
      buffer_fmt(tbuf, ");\n");
    }
  }

  buffer_fmt(tbuf, "return list;\n");
  buffer_fmt(tbuf, "}\n");

  buffer_appendb(gbuf, tbuf);

  EMIT("__%s%d(state)", PREFIX, gid);
}

void compile_table(buffer_t *gbuf, buffer_t *buf, list_t *ctx, table_t *ltab,
                   list_t *lstk, list_t *sstk, list_t *lbl, table_t *table) {
  if (!table || table->used < 1) {
    EMIT("NULL");

    return;
  }

  buffer_t *tbuf = buffer_new();

  NEWGID();

  buffer_fmt(tbuf, "inline static qi_table_t *__%s%d(qi_state_t *state) {\n",
             PREFIX, gid);
  buffer_fmt(tbuf, "qi_table_t *table = qi_table_make();\n");

  table_iterate(table, {
    buffer_fmt(tbuf, "qi_table_set(table, \"%s\", ", entry.key);

    compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, entry.value);

    buffer_fmt(tbuf, ");\n");
  });

  buffer_fmt(tbuf, "return table;\n");
  buffer_fmt(tbuf, "}\n");

  buffer_appendb(gbuf, tbuf);

  EMIT("__%s%d(state)", PREFIX, gid);
}

void compile_pairs(buffer_t *gbuf, buffer_t *buf, list_t *ctx, table_t *ltab,
                   list_t *lstk, list_t *sstk, list_t *lbl, list_t *pairs) {
  if (!pairs || pairs->length < 1) {
    EMIT("NULL");

    return;
  }

  buffer_t *tbuf = buffer_new();

  NEWGID();

  buffer_fmt(tbuf, "inline static qi_table_t *__%s%d(qi_state_t *state) {\n",
             PREFIX, gid);
  buffer_fmt(tbuf, "qi_table_t *table = qi_table_make();\n");

  for (size_t i = 0; i < pairs->length; i++) {
    list_t *pair = pairs->data[i];

    buffer_fmt(tbuf, "qi_table_set(table, qi_to_string(state, ");
    compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, pair->data[0]);
    buffer_fmt(tbuf, ")->value.string, ");
    compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, pair->data[1]);
    buffer_fmt(tbuf, ");\n");
  }

  buffer_fmt(tbuf, "return table;\n");
  buffer_fmt(tbuf, "}\n");

  buffer_appendb(gbuf, tbuf);

  EMIT("__%s%d(state)", PREFIX, gid);
}

#define CTXPUSH(s) list_push(ctx, (s))
#define CTXPOP() list_pop(ctx)

int in_context(list_t *ctx, char *s) {
  if (!ctx->length)
    return 0;

  for (ssize_t i = ctx->length - 1; i >= 0; i--)
    if (strcmp(ctx->data[i], "gap") == 0)
      break;
    else if (strcmp(ctx->data[i], s) == 0)
      return 1;

  return 0;
}

int in_switch(list_t *ctx) {
  if (!ctx->length)
    return 0;

  for (ssize_t i = ctx->length - 1; i >= 0; i--)
    if (strcmp(ctx->data[i], "gap") == 0 || strcmp(ctx->data[i], "for") == 0)
      break;
    else if (strcmp(ctx->data[i], "switch") == 0)
      return 1;

  return 0;
}

size_t count_ctxs(list_t *ctx, char *s) {
  if (!ctx->length)
    return 0;

  size_t k = 0;

  for (ssize_t i = ctx->length - 1; i >= 0; i--)
    if (strcmp(ctx->data[i], "gap") == 0)
      break;
    else if (strcmp(ctx->data[i], s) == 0)
      k++;

  return k;
}

list_t *CONSTANTS;

#define INCTX(s) (in_context(ctx, (s)))
#define SCOPESK (count_ctxs(ctx, "scope"))
#define TRAPSK (count_ctxs(ctx, "trap"))

#define LPUSH(i)                                                               \
  {                                                                            \
    int_stack_t *pair = stack_new();                                           \
    stack_push(pair, (i));                                                     \
    stack_push(pair, scope_index(ctx));                                        \
    list_push(lstk, pair);                                                     \
  }
#define LPOP() list_pop(lstk)
#define LID (((int_stack_t *)lstk->data[lstk->length - 1])->data[0])

#define SPUSH(i)                                                               \
  {                                                                            \
    int_stack_t *pair = stack_new();                                           \
    stack_push(pair, (i));                                                     \
    stack_push(pair, scope_index(ctx));                                        \
    list_push(sstk, pair);                                                     \
  }
#define SPOP() list_pop(sstk)
#define SID (sstk->data[sstk->length - 1]->data[0])

#define LBPUSH() list_push(lbl, table_new())
#define LBPOP() list_pop(lbl)

size_t insert_debug(node_t *node) {
  size_t line;
  (void)traverse(GETSRC(node->fi), node->pos, &line, NULL);

  buffer_t *tbuf = buffer_new();
  buffer_fmt(tbuf, "File \"%s\", line %d", GETFNAME(node->fi), line);

  if (FUNCNAMES->length)
    buffer_fmt(tbuf, ", in %s", list_index(FUNCNAMES, -1));

  list_push(DEBUGDATA, buffer_read(tbuf));

  return DEBUGDATA->length - 1;
}

void emit_debug(buffer_t *buf, node_t *node) {
  buffer_fmt(buf, "state->_debug_data = __debugData[%d];\n",
             insert_debug(node));
}

void compile_func(buffer_t *gbuf, buffer_t *buf, list_t *ctx, table_t *ltab,
                  list_t *lstk, list_t *sstk, list_t *lbl, node_t *node,
                  char *name) {
  NEWGID();

  char *funname = name ? name : node->t ? node->t->text : "<anon>";

  buffer_t *tbuf = buffer_new();

  buffer_fmt(tbuf,
             "qi_value_t *__%s%d(qi_state_t *state, qi_size_t pargc, qi_list_t "
             "*pargs) {\n",
             PREFIX, gid);

  LBPUSH();
  CTXPUSH("gap");
  CTXPUSH("func");
  list_push(CONSTANTS, table_new());
  list_push(MACROS, table_new());
  list_push(FUNCNAMES, funname);

  if (DEBUG)
    emit_debug(tbuf, node);

  size_t optargc = 0;

  if (node->h) {
    table_iterate(node->h, {
      list_t *pair = entry.value;

      size_t argc = *(size_t *)pair->data[0];

      if (pair->data[1]) {
        optargc++;

        buffer_fmt(
            tbuf,
            "qi_decl(state, \"%s\", pargc >= %d? qi_list_index(pargs, %d): ",
            entry.key, argc + 1, argc);
        compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, pair->data[1]);
        buffer_fmt(tbuf, ");\n");
      } else
        buffer_fmt(tbuf, "qi_decl(state, \"%s\", qi_list_index(pargs, %d));\n",
                   entry.key, argc);

      argc++;
    });
  }

  compile_node(gbuf, tbuf, ctx, table_new(), list_new(), list_new(), lbl,
               node->a);

  list_pop(FUNCNAMES);
  list_pop(MACROS);
  list_pop(CONSTANTS);
  CTXPOP();
  CTXPOP();
  LBPOP();

  buffer_fmt(tbuf, "return state->nil;\n");
  buffer_fmt(tbuf, "}\n");

  buffer_appendb(gbuf, tbuf);

  tbuf = buffer_new();

  buffer_fmt(tbuf, "qi_make_function(state, \"%s\", %d, __%s%d, ", funname,
             !node->h ? 0 : (node->h->used - optargc), PREFIX, gid);
  compile_table(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->h2);
  buffer_fmt(tbuf, ")");

  if (node->tag == N_FUNCEXPR) {
    buffer_appendb(buf, tbuf);

    return;
  }

  EMIT("qi_set(state, false, \"%s\", ", node->t->text);
  buffer_appendb(buf, tbuf);
  EMIT(");");
}

int const_set(char *name, node_t *val) {
  table_t *table = list_index(CONSTANTS, -1);

  if (table_get(table, name))
    return 0;

  table_set(table, name, val);

  return 1;
}

node_t *const_get(char *name) {
  node_t *val = NULL;

  for (ssize_t i = CONSTANTS->length - 1; i >= 0; i--)
    if ((val = table_get(CONSTANTS->data[i], name)))
      break;

  return val;
}

size_t count_scopes(list_t *ctx, size_t offset) {
  if (ctx->length < 2 || offset >= ctx->length)
    return 0;

  size_t k = 0;

  for (ssize_t i = ctx->length - 1; i >= 0 && i > offset; i--)
    if (strcmp(ctx->data[i], "gap") == 0)
      break;
    else if (strcmp(ctx->data[i], "scope") == 0)
      k++;

  return k;
}

size_t scope_index(list_t *ctx) {
  if (ctx->length < 2)
    return 0;

  for (ssize_t i = ctx->length - 1; i >= 0; i--)
    if (strcmp(ctx->data[i], "gap") == 0)
      break;
    else if (strcmp(ctx->data[i], "scope") == 0)
      return i;

  return 0;
}

void compile_block(buffer_t *gbuf, buffer_t *buf, list_t *ctx, table_t *ltab,
                   list_t *lstk, list_t *sstk, list_t *lbl, list_t *block) {
  for (size_t i = 0; i < block->length; i++) {
    node_t *node = block->data[i];

    if (node->tag == N_CONST) {
      table_iterate(node->h, {
        char *name = entry.key;

        if (!const_set(name, entry.value))
          COMPILE_ERROR("redeclaration of compile-time constant: '%s'", name);
      });
    } else if (node->tag == N_ENUM) {
      size_t k = 0;

      table_iterate(node->h, {
        char *name = entry.key;

        node_t *v = entry.value;
        if (!v) {
          char buf[128];
          snprintf(buf, sizeof(buf), "%zu", k++);

          v = nodet(N_LITERAL, token(T_NUMBER, strdup(buf)));
        }

        if (!const_set(name, v))
          COMPILE_ERROR("redeclaration of compile-time constant: '%s'", name);
      });
    } else if (node->tag == N_FUNCDEF) {
      compile_func(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node, NULL);

      EMIT("\n");
    } else if (node->tag == N_CLASS) {
      NEWGID();

      char *name = node->t->text;
      list_t *supers = list_index(node->l, 0);
      list_t *triples = list_index(node->l, 1);

      buffer_t *tbuf = buffer_new();

      buffer_fmt(tbuf, "qi_value_t *__%s%d(qi_state_t *state) {\n", PREFIX,
                 gid);
      buffer_fmt(tbuf, "qi_list_t *supers = qi_list_make_n(%d);\n",
                 !supers ? 0 : supers->length);

      if (supers)
        for (size_t i = 0; i < supers->length; i++) {
          token_t *t = supers->data[i];

          buffer_fmt(tbuf,
                     "qi_list_data(supers, %d) = qi_get(state, \"%s\");\n", i,
                     t->text);
        }

      buffer_fmt(tbuf, "qi_table_t *table = qi_table_make();\n");
      buffer_fmt(tbuf, "qi_table_t *metatable = qi_table_make();\n");
      buffer_fmt(tbuf, "qi_table_t *statictable = qi_table_make();\n");

      for (size_t i = 0; i < triples->length; i++) {
        list_t *triple = triples->data[i];
        token_t *t = triple->data[0];
        int flag = *(int *)triple->data[1];

        if (flag == 0) {
          buffer_fmt(tbuf, "qi_table_set(metatable, \"%s\", ", t->text);

          if (((node_t *)triple->data[2])->tag == N_FUNCEXPR) {
            buffer_t *methodname = buffer_new();
            buffer_fmt(methodname, "%s.%s", name, t->text);

            compile_func(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl,
                         triple->data[2], buffer_read(methodname));
          } else
            compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl,
                         triple->data[2]);
        } else {
          buffer_fmt(tbuf, "qi_table_set(%s, \"%s\", ",
                     flag == 1 ? "table" : "statictable", t->text);

          compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, triple->data[2]);
        }

        buffer_fmt(tbuf, ");\n");
      }

      buffer_fmt(tbuf, "qi_list_t *pargs = qi_list_make_n(5);\n");
      buffer_fmt(tbuf,
                 "qi_list_data(pargs, 0) = qi_make_string(state, \"%s\");\n",
                 name);
      buffer_fmt(tbuf,
                 "qi_list_data(pargs, 1) = qi_make_list(state, supers);\n");
      buffer_fmt(tbuf,
                 "qi_list_data(pargs, 2) = qi_make_table(state, table);\n");
      buffer_fmt(tbuf,
                 "qi_list_data(pargs, 3) = qi_make_table(state, metatable);\n");
      buffer_fmt(
          tbuf,
          "qi_list_data(pargs, 4) = qi_make_table(state, statictable);\n");

      buffer_fmt(tbuf, "return qi_call(state, qi_get(state, "
                       "\"__class_wrapper\"), pargs);\n");
      buffer_fmt(tbuf, "}\n");

      buffer_appendb(gbuf, tbuf);

      EMIT("qi_set(state, false, \"%s\", __%s%d(state));", name, PREFIX, gid);
    } else if (node->tag == N_LABEL) {
      char *label = node->t->text;

      if (table_get(list_index(lbl, -1), label))
        COMPILE_ERROR("duplicated label: '%s'", label);

      NEWGID();

      int_stack_t *pair = stack_new();
      stack_push(pair, gid);
      stack_push(pair, scope_index(ctx));

      table_set(list_index(lbl, -1), label, pair);
    }
  }

  for (size_t i = 0; i < block->length; i++) {
    node_t *n = block->data[i];
    if (n->tag == N_CONST || n->tag == N_ENUM || n->tag == N_FUNCDEF || n->tag == N_CLASS ||
        n->tag == N_PASS)
      continue;

    if (DEBUG)
      emit_debug(buf, n);

    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, n);

    EMIT("\n");
  }
}

const char *STD[][2] = {
    {"json",
     "require \"string\"\n"
     "class JSONError(Error)\n"
     "func json_tokenize(s) {\n"
     "  let toks = []\n"
     "  for var i = 0; i < len(s); i++ {\n"
     "    if isws(s[i])\n"
     "      continue\n"
     "    if s[i] in \"[]{}:,\"\n"
     "      toks.push((s[i], nil))\n"
     "    elif isalpha(s[i]) {\n"
     "      var text = \"\"\n"
     "      for i < len(s) && isalpha(s[i])\n"
     "        text += s[i++]\n"
     "      i--\n"
     "      toks.push((\"name\", text))\n"
     "    } elif s[i] == '-' || isdigit(s[i]) {\n"
     "      var text = \"\"\n"
     "      if s[i] == '-'\n"
     "        text += s[i++]\n"
     "      if i >= len(s) || !isdigit(s[i])\n"
     "        throw JSONError(f\"${i}: malformed number literal\")\n"
     "      for i < len(s) && isdigit(s[i]) {\n"
     "        text += s[i++]\n"
     "        if i < len(s) && s[i] == \".\" && \".\" !in text\n"
     "          text += s[i++]\n"
     "      }\n"
     "      i--\n"
     "      toks.push((\"number\", text))\n"
     "    } elif s[i] == '\"' {\n"
     "      var text = \"\"\n"
     "      i++\n"
     "      for i < len(s) && s[i] != '\"' {\n"
     "        var c = s[i++]\n"
     "        if c == `\\` {\n"
     "          if i >= len(s)\n"
     "            throw JSONError(f\"#${i}: unterminated string literal\")\n"
     "          switch s[i] {\n"
     "            case \"n\":\n"
     "              c = \"\\n\"\n"
     "              break\n"
     "            case \"r\":\n"
     "              c = \"\\r\"\n"
     "              break\n"
     "            case \"t\":\n"
     "              c = \"\\t\"\n"
     "              break\n"
     "          }\n"
     "          i++\n"
     "        }\n"
     "        text += c\n"
     "      }\n"
     "      if i >= len(s) || s[i] != '\"'\n"
     "        throw JSONError(f\"#${i}: unterminated string literal\")\n"
     "      toks.push((\"string\", text))\n"
     "    } else\n"
     "      throw JSONError(f\"#${i}: unknown input\")\n"
     "  }\n"
     "  return toks\n"
     "}\n"
     "func json_parse(toks) {\n"
     "  func parse_array(toks) {\n"
     "    let r = []\n"
     "    if toks && toks[0][0] == ']'\n"
     "      return r, toks[1:]\n"
     "    for {\n"
     "      var e\n"
     "      [e, toks] = parse_expression(toks)\n"
     "      r.push(e)\n"
     "      if !toks || toks[0][0] != ','\n"
     "        break\n"
     "      if toks[0][0] == \",\"\n"
     "        toks = toks[1:]\n"
     "    }\n"
     "    if !toks || toks[0][0] != ']'\n"
     "      throw JSONError(\"missing ]\")\n"
     "    return r, toks[1:]\n"
     "  }\n"
     "  func parse_object(toks) {\n"
     "    let r = {}\n"
     "    for {\n"
     "      var k, e\n"
     "      if !toks || toks[0][0] != \"string\"\n"
     "        throw JSONError(\"expected string\")\n"
     "      k = toks[0][1]\n"
     "      toks = toks[1:]\n"
     "      if !toks || toks[0][0] != \":\"\n"
     "        throw JSONError(\"expected :\")\n"
     "      toks = toks[1:]\n"
     "      [e, toks] = parse_expression(toks)\n"
     "      r[k] = e\n"
     "      if !toks || toks[0][0] != \",\"\n"
     "        break\n"
     "      if toks[0][0] == \",\"\n"
     "        toks = toks[1:]\n"
     "    }\n"
     "    if !toks || toks[0][0] != \"}\"\n"
     "      throw JSONError(\"missing }\")\n"
     "    return r, toks[1:]\n"
     "  }\n"
     "  func parse_expression(toks) {\n"
     "    if toks\n"
     "      switch toks[0][0] {\n"
     "        case \"{\":\n"
     "          return parse_object(toks[1:])\n"
     "        case \"[\":\n"
     "          return parse_array(toks[1:])\n"
     "        case \"name\":\n"
     "          switch toks[0][1] {\n"
     "            case \"true\":\n"
     "              return true, toks[1:]\n"
     "            case \"false\":\n"
     "              return false, toks[1:]\n"
     "            case \"null\":\n"
     "              return nil, toks[1:]\n"
     "          }\n"
     "          throw JSONError(f\"illegal name: ${toks[0][1]}\")\n"
     "        case \"number\":\n"
     "          return num(toks[0][1]), toks[1:]\n"
     "        case \"string\":\n"
     "          return toks[0][1], toks[1:]\n"
     "      }\n"
     "    throw JSONError(\"expected expression\")\n"
     "  }\n"
     "  if !toks\n"
     "    throw JSONError(\"empty document\")\n"
     "  if toks[0][0] !in \"{[\"\n"
     "    throw JSONError(\"expected { or [\")\n"
     "  let [r, unconsumed] = parse_expression(toks)\n"
     "  if unconsumed\n"
     "    throw JSONError(\"unconsumed input\")\n"
     "  return r\n"
     "}\n"
     "func json_read(s)\n"
     "  return json_parse(json_tokenize(s))\n"
     "func json_dump(d) {\n"
     "  func escape(s) {\n"
     "    var r = \"\"\n"
     "    \n"
     "    for var c of s {\n"
     "      if c == `\\`\n"
     "        r += `\\\\`\n"
     "      elif c == '\"'\n"
     "        r += `\\\"`\n"
     "      elif c == \"\\n\"\n"
     "        r += `\\n`\n"
     "      elif c == \"\\r\"\n"
     "        r += `\\r`\n"
     "      elif c == \"\\t\"\n"
     "        r += `\\t`\n"
     "      else r += c\n"
     "    }\n"
     "    return r\n"
     "  }\n"
     "  switch type(d) {\n"
     "    case \"nil\":\n"
     "      return \"null\"\n"
     "    case \"bool\":\n"
     "      return d? \"true\": \"false\"\n"
     "    case \"number\":\n"
     "      return str(d)\n"
     "    case \"string\":\n"
     "      return \"\\\"\" + escape(d) + \"\\\"\"\n"
     "    case \"list\":\n"
     "      var f = true\n"
     "      var buf = \"[\"\n"
     "      for var el of d {\n"
     "        if f\n"
     "          f = false\n"
     "        else\n"
     "          buf += \", \"\n"
     "        buf += json_dump(el)   \n"
     "      }\n"
     "      buf += \"]\"\n"
     "      return buf\n"
     "    case \"table\":\n"
     "      var f = true\n"
     "      var buf = \"{\"\n"
     "      for var [k, v] of enumerate(d) {\n"
     "        if f\n"
     "          f = false\n"
     "        else\n"
     "          buf += \", \"\n"
     "        buf += f`\"${escape(k)}\": ${json_dump(v)}`\n"
     "      }\n"
     "      buf += \"}\"\n"
     "      return buf\n"
     "  }\n"
     "  throw JSONError(f\"cannot serialize ${type(d)} into a JSON\")\n"
     "}\n"},

    {"utf8", "func utf8_chrlen(s) {\n"
             "  s = bytes(s)\n"
             "  var z = len(s)\n"
             "  if z < 2\n"
             "    return z\n"
             "  var l = 1\n"
             "  for var i = 1; i < z && (s[i] & 0xc0) == 0x80; i++\n"
             "    l++\n"
             "  return l\n"
             "}\n"
             "func utf8_decode(s) {\n"
             "  s = bytes(s)\n"
             "  var l = utf8_chrlen(s)\n"
             "  if !l\n"
             "    throw \"malformed sequence\"\n"
             "  var c = (s[0] & ((1 << (8 - l)) - 1)) << (l - 1) * 6\n"
             "  for var i = 1; i < l; i++\n"
             "    c |= (s[i] & 0x3f) << (l - i - 1) * 6\n"
             "  return (c, l)\n"
             "}\n"
             "func utf8_encode(c) {\n"
             "  if c <= 0x7f\n"
             "    return bytes([c & 0xFF])\n"
             "  elif c >= 0x80 && c <= 0x7ff\n"
             "    return bytes([0xC0 | ((c >> 6) & 0x1f), 0x80 | (c & 0x3f)])\n"
             "  elif c >= 0x800 && c <= 0xfff\n"
             "    return bytes([0xe0 | ((c >> 12) & 0xf), 0x80 | ((c >> 6) & "
             "0x3f), 0x80 | (c & 0x3f)])\n"
             "  elif c >= 0x10000 && c <= 0x10ffff\n"
             "    return bytes([0xf0 | ((c >> 18) & 0x7), 0x80 | ((c >> 12) & "
             "0x3f), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f)])\n"
             "  throw \"malformed codepoint\"\n"
             "}\n"
             "class ustr {\n"
             "  _ucs = nil\n"
             "  constructor (this, s=\"\") {\n"
             "    if type(s) == \"list\" && all(map(func (x): type(x) == "
             "\"number\", s)) {\n"
             "      this._ucs = s\n"
             "      return\n"
             "    }\n"
             "    s = str(s)\n"
             "    this._ucs = []\n"
             "    for var i = 0; i < len(s) {\n"
             "      let [c, l] = utf8_decode(slice(s, i))\n"
             "      this._ucs.push(c)\n"
             "      i += l\n"
             "    }\n"
             "  }\n"
             "  nth (this, i): this._ucs[i]\n"
             "  __type (this): \"ustr\"\n"
             "  __str (this) {\n"
             "    var s = \"\"\n"
             "    for var uc of this._ucs\n"
             "      s += str(utf8_encode(uc))\n"
             "    return s\n"
             "  }\n"
             "  __len (this): len(this._ucs)\n"
             "  __index (this, i): ustr([this._ucs[i]])\n"
             "  __index_set (this): throw\n"
             "  __iter (this): this._ucs\n"
             "  __list (this): list_copy(this._ucs)\n"
             "  __add (this, other) {\n"
             "    if type(other) != \"ustr\"\n"
             "      throw\n"
             "    return ustr(this._ucs + other._ucs)\n"
             "  }\n"
             "  __equals (this, other) {\n"
             "    if type(other) != \"ustr\"\n"
             "      return false\n"
             "    return this._ucs == other._ucs\n"
             "  }\n"
             "}\n"},

    {"thread",
     "include `pthread.h`\n"
     "func thread_create(fn, args=[]) {\n"
     "  if type(fn) != \"function\"\n"
     "    throw \"expected first argument to be: function, but got: \" + "
     "type(fn)\n"
     "  if type(args) != \"list\"\n"
     "    throw \"expected second argument to be: list, but got: \" + "
     "type(args)\n"
     "  inline `qi_value_t *args = qi_get(state, \"args\")`\n"
     "  inline `qi_list_t *list`\n"
     "  inline `LOCKED(args, {list = qi_list_copy(args->value.list);})`\n"
     "  inline `void *td = qi_thread_create(state, qi_get(state, \"fn\"), "
     "list)`\n"
     "  inline `qi_decl(state, \"td\", qi_make_data(state, 'T', td))`\n"
     "  return Object({\n"
     "    __str: func (this): \"<Thread>\",\n"
     "    _td: td,\n"
     "    joined: false,\n"
     "    join: func (this) {\n"
     "      if this.joined\n"
     "        return\n"
     "      var td = this._td\n"
     "      inline `qi_value_t *ret = qi_thread_join(state, qi_get_data(state, "
     "'T', qi_get(state, \"td\")))`\n"
     "      this.joined = true\n"
     "      inline `return ret`\n"
     "    }\n"
     "  })\n"
     "}\n"
     "func Thread(fn, args=[]): Object({\n"
     "  __str: func (this) use (fn, args): format(\"<Thread _ _>\", fn, "
     "args),\n"
     "  _thread: nil,\n"
     "  start: func (this) use (fn, args) {\n"
     "    if this._thread !is nil\n"
     "      return\n"
     "    this._thread = thread_create(fn, args)\n"
     "    return this\n"
     "  },\n"
     "  join: func (this) {\n"
     "    if this._thread !is nil\n"
     "      return this._thread.join()\n"
     "  },\n"
     "  is_joined: func (this): this._thread.joined\n"
     "})\n"
     "func Mutex() {\n"
     "  inline `void *mutex = qi_mutex_create()`\n"
     "  inline `if (!mutex) qi_throw_format(state, \"mutex init failed\")`\n"
     "  inline `qi_decl(state, \"mutex\", qi_make_data(state, 'M', mutex))`\n"
     "  return Object({\n"
     "    __fin: func (this) {\n"
     "      mutex = this._mutex\n"
     "      this._mutex = nil\n"
     "      inline `qi_mutex_destroy(qi_get_data(state, 'M', qi_get(state, "
     "\"mutex\")))`\n"
     "    },\n"
     "    __str: func (this): \"<Mutex>\",\n"
     "    _mutex: mutex,\n"
     "    lock: func (this) {\n"
     "      var mutex = this._mutex\n"
     "      inline `qi_mutex_lock(qi_get_data(state, 'M', qi_get(state, "
     "\"mutex\")))`\n"
     "    },\n"
     "    trylock: func (this) {\n"
     "      var mutex = this._mutex\n"
     "      inline `return qi_make_boolean(state, "
     "qi_mutex_trylock(qi_get_data(state, 'M', qi_get(state, \"mutex\"))))`\n"
     "    },\n"
     "    unlock: func (this) {\n"
     "      var mutex = this._mutex\n"
     "      inline `qi_mutex_unlock(qi_get_data(state, 'M', qi_get(state, "
     "\"mutex\")))`\n"
     "    }\n"
     "  })\n"
     "}\n"
     "func Cond() {\n"
     "  inline `void *cond = qi_cond_create()`\n"
     "  inline `if (!cond) qi_throw_format(state, \"cond init failed\")`\n"
     "  inline `qi_decl(state, \"cond\", qi_make_data(state, 'C', cond))`\n"
     "  return Object({\n"
     "    __fin: func (this) {\n"
     "      cond = this._cond\n"
     "      this._cond = nil\n"
     "      inline `qi_cond_destroy(qi_get_data(state, 'C', qi_get(state, "
     "\"cond\")))`\n"
     "    },\n"
     "    __str: func (this): \"<Cond>\",\n"
     "    _cond: cond,\n"
     "    wait: func (this, mutex) {\n"
     "      var cond = this._cond\n"
     "      mutex = mutex._mutex\n"
     "      inline `qi_cond_wait(qi_get_data(state, 'C', qi_get(state, "
     "\"cond\")), qi_get_data(state, 'M', qi_get(state, \"mutex\")))`\n"
     "    },\n"
     "    signal: func (this) {\n"
     "      var cond = this._cond\n"
     "      inline `qi_cond_signal(qi_get_data(state, 'C', qi_get(state, "
     "\"cond\")))`\n"
     "    },\n"
     "    broadcast: func (this) {\n"
     "      var cond = this._cond\n"
     "      inline `qi_cond_broadcast(qi_get_data(state, 'C', qi_get(state, "
     "\"cond\")))`\n"
     "    }\n"
     "  })\n"
     "}\n"
     "func thread_exit(ret=nil)\n"
     "  inline `qi_thread_exit(state, qi_get(state, \"ret\"))`\n"
     "func is_main_thread()\n"
     "  inline `return qi_make_boolean(state, qi_thread_main())`\n"},

    {"os",
     "header `#ifdef _WIN32`\n"
     "include `Windows.h`\n"
     "header `#endif`\n"
     "func system(s) {\n"
     "  if type(s) != \"string\"\n"
     "    throw \"expected first argument to be: string, but got: \" + "
     "type(s)\n"
     "  inline `return qi_make_number(state, system(qi_get(state, "
     "\"s\")->value.string))`"
     "}\n"
     "func getenv(n) {\n"
     "  if type(n) != \"string\"\n"
     "    throw \"expected first argument to be: string, but got: \" + "
     "type(n)\n"
     "  inline `char *value = getenv(qi_get(state, \"n\")->value.string)`\n"
     "  inline `return value? qi_make_string_copy(state, value): state->nil`\n"
     "}\n"
     "func setenv(n, v) {\n"
     "  if type(n) != \"string\"\n"
     "    throw \"expected first argument to be: string, but got: \" + "
     "type(n)\n"
     "  v = str(v)\n"
     "  inline \"#ifdef _WIN32\"\n"
     "  var s = n + \"=\" + v\n"
     "  inline `_putenv(qi_get(state, \"s\")->value.string)`\n"
     "  inline \"#else\"\n"
     "  inline `setenv(qi_get(state, \"n\")->value.string, qi_get(state, "
     "\"v\")->value.string, 1)`\n"
     "  inline \"#endif\"\n"
     "}\n"
     "func exit(c) {\n"
     "  if type(c) != \"number\"\n"
     "   throw \"expected first argument to be: number, but got: \" + type(c)\n"
     "  inline `qi_exit(state, qi_get(state, \"c\")->value.number)`\n"
     "}\n"
     "func die(msg, c=1) {\n"
     "  fputs(STDERR, str(msg) + \"\\n\")\n"
     "  exit(c)\n"
     "}\n"},

    {"string", "let STR_LETTERS = "
               "\"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n"
               "let STR_ASCII_LC = \"abcdefghijklmnopqrstuvwxyz\"\n"
               "let STR_ASCII_UC = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n"
               "let STR_DIGITS = \"0123456789\"\n"
               "let STR_WS = \" \\t\\n\\r\\x0b\\x0c\"\n"
               "let STR_PUNCTS = \"!\\\"#$%&'()*+,-./:;<=>?@[\\\\]^_`{|}~\"\n"
               "func is_char(c): return type(c) == \"string\" && len(c) == 1\n"
               "func isalpha(c): return (c >= 'a' && c <= 'z') || (c >= 'A' && "
               "c <= 'Z')\n"
               "func isdigit(c): return c >= '0' && c <= '9'\n"
               "func ispunct(c): return c in STR_PUNCTS\n"
               "func isws(c): return c in STR_WS\n"},

    {"time",
     "include `time.h`\n"
     "include `errno.h`\n"
     "header `#ifdef _WIN32`\n"
     "include `Windows.h`\n"
     "header `#endif`\n"
     "func time() {\n"
     "  inline `unsigned long long ts = time(NULL)`\n"
     "  inline `return qi_make_number(state, ts)`\n"
     "}\n"
     "func strftime(f, t=time()) {\n"
     "  if type(f) != \"string\"\n"
     "    throw \"expected first argument to be: string, but got: \" + "
     "type(f)\n"
     "  if type(t) != \"number\"\n"
     "    throw \"expected second argument to be: number, but got: \" + "
     "type(t)\n"
     "  inline `time_t ts = qi_get(state, \"t\")->value.number`\n"
     "  inline `struct tm lt`\n"
     "  inline `lt = *localtime(&ts)`\n"
     "  inline `char buffer[512]`\n"
     "  inline `strftime(buffer, sizeof(buffer), qi_get(state, "
     "\"f\")->value.string, &lt)`\n"
     "  inline `return qi_make_string_copy(state, buffer)`\n"
     "}\n"
     "func usleep(t) {\n"
     "  if type(t) != \"number\"\n"
     "    throw \"expected first argument to be: number, but got: \" + "
     "type(t)\n"
     "    \n"
     "  inline `#ifdef _WIN32`\n"
     "  inline `Sleep((unsigned long)(qi_get(state, \"t\")->value.number))`\n"
     "  inline `#else`\n"
     "  inline `unsigned long ms = (unsigned long)(qi_get(state, "
     "\"t\")->value.number)`\n"
     "  inline `struct timespec ts`\n"
     "  inline `ts.tv_sec = ms / 1000`\n"
     "  inline `ts.tv_nsec = (ms % 1000) * 1000000`\n"
     "  inline `struct timespec r`\n"
     "  inline `while (nanosleep(&ts, &r) < 0) if (errno == EINTR) ts = r; "
     "else break`\n"
     "  inline `#endif`\n"
     "}\n"
     "func sleep(t)\n"
     "  usleep(t * 1000)\n"},

    {"random",
     "func rand() {\n"
     "  inline `return qi_make_number(state, rand())`\n"
     "}\n"
     "func random_int(min, max): return rand() % (max + 1 - min) + min\n"
     "func random_choice(l, k=1) {\n"
     "  if k < 0 || k > len(l)\n"
     "    throw \"sample larger than population or is negative\"\n"
     "  l = list_copy(list(l))\n"
     "  var r = []\n"
     "  for var i = 0; i < k; i++\n"
     "    list_push(r, list_pop_at(l, random_int(0, len(l)-1)))\n"
     "  return r\n"
     "}\n"
     "func random_pick(l, k=1) {\n"
     "  var r = []\n"
     "  for var i = 0; i < k; i++\n"
     "    list_push(r, l[random_int(0, len(l)-1)])\n"
     " return r\n"
     "}\n"
     "inline `srand(time(NULL))`\n"},

    {"math", NULL},

    {NULL, NULL}};

const struct {
  const char *name;
  const char *fname;
  int arity;
} MATHFUNCS[] = {{"ceil", NULL, 1},  {"floor", NULL, 1}, {"trunc", NULL, 1},
                 {"round", NULL, 1}, {"abs", "fabs", 1}, {"exp", NULL, 1},
                 {"sqrt", NULL, 1},  {"sinh", NULL, 1},  {"cosh", NULL, 1},
                 {"tanh", NULL, 1},  {"asinh", NULL, 1}, {"acosh", NULL, 1},
                 {"atanh", NULL, 1}, {"sin", NULL, 1},   {"cos", NULL, 1},
                 {"tan", NULL, 1},   {"asin", NULL, 1},  {"acos", NULL, 1},
                 {"atan", NULL, 1},  {"atan2", NULL, 2}, {"hypot", NULL, 2},

                 {NULL, 0}};

void genmathlib(void) {
  buffer_t *buffer = buffer_new();

  buffer_appends(
      buffer,
      "let Math = {\"tau\": 6.283185307179586, \"pi\": 3.141592653589793, "
      "\"e\": 2.718281828459045, \"inf\": INFINITY, \"nan\": NAN, ");

  for (size_t i = 0; MATHFUNCS[i].name; i++) {
    if (MATHFUNCS[i].arity == 0)
      buffer_fmt(
          buffer,
          "\"%s\": func () { inline `return qi_make_number(state, %s())` }",
          MATHFUNCS[i].name,
          MATHFUNCS[i].fname ? MATHFUNCS[i].fname : MATHFUNCS[i].name);
    else if (MATHFUNCS[i].arity == 1)
      buffer_fmt(
          buffer,
          "\"%s\": func (x) { if type(x) != \"number\" { throw \"expected "
          "first argument to be: number, but got: \" + type(x) } inline "
          "`double n = %s(qi_get(state, \"x\")->value.number)`; inline `return "
          "qi_make_number(state, n)` }",
          MATHFUNCS[i].name,
          MATHFUNCS[i].fname ? MATHFUNCS[i].fname : MATHFUNCS[i].name);
    else
      buffer_fmt(
          buffer,
          "\"%s\": func (x, y) { if type(x) != \"number\" { throw \"expected "
          "first argument to be: number, but got: \" + type(x) } if type(y) != "
          "\"number\" { throw \"expected second argument to be: number, but "
          "got: \" + type(y) } inline `double n = %s(qi_get(state, "
          "\"x\")->value.number, qi_get(state, \"y\")->value.number)`; inline "
          "`return qi_make_number(state, n)` }",
          MATHFUNCS[i].name,
          MATHFUNCS[i].fname ? MATHFUNCS[i].fname : MATHFUNCS[i].name);

    if (MATHFUNCS[i + 1].name)
      buffer_append(buffer, ',');
  }

  buffer_append(buffer, '}');

  size_t i;
  for (i = 0; strcmp(STD[i][0], "math") != 0; i++)
    ;

  STD[i][1] = buffer_read(buffer);
}

char *unescape(char *s) {
  buffer_t *buf = buffer_new();

  for (size_t i = 0; i < strlen(s); i++) {
    char c = s[i];

    if (c == '\\') {
      char nc = s[i + 1];
      if (!nc)
        continue;

      switch (nc) {
      case 'n':
        buffer_append(buf, '\n');
        break;

      case 't':
        buffer_append(buf, '\t');
        break;

      case 'r':
        buffer_append(buf, '\r');
        break;

      default:
        buffer_append(buf, nc);
        break;
      }

      i++;
    } else
      buffer_append(buf, c);
  }

  return buffer_read(buf);
}

void compile_into(char *source, buffer_t *gbuf, buffer_t *buf, list_t *ctx,
                  table_t *ltab, list_t *lstk, list_t *sstk, list_t *lbl);

int require_once(buffer_t *gbuf, buffer_t *buf, list_t *ctx, table_t *ltab,
                 list_t *lstk, list_t *sstk, list_t *lbl, char *path) {
  char *source = NULL;

  if (is_required(path))
    return 1;

  for (size_t i = 0; STD[i][0]; i++) {
    if (strcmp(path, STD[i][0]) == 0) {
      source = (char *)STD[i][1];

      break;
    }
  }

  if (!source) {
    FILE *fd = fopen(path, "rb");
    if (!fd) {
      char *qipath = getenv("QIPATH");
      if (!qipath)
        return -1;

      char *n = strtok(qipath, ":");

      while (n) {
        char tmp[512];
        snprintf(tmp, sizeof(tmp), "%s/%s", n, path);

        fd = fopen(tmp, "rb");
        if (fd) {
          path = strdup(tmp);
          break;
        }
      }

      if (!fd)
        return -1;
    }

    buffer_t *fbuf = buffer_new();

    for (;;) {
      char line[512];

      if (!fgets(line, sizeof(line), fd))
        break;

      buffer_appends(fbuf, line);
    }

    source = buffer_read(fbuf);
    path = realpath(path, NULL);
  }

  list_t *pair = list_new();
  list_push(pair, path);
  list_push(pair, source);

  list_push(FILES, pair);

  compile_into(source, gbuf, buf, ctx, ltab, lstk, sstk, lbl);

  list_pop(FILES);
  list_push(REQUIRED, path);

  return 0;
}

buffer_t *HBUF;
list_t *MVARS;
node_t *YES;

#define IS_EXPR(n)                                                             \
  ((n) && ((node_t *)(n))->tag > N_EXPRS_BEGIN &&                              \
   ((node_t *)(n))->tag < N_EXPRS_END)
#define IS_NUMBER(n) ((n) && (n)->tag == N_LITERAL && (n)->t->tag == T_NUMBER)
#define TO_DOUBLE(n) (strtod((n)->t->text, NULL))
#define IS_STRING(n) ((n) && (n)->tag == N_LITERAL && (n)->t->tag == T_STRING)

node_t *make_number(double v) {
  char buf[64];
  snprintf(buf, sizeof(buf), "%g", v);

  return nodet(N_LITERAL, token(T_NUMBER, strdup(buf)));
}

node_t *mexpr_negate(node_t *a) {
  if (!IS_NUMBER(a))
    return NULL;

  return make_number(-TO_DOUBLE(a));
}

node_t *mexpr_add(node_t *a, node_t *b) {
  if (!IS_NUMBER(a))
    return NULL;

  if (!IS_NUMBER(b))
    return NULL;

  return make_number(TO_DOUBLE(a) + TO_DOUBLE(b));
}

node_t *mexpr_sub(node_t *a, node_t *b) {
  if (!IS_NUMBER(a))
    return NULL;

  if (!IS_NUMBER(b))
    return NULL;

  return make_number(TO_DOUBLE(a) - TO_DOUBLE(b));
}

node_t *mexpr_mul(node_t *a, node_t *b) {
  if (!IS_NUMBER(a))
    return NULL;

  if (!IS_NUMBER(b))
    return NULL;

  return make_number(TO_DOUBLE(a) * TO_DOUBLE(b));
}

node_t *mexpr_div(node_t *a, node_t *b) {
  if (!IS_NUMBER(a))
    return NULL;

  if (!IS_NUMBER(b))
    return NULL;

  double x = TO_DOUBLE(b);
  if (x == 0)
    return make_number(0);

  return make_number(TO_DOUBLE(a) * x);
}

int mexpr_equals(node_t *a, node_t *b) {
  if (!a && !b)
    return 1;
  if (!a && b)
    return 0;
  if (a && !b)
    return 0;

  if (a->tag != b->tag)
    return 0;

  switch (a->tag) {
  case N_LITERAL:
    return a->t->tag == b->t->tag && strcmp(a->t->text, b->t->text) == 0;

  default:
    break;
  }

  return 0;
}

int mexpr_less(node_t *a, node_t *b) {
  if (!IS_NUMBER(a))
    return 0;

  if (!IS_NUMBER(b))
    return 0;

  return TO_DOUBLE(a) < TO_DOUBLE(b);
}

int mexpr_greater(node_t *a, node_t *b) {
  if (!IS_NUMBER(a))
    return 0;

  if (!IS_NUMBER(b))
    return 0;

  return TO_DOUBLE(a) > TO_DOUBLE(b);
}

node_t *mexpr_eval(node_t *n) {
  if (n)
    switch (n->tag) {
    case N_LITERAL:
      if (n->t->tag == T_NAME) {
        node_t *v = const_get(n->t->text);
        if (v)
          return mexpr_eval(v);
      }
      break;

    case N_UNARY_PLUS:
      return mexpr_eval(n->a);
      break;
    case N_NEGATE: {
      node_t *a = mexpr_eval(n->a);

      return mexpr_negate(a);
    }

    case N_ADD: {
      node_t *a = mexpr_eval(n->a);
      node_t *b = mexpr_eval(n->b);

      if (!IS_NUMBER(a) && IS_NUMBER(b))
        return node2(N_ADD, n->a, b);

      if (IS_NUMBER(a) && !IS_NUMBER(b))
        return node2(N_ADD, a, n->b);

      return mexpr_add(a, b);
    }

    case N_SUB: {
      node_t *a = mexpr_eval(n->a);
      node_t *b = mexpr_eval(n->b);

      if (!IS_NUMBER(a) && IS_NUMBER(b))
        return node2(N_SUB, n->a, b);

      if (IS_NUMBER(a) && !IS_NUMBER(b))
        return node2(N_SUB, a, n->b);

      return mexpr_sub(a, b);
    }

    case N_MUL: {
      node_t *a = mexpr_eval(n->a);
      node_t *b = mexpr_eval(n->b);

      if (!IS_NUMBER(a) && IS_NUMBER(b))
        return node2(N_MUL, n->a, b);

      if (IS_NUMBER(a) && !IS_NUMBER(b))
        return node2(N_MUL, a, n->b);

      return mexpr_mul(a, b);
    }

    case N_DIV: {
      node_t *a = mexpr_eval(n->a);
      node_t *b = mexpr_eval(n->b);

      if (!IS_NUMBER(a) && IS_NUMBER(b))
        return node2(N_DIV, n->a, b);

      if (IS_NUMBER(a) && !IS_NUMBER(b))
        return node2(N_DIV, a, n->b);

      return mexpr_div(a, b);
    }

    case N_IFEXPR: {
      node_t *a = mexpr_eval(n->a);

      if (a)
        return mexpr_eval(n->b);

      return mexpr_eval(n->c);
    }

    case N_TUPLE:
    case N_LIST: {
      list_t *l = list_new();

      for (size_t i = 0; i < n->l->length; i++) {
        node_t *a = mexpr_eval(n->l->data[i]);

        if (!IS_EXPR(a))
          return NULL;

        list_push(l, a);
      }

      return nodel(n->tag, l);
    }

    case N_COMMA:
      return mexpr_eval(list_index(n->l, -1));

    default:
      break;
    }

  return n;
}

node_t *mf_isExpr(list_t *t) {
  if (t->length != 1)
    return NULL;

  return IS_EXPR(t->data[0]) ? YES : NULL;
}

node_t *mf_isList(list_t *t) {
  if (t->length != 1)
    return NULL;

  node_t *a = t->data[0];
  if (!a)
    return NULL;

  return a->tag == N_LIST ? YES : NULL;
}

node_t *mf_newList(list_t *t) {
  for (size_t i = 0; i < t->length; i++)
    if (!IS_EXPR(t->data[i]))
      return NULL;

  return nodel(N_LIST, t);
}

node_t *mf_newBlock(list_t *t) {
  for (size_t i = 0; i < t->length; i++)
    if (!t->data[i])
      return NULL;
    else if (IS_EXPR(t->data[i]))
      t->data[i] = node1(N_EXPRSTMT, t->data[i]);

  return nodel(N_PROGRAM, t);
}

node_t *mf_newName(list_t *t) {
  if (t->length != 1)
    return NULL;

  node_t *a = t->data[0];
  if (!IS_STRING(a))
    return NULL;

  char *text = a->t->text;
  if (*text != '_' && !isalpha(*text))
    return NULL;

  for (size_t i = 0; i < strlen(text); i++)
    if (text[i] != '_' && !isdigit(text[i]) && !isalpha(text[i]))
      return NULL;

  return nodet(N_LITERAL, token(T_NAME, text));
}

node_t *mf_newVar(list_t *t) {
  if (t->length != 1 && t->length != 2)
    return NULL;

  node_t *a = t->data[0];
  if (!a || a->tag != N_LITERAL || a->t->tag != T_NAME)
    return NULL;

  node_t *b = NULL;
  if (t->length == 2) {
    b = t->data[1];

    if (!IS_EXPR(b))
      return NULL;
  }

  table_t *h = table_new();
  table_set(h, a->t->text, b);

  return nodeh(N_VAR, h);
}

node_t *mf_len(list_t *t) {
  if (t->length != 1)
    return NULL;

  node_t *a = t->data[0];
  if (!a)
    return NULL;

  if (a->tag == N_LIST || a->tag == N_TUPLE)
    return make_number(a->l->length);

  return NULL;
}

node_t *mf_nth(list_t *t) {
  if (t->length != 2)
    return NULL;

  node_t *a = t->data[0];
  if (!a)
    return NULL;

  node_t *b = t->data[1];
  if (!IS_NUMBER(b))
    return NULL;

  if (a->tag == N_LIST || a->tag == N_TUPLE)
    return list_index(a->l, TO_DOUBLE(b));

  return NULL;
}

node_t *mf_E(list_t *t) {
  if (t->length != 1)
    return NULL;

  node_t *a = t->data[0];

  return mexpr_eval(a);
}

node_t *mf_C(list_t *t) {
  if (t->length != 1)
    return NULL;

  node_t *a = t->data[0];
  if (!IS_STRING(a))
    return NULL;

  return const_get(a->t->text);
}

struct {
  char *name;
  node_t *(*handler)(list_t *);
} METAFUNCS[] = {{"isExpr", mf_isExpr},
                 {"isList", mf_isList},

                 {"newName", mf_newName},
                 {"newList", mf_newList},
                 {"newBlock", mf_newBlock},
                 {"newVar", mf_newVar},

                 {"len", mf_len},
                 {"nth", mf_nth},

                 {"E", mf_E},
                 {"C", mf_C},

                 {NULL, NULL}};

macro_t *find_macro(char *name, size_t argc, int *res) {
  list_t *ms = macros_get(name);

  if (!ms) {
    if (res)
      *res = 1;

    return NULL;
  }

  macro_t *m = NULL;
  for (size_t i = 0; i < ms->length; i++) {
    macro_t *t = ms->data[i];

    if (t->variable || t->params->length == argc) {
      m = t;

      break;
    }
  }

  if (!m) {
    if (res)
      *res = 2;

    return NULL;
  }

  if (res)
    *res = 0;

  return m;
}

typedef struct {
  node_t *mvar;
  int code;
} mvar_expand_err_t;

node_t *_expand_mvars(node_t *node, int expr, mvar_expand_err_t *err);
node_t *run_macro(macro_t *macro, list_t *args);

node_t *run_mexpr(node_t *node) {
  switch (node->tag) {
  case N_LITERAL:
    switch (node->t->tag) {
    case T_NAME:
      return table_get(list_index(MVARS, -1), node->t->text);

    case T_NUMBER:
    case T_STRING:
      return node;

    default:
      COMPILE_ERROR("not yet implemented");
    }
    break;

  case N_MSTMT: {
    mvar_expand_err_t err = {NULL, 0};
    node_t *n = _expand_mvars(node->a, 1, &err);

    if (!n || err.code != 0)
      return NULL;

    return n;
  } break;

  case N_CALL:
  case N_MACRO_CALL: {
    list_t *args = list_new();

    for (size_t i = 0; i < node->l->length; i++)
      list_push(args, run_mexpr(node->l->data[i]));

    if (node->tag == N_MACRO_CALL) {
      macro_t *m = find_macro(node->t->text, args->length, NULL);
      if (!m)
        return NULL;

      return run_macro(m, args);
    }

    for (size_t i = 0; METAFUNCS[i].name; i++)
      if (strcmp(METAFUNCS[i].name, node->t->text) == 0)
        return METAFUNCS[i].handler(args);
  } break;

  case N_LOGOR:
    if (run_mexpr(node->a) || run_mexpr(node->b))
      return YES;

  case N_LOGAND:
    if (run_mexpr(node->a) && run_mexpr(node->b))
      return YES;

  case N_NEGATE: {
    node_t *a = run_mexpr(node->a);

    return mexpr_negate(a);
  }

  case N_ADD: {
    node_t *a = run_mexpr(node->a);
    node_t *b = run_mexpr(node->b);

    return mexpr_add(a, b);
  }

  case N_SUB: {
    node_t *a = run_mexpr(node->a);
    node_t *b = run_mexpr(node->b);

    return mexpr_sub(a, b);
  }

  case N_MUL: {
    node_t *a = run_mexpr(node->a);
    node_t *b = run_mexpr(node->b);

    return mexpr_mul(a, b);
  }

  case N_DIV: {
    node_t *a = run_mexpr(node->a);
    node_t *b = run_mexpr(node->b);

    return mexpr_div(a, b);
  }

  case N_EQUALS: {
    node_t *a = run_mexpr(node->a);
    node_t *b = run_mexpr(node->b);

    return mexpr_equals(a, b) ? YES : NULL;
  }

  case N_LT: {
    node_t *a = run_mexpr(node->a);
    node_t *b = run_mexpr(node->b);

    return mexpr_less(a, b) ? YES : NULL;
  }

  case N_GT: {
    node_t *a = run_mexpr(node->a);
    node_t *b = run_mexpr(node->b);

    return mexpr_greater(a, b) ? YES : NULL;
  }

  default:
    COMPILE_ERROR("not yet implemented");
  }

  return NULL;
}

node_t *run_mnode(node_t *node);

node_t *run_mnodes(list_t *l) {
  node_t *r = NULL;

  for (size_t i = 0; i < l->length; i++)
    if ((r = run_mnode(l->data[i])))
      break;

  return r;
}

node_t *run_mnode(node_t *node) {
  node_t *r = NULL;

  switch (node->tag) {
  case N_MIF:
    if (run_mexpr(node->a))
      r = run_mnodes(node->l);
    else if (node->l2)
      r = run_mnodes(node->l2);
    break;

  case N_MFOR:
    while (run_mexpr(node->a))
      if ((r = run_mnodes(node->l)))
        break;
    break;

  case N_MREPEAT: {
    list_t *l = list_new();

    while (run_mexpr(node->a)) {
      node_t *n = run_mnodes(node->l);

      if (!n)
        return NULL;

      if (IS_EXPR(n))
        n = node1(N_EXPRSTMT, n);

      list_push(l, n);
    }

    r = nodel(N_PROGRAM, l);
  } break;

  case N_MSET:
    table_set(list_index(MVARS, -1), node->t->text, run_mexpr(node->a));
    break;

  case N_MPUSH: {
    node_t *l = table_get(list_index(MVARS, -1), node->t->text);
    if (l && (l->tag == N_LIST || l->tag == N_PROGRAM)) {
      node_t *n = run_mexpr(node->a);
      if (!n)
        break;

      if (IS_EXPR(n)) {
        if (l->tag == N_PROGRAM)
          n = node1(N_EXPRSTMT, n);
        else
          break;
      }

      list_push(l->l, n);
    }
  } break;

  case N_MSTMT:
    r = node->a;
    break;

  case N_MEXPR:
    r = run_mexpr(node->a);
    break;

  default:
    r = node;
  }

  return r;
}

list_t *macro_stk;
size_t expand_depth = 0;
size_t macro_rlimit = 100;

node_t *run_macro(macro_t *macro, list_t *args) {
  if (macro_stk->length >= macro_rlimit)
    return NULL;

  list_push(macro_stk, macro);

  table_t *mvars = list_index(MVARS, -1);
  table_set(mvars, "nil", NULL);
  table_set(mvars, "*", nodel(N_LIST, args));

  if (!macro->variable)
    for (size_t i = 0; i < args->length; i++)
      table_set(mvars, ((token_t *)macro->params->data[i])->text,
                args->data[i]);

  node_t *r = NULL;

  for (size_t i = 0; i < macro->body->length; i++) {
    r = run_mnode(macro->body->data[i]);

    if (r)
      break;
  }

  list_pop(macro_stk);

  return r;
}

node_t *_expand_mvars(node_t *node, int expr, mvar_expand_err_t *err) {
  if (node->tag == N_LITERAL)
    return node;

  if (node->tag == N_MVAR) {
    char *name = node->t->text;
    err->mvar = node;

    table_t *mvars = list_index(MVARS, -1);

    if (!table_has(mvars, name)) {
      err->code = 1;
      return NULL;
    }

    node_t *n = table_get(mvars, name);

    if (n) {
      if (expr && !IS_EXPR(n)) {
        err->code = 2;
        return NULL;
      }

      if (!expr && IS_EXPR(n))
        n = node1(N_EXPRSTMT, n);
    } else {
      err->code = 3;
      return NULL;
    }

    return n;
  }

  if (node->tag == N_EXPRSTMT) {
    node_t *n = _expand_mvars(node->a, 0, err);
    if (err->code != 0)
      return NULL;

    if (!IS_EXPR(n))
      return n;

    node = node_copy(node);
    node->a = n;

    return node;
  } else if ((node->tag >= N_ADD && node->tag <= N_BAND) ||
             (node->tag >= N_ASSIGN && node->tag <= N_ASSIGN_SHR) ||
             node->tag == N_DECL) {
    node = node_copy(node);

    node->a = _expand_mvars(node->a, 1, err);
    if (err->code != 0)
      return NULL;

    node->b = _expand_mvars(node->b, 1, err);
    if (err->code != 0)
      return NULL;

    return node;
  } else if (node->tag == N_PROGRAM || node->tag == N_BLOCK ||
             node->tag == N_LIST || node->tag == N_TUPLE ||
             node->tag == N_COMMA) {
    node = node_copy(node);
    node->l = list_copy(node->l);

    for (size_t i = 0; i < node->l->length; i++) {
      node_t *n = _expand_mvars(node->l->data[i], 1, err);
      if (err->code != 0)
        return NULL;

      node->l->data[i] = n;
    }

    return node;
  } else if (node->tag == N_IF || node->tag == N_IFEXPR) {
    node = node_copy(node);

    node->a = _expand_mvars(node->a, 1, err);
    if (err->code != 0)
      return NULL;

    node->b = _expand_mvars(node->b, 1, err);
    if (err->code != 0)
      return NULL;

    if (node->c) {
      node->c = _expand_mvars(node->c, 1, err);
      if (err->code != 0)
        return NULL;
    }

    return node;
  } else if (node->tag == N_CALL) {
    node = node_copy(node);

    node->a = _expand_mvars(node->a, 1, err);
    if (err->code != 0)
      return NULL;

    node->l = list_copy(node->l);

    for (size_t i = 0; i < node->l->length; i++) {
      node_t *n = _expand_mvars(node->l->data[i], 1, err);
      if (err->code != 0)
        return NULL;

      node->l->data[i] = n;
    }

    return node;
  } else if (node->tag == N_MACRO_CALL) {
    node = node_copy(node);
    node->l = list_copy(node->l);

    for (size_t i = 0; i < node->l->length; i++) {
      node_t *n = _expand_mvars(node->l->data[i], 1, err);
      if (err->code != 0)
        return NULL;

      node->l->data[i] = n;
    }

    return node;
  } else if (node->tag == N_INC || node->tag == N_DEC || node->tag == N_PINC ||
             node->tag == N_PDEC) {
    node = node_copy(node);

    node->a = _expand_mvars(node->a, 1, err);
    if (err->code != 0)
      return NULL;

    return node;
  }

  err->code = 4;

  return NULL;
}

node_t *expand_mvars(node_t *node, node_t *_node, int expr) {
  mvar_expand_err_t err = {NULL, 0};

  node_t *r = _expand_mvars(_node, expr, &err);
  if ((!r || err.code != 0) && err.mvar) {
    COMPILE_NOTE("macro expansion failed");

    node = err.mvar;
  }

  if (err.code == 1) {
    COMPILE_ERROR("undefined macro variable: '%s'", err.mvar->t->text);
  } else if (err.code == 2) {
    COMPILE_ERROR(
        "macro variable '%s' expanded to non-expression in expression context",
        err.mvar->t->text);
  } else if (err.code == 3) {
    COMPILE_ERROR("macro variable '%s' expanded to nil", err.mvar->t->text);
  } else if (err.code == 4) {
    COMPILE_ERROR("macro variable expansion failed because it is not yet "
                  "implemented for this context");
  }

  if (!r)
    COMPILE_ERROR("macro variable expansion failed");

  return r;
}

void compile_macro_call(buffer_t *gbuf, buffer_t *buf, list_t *ctx,
                        table_t *ltab, list_t *lstk, list_t *sstk, list_t *lbl,
                        node_t *node, int expr) {
  size_t argc = node->l->length;
  char *name = node->t->text;

  int res = 0;
  macro_t *m = find_macro(name, argc, &res);
  if (!m) {
    if (res == 1) {
      COMPILE_ERROR("undefined macro: '%s'", name);
    } else {
      COMPILE_ERROR("no %d-param candidate found for macro: '%s'", argc, name);
    }
  }

  list_push(MVARS, table_new());

  if (macro_stk->length >= macro_rlimit)
    COMPILE_ERROR("recursion depth limit exceeded while expanding macro: '%s'",
                  name);

  node_t *r = run_macro(m, node->l);

  if (r) {
    r = expand_mvars(node, r, expr);

    if (r->tag == N_MACRO_CALL) {
      list_pop(MVARS);

      if (expand_depth >= macro_rlimit)
        COMPILE_ERROR(
            "recursion depth limit exceeded while expanding macro: '%s'", name);

      expand_depth++;

      compile_macro_call(gbuf, buf, ctx, ltab, lstk, sstk, lbl, r, expr);

      expand_depth--;

      return;
    }

    if (expr && !IS_EXPR(r))
      COMPILE_ERROR(
          "macro '%s' expanded to non-expression in expression context", name);

    if (!expr && IS_EXPR(r))
      r = node1(N_EXPRSTMT, r);

    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, r);
  } else
    COMPILE_ERROR("macro '%s' expanded to nil", name);

  list_pop(MVARS);
}

void compile_node(buffer_t *gbuf, buffer_t *buf, list_t *ctx, table_t *ltab,
                  list_t *lstk, list_t *sstk, list_t *lbl, node_t *node) {
  switch (node->tag) {
  case N_TOPLEVEL:
  case N_PROGRAM:
    compile_block(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->l);
    break;

  case N_EXPRSTMT:
    if (node->a->tag == N_LITERAL && node->a->t->tag != T_NAME)
      break;
    else if (node->a->tag == N_MACRO_CALL) {
      compile_macro_call(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a, 0);

      break;
    }

    EMIT("(void)(");
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
    EMIT(");");
    break;

  case N_BLOCK:
    LBPUSH();
    CTXPUSH("scope");
    list_push(CONSTANTS, table_new());
    list_push(MACROS, table_new());
    EMIT("qi_new_sticky_scope(state);\n");
    compile_block(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->l);
    EMIT("qi_old_scope(state);");
    list_pop(MACROS);
    list_pop(CONSTANTS);
    CTXPOP();
    LBPOP();
    break;

  case N_LITERAL:
    switch (node->t->tag) {
    case T_NUMBER: {
      char *number = node->t->text;

      if (strncmp(number, "0o", 2) == 0 || strncmp(number, "0b", 2) == 0) {
        buffer_t *buf = buffer_new();

        if (number[1] == 'o')
          buffer_fmt(buf, "0%s", number + 2);
        else
          buffer_fmt(buf, "%d", strtol(number + 2, NULL, 2));

        number = buffer_read(buf);
      } else if (number[0] == '0' && number[1] && isdigit(number[1])) {
        size_t i;
        for (i = 0; i < strlen(number); i++)
          if (number[i] != '0' || number[i + 1] == '.')
            break;

        number += i;
      }

      EMIT("qi_make_number(state, %s)", number);
    } break;

    case T_STRING:
      if (!*(node->t->text)) {
        EMIT("state->empty_string");
      } else {
        EMIT("qi_make_string(state, \"%s\")", node->t->text);
      }
      break;

    case T_FSTRING: {
      char *text = node->t->text;

      if (!*text) {
        EMIT("state->empty_string");

        break;
      }

      list_t *parts = list_new();

      buffer_t *tbuf = buffer_new();

      for (size_t i = 0; i < strlen(text); i++) {
        char c = text[i];
        if (c == '$' && text[i + 1] == '$') {
          buffer_append(tbuf, '$');

          i++;

          continue;
        } else if (c == '$' && text[i + 1] == '{') {
          i += 2;

          buffer_t *tbuf2 = buffer_new();

          while (text[i] && text[i] != '}')
            buffer_append(tbuf2, text[i++]);

          if (text[i] != '}') {
            i--;

            buffer_appends(tbuf, "${");
            buffer_appendb(tbuf, tbuf2);

            continue;
          }

          if (tbuf->size > 0)
            list_push(parts, nodeb(tbuf));

          tbuf = buffer_new();

          char *source = unescape(buffer_read(tbuf2));

          list_t *pair = list_new();

          buffer_t *fname = buffer_new();
          size_t line, col;
          (void)traverse(GETSRC(node->fi), node->pos, &line, &col);

          buffer_fmt(fname, "<fstring at %s:%zu:%zu>", GETFNAME(node->fi), line,
                     col);

          list_push(pair, buffer_read(fname));
          list_push(pair, source);

          list_push(FILES, pair);

          list_t *tokens = tokenize(source);

          size_t pos = 0;
          node_t *n = parse_expr(tokens, &pos);

          if (pos != tokens->length - 1)
            COMPILE_ERROR("unconsumed input in f-expr");

          list_push(parts, n);
        } else
          buffer_append(tbuf, c);
      }

      if (tbuf->size > 0)
        list_push(parts, nodeb(tbuf));

      tbuf = buffer_new();

      NEWGID();

      buffer_fmt(tbuf,
                 "inline static qi_value_t *__%s%d(qi_state_t *state) {\n",
                 PREFIX, gid);
      buffer_fmt(tbuf, "qi_value_t *str = state->empty_string;\n");

      for (size_t i = 0; i < parts->length; i++) {
        node_t *part = parts->data[i];

        buffer_fmt(tbuf, "str = qi_add(state, str, ");

        if (part->tag == N_BUFFER)
          buffer_fmt(tbuf, "qi_make_string(state, \"%s\")",
                     buffer_read(part->buf));
        else {
          buffer_fmt(tbuf, "qi_to_string(state, ");
          compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, part);
          buffer_fmt(tbuf, ")");
        }

        buffer_fmt(tbuf, ");\n");
      }

      buffer_fmt(tbuf, "return str;\n}\n");

      buffer_appendb(gbuf, tbuf);

      EMIT("__%s%d(state)", PREFIX, gid);
    } break;

    case T_USTRING:
      EMIT("qi_call(state, qi_get(state, \"ustr\"), "
           "qi_list_push(qi_list_make(), qi_make_string(state, \"%s\")))",
           node->t->text);
      break;

    case T_BSTRING:
      EMIT("qi_make_bytes(state, (unsigned char *)\"%s\", %d)", node->t->text,
           node->t->z);
      break;

    case T_NAME: {
      char *name = node->t->text;
      node_t *n = const_get(name);

      if (n)
        compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, n);
      else
        EMIT("qi_get(state, \"%s\")", name);
    } break;

    case T_TRUE:
      EMIT("state->_true");
      break;
    case T_FALSE:
      EMIT("state->_false");
      break;
    case T_NIL:
      EMIT("state->nil");
      break;

    default:
      COMPILE_ERROR("not yet implemented");
    }
    break;

  case N_COMMA:
    EMIT("(");

    for (size_t i = 0; i < node->l->length; i++) {
      if (i != 0)
        EMIT(", ");

      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->l->data[i]);
    }

    EMIT(")");
    break;

  case N_LIST:
    EMIT("qi_make_list(state, ");
    compile_list(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->l);
    EMIT(")");
    break;

  case N_LISTGEN: {
    NEWGID();

    buffer_t *tbuf = buffer_new();

    buffer_fmt(tbuf, "inline static qi_value_t *__%s%d(qi_state_t *state) {\n",
               PREFIX, gid);
    buffer_fmt(tbuf, "qi_list_t *list = qi_list_make();\n");

    buffer_t *bbuf = buffer_new();

    CTXPUSH("scope");
    buffer_fmt(tbuf, "qi_new_scope(state);\n");

    if (node->b) {
      buffer_fmt(bbuf, "if (_qi_truthy(state, ");
      compile_node(gbuf, bbuf, ctx, ltab, lstk, sstk, lbl, node->b);
      buffer_fmt(bbuf, ")) {\n");
    }

    for (size_t i = 0; i < node->a->b->l->length; i++) {
      buffer_fmt(bbuf, "qi_list_push(list, ");
      compile_node(gbuf, bbuf, ctx, ltab, lstk, sstk, lbl,
                   node->a->b->l->data[i]);
      buffer_fmt(bbuf, ");\n");
    }

    if (node->b)
      buffer_fmt(bbuf, "}\n");

    node->a->b = nodeb(bbuf);
    node->a->t2 = NULL;

    compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->a);

    CTXPOP();
    buffer_fmt(tbuf, "qi_old_scope(state);\n");

    buffer_fmt(tbuf, "return qi_make_list(state, list);\n}\n");

    buffer_appendb(gbuf, tbuf);

    EMIT("__%s%d(state)", PREFIX, gid);
  } break;

  case N_TABLEGEN: {
    NEWGID();

    buffer_t *tbuf = buffer_new();

    buffer_fmt(tbuf, "inline static qi_value_t *__%s%d(qi_state_t *state) {\n",
               PREFIX, gid);
    buffer_fmt(tbuf, "qi_table_t *table = qi_table_make();\n");

    buffer_t *bbuf = buffer_new();

    CTXPUSH("scope");
    buffer_fmt(tbuf, "qi_new_scope(state);\n");

    if (node->b) {
      buffer_fmt(bbuf, "if (_qi_truthy(state, ");
      compile_node(gbuf, bbuf, ctx, ltab, lstk, sstk, lbl, node->b);
      buffer_fmt(bbuf, ")) {\n");
    }

    for (size_t i = 0; i < node->a->b->l->length; i++) {
      list_t *pair = node->a->b->l->data[i];

      buffer_fmt(bbuf, "qi_table_set(table, qi_to_string(state, ");
      compile_node(gbuf, bbuf, ctx, ltab, lstk, sstk, lbl, pair->data[0]);
      buffer_fmt(bbuf, ")->value.string, ");
      compile_node(gbuf, bbuf, ctx, ltab, lstk, sstk, lbl, pair->data[1]);
      buffer_fmt(bbuf, ");\n");
    }

    if (node->b)
      buffer_fmt(bbuf, "}\n");

    node->a->b = nodeb(bbuf);
    node->a->t2 = NULL;

    compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->a);

    CTXPOP();
    buffer_fmt(tbuf, "qi_old_scope(state);\n");

    buffer_fmt(tbuf, "return qi_make_table(state, table);\n}\n");

    buffer_appendb(gbuf, tbuf);

    EMIT("__%s%d(state)", PREFIX, gid);
  } break;

  case N_TUPLE:
    EMIT("qi_make_tuple(state, ");
    compile_list(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->l);
    EMIT(")");
    break;

  case N_NILTUPLE:
    EMIT("state->empty_tuple");
    break;

  case N_TABLE:
    EMIT("qi_make_table(state, ");
    compile_pairs(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->l);
    EMIT(")");
    break;

  case N_CALL:
    if (DEBUG) {
      EMIT("qi_call_debug(state, ");
    } else {
      EMIT("qi_call(state, ");
    }

    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
    EMIT(", ");
    compile_list(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->l);

    if (DEBUG)
      buffer_fmt(buf, ", __debugData[%d]", insert_debug(node));

    EMIT(")");
    break;

  case N_MEMBER:
    EMIT("qi_index(state, ");
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
    EMIT(", qi_make_string(state, \"%s\"))", node->t->text);
    break;

  case N_INDEX:
    EMIT("qi_index(state, ");
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
    EMIT(", ");
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b);
    EMIT(")");
    break;

  case N_SLICE: {
    NEWGID();

    buffer_t *tbuf = buffer_new();

    buffer_fmt(tbuf, "inline static qi_value_t *__%s%d(qi_state_t *state) {\n",
               PREFIX, gid);

    if (node->b && node->c) {
      buffer_fmt(tbuf, "qi_list_t *pargs = qi_list_make_n(3);\n");
      buffer_fmt(tbuf, "qi_list_data(pargs, 0) = ");
      compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->a);
      buffer_fmt(tbuf, ";\n");

      buffer_fmt(tbuf, "qi_list_data(pargs, 1) = ");
      compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->b);
      buffer_fmt(tbuf, ";\n");

      buffer_fmt(tbuf, "qi_list_data(pargs, 2) = ");
      compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->c);
      buffer_fmt(tbuf, ";\n");
    } else if (node->b) {
      buffer_fmt(tbuf, "qi_list_t *pargs = qi_list_make_n(2);\n");
      buffer_fmt(tbuf, "qi_list_data(pargs, 0) = ");
      compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->a);
      buffer_fmt(tbuf, ";\n");

      buffer_fmt(tbuf, "qi_list_data(pargs, 1) = ");
      compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->b);
      buffer_fmt(tbuf, ";\n");
    } else {
      buffer_fmt(tbuf, "qi_list_t *pargs = qi_list_make_n(3);\n");
      buffer_fmt(tbuf, "qi_list_data(pargs, 0) = ");
      compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->a);
      buffer_fmt(tbuf, ";\n");

      buffer_fmt(tbuf, "qi_list_data(pargs, 1) = state->zero;\n");

      buffer_fmt(tbuf, "qi_list_data(pargs, 2) = ");
      compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->c);
      buffer_fmt(tbuf, ";\n");
    }

    buffer_fmt(tbuf,
               "return qi_call(state, qi_get(state, \"__slice\"), pargs);\n");
    buffer_fmt(tbuf, "}\n");

    buffer_appendb(gbuf, tbuf);

    EMIT("__%s%d(state)", PREFIX, gid);
  } break;

  case N_DECL:
  case N_ASSIGN:
    if (node->a->tag == N_LIST) {
      if (node->a->l->length < 2)
        COMPILE_ERROR("illegal unpack assignment left-hand side");

      NEWGID();

      buffer_t *tbuf = buffer_new();

      buffer_fmt(tbuf,
                 "inline static qi_value_t *__%s%d(qi_state_t *state) {\n",
                 PREFIX, gid);

      char *varname = tempvar();

      buffer_fmt(tbuf, "qi_value_t *%s = ", varname);
      compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->b);
      buffer_fmt(tbuf, ";\n");

      for (size_t i = 0; i < node->a->l->length; i++) {
        if (node->tag == N_DECL) {
          DECLIN(tbuf, (node_t *)node->a->l->data[i],
                 buffer_fmt(tbuf,
                            "qi_index(state, %s, qi_make_number(state, %d))",
                            varname, i));
        } else {
          ASSIGNIN(tbuf, (node_t *)node->a->l->data[i],
                   buffer_fmt(tbuf,
                              "qi_index(state, %s, qi_make_number(state, %d))",
                              varname, i),
                   false);
        }

        buffer_fmt(tbuf, ";\n");
      }

      buffer_fmt(tbuf, "return %s;\n}\n", varname);

      buffer_appendb(gbuf, tbuf);

      EMIT("__%s%d(state)", PREFIX, gid);

      break;
    } else if (node->a->tag == N_TUPLE) {
      if (node->a->l->length < 2)
        COMPILE_ERROR("illegal multiple assignment left-hand side");

      if (node->b->tag != N_TUPLE || node->b->l->length < 2 ||
          node->a->l->length != node->b->l->length)
        COMPILE_ERROR("illegal multiple assignment right-hand side");

      NEWGID();

      buffer_t *tbuf = buffer_new();

      buffer_fmt(tbuf, "qi_value_t *__%s%d(qi_state_t *state) {\n", PREFIX,
                 gid);

      list_t *vals = list_new();
      for (size_t i = 0; i < node->b->l->length; i++) {
        char *varname = tempvar();

        buffer_fmt(tbuf, "qi_value_t *%s = ", varname);
        compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl,
                     node->b->l->data[i]);
        buffer_fmt(tbuf, ";\n");

        list_push(vals, varname);
      }

      for (size_t i = 0; i < node->a->l->length; i++) {
        char *varname = vals->data[i];

        if (node->tag == N_DECL) {
          DECLIN(tbuf, (node_t *)node->a->l->data[i],
                 buffer_fmt(tbuf, "%s", varname));
        } else {
          ASSIGNIN(tbuf, (node_t *)node->a->l->data[i],
                   buffer_fmt(tbuf, "%s", varname), false);
        }

        buffer_fmt(tbuf, ";\n");
      }

      buffer_fmt(tbuf, "return %s;\n}\n", vals->data[vals->length - 1]);

      buffer_appendb(gbuf, tbuf);

      EMIT("__%s%d(state)", PREFIX, gid);

      break;
    }

    if (node->tag == N_DECL) {
      DECL(node->a,
           compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b));
    } else {
      ASSIGN(node->a,
             compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b));
    }
    break;

  case N_ASSIGN_ADD:
    COMPASSIGN(node->a, "add",
               compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b));
    break;
  case N_ASSIGN_SUB:
    COMPASSIGN(node->a, "sub",
               compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b));
    break;
  case N_ASSIGN_MUL:
    COMPASSIGN(node->a, "mul",
               compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b));
    break;
  case N_ASSIGN_DIV:
    COMPASSIGN(node->a, "div",
               compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b));
    break;
  case N_ASSIGN_IDIV:
    COMPASSIGN(node->a, "idiv",
               compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b));
    break;
  case N_ASSIGN_MOD:
    COMPASSIGN(node->a, "mod",
               compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b));
    break;
  case N_ASSIGN_POW:
    COMPASSIGN(node->a, "pow",
               compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b));
    break;
  case N_ASSIGN_BOR:
    COMPASSIGN(node->a, "bor",
               compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b));
    break;
  case N_ASSIGN_BAND:
    COMPASSIGN(node->a, "band",
               compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b));
    break;
  case N_ASSIGN_XOR:
    COMPASSIGN(node->a, "xor",
               compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b));
    break;
  case N_ASSIGN_SHL:
    COMPASSIGN(node->a, "shl",
               compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b));
    break;
  case N_ASSIGN_SHR:
    COMPASSIGN(node->a, "shr",
               compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b));
    break;

  case N_INC:
    COMPASSIGN(node->a, "add", EMIT("state->one"));
    break;

  case N_DEC:
    COMPASSIGN(node->a, "sub", EMIT("state->one"));
    break;

  case N_PINC:
    COMPASSIGNP(node->a, "add", EMIT("state->one"));
    break;

  case N_PDEC:
    COMPASSIGNP(node->a, "sub", EMIT("state->one"));
    break;

  case N_VAR:
  case N_LET:
    table_iterate(node->h, {
      EMIT("qi_%s(state, \"%s\", ", node->tag == N_LET ? "decl_const" : "decl",
           entry.key);

      if (entry.value)
        compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, entry.value);
      else
        EMIT("state->nil");

      EMIT(");\n");
    });
    break;

  case N_VARUNPACK:
  case N_LETUNPACK: {
    char *varname = tempvar();

    EMIT("qi_value_t *%s = ", varname);
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
    EMIT(";\n");

    for (size_t i = 0; i < node->l->length; i++)
      EMIT("%s(state, \"%s\", qi_index(state, %s, qi_make_number(state, "
           "%d)));\n",
           node->tag == N_VARUNPACK ? "qi_decl" : "qi_decl_const",
           node->l->data[i], varname, i);
  } break;

  case N_CONST: case N_ENUM:
    break;

  case N_IF:
    CTXPUSH("scope");

    EMIT("qi_new_scope(state);\n");
    EMIT("if (_qi_truthy(state, ");
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
    EMIT(")) {\n");
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b);
    if (node->c) {
      EMIT("} else {\n");
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->c);
    }
    EMIT("}\n");

    CTXPOP();
    EMIT("qi_old_scope(state);\n");
    break;

  case N_SWITCH: {
    NEWGID();

    CTXPUSH("scope");

    EMIT("qi_new_scope(state);\n");

    if (node->t2) {
      if (table_get(ltab, node->t2->text))
        COMPILE_ERROR("redeclaration of loop label: '%s'", node->t2->text);

      int_stack_t *triple = stack_new();

      stack_push(triple, 1);
      stack_push(triple, gid);
      stack_push(triple, scope_index(ctx));

      table_set(ltab, node->t2->text, triple);
    }

    char *varname = tempvar();

    EMIT("qi_value_t *%s = ", varname);
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
    EMIT(";\n");

    for (size_t i = 0; i < node->l->length; i++) {
      list_t *pair = node->l->data[i];
      if (!pair->data[0])
        continue;

      char *label = tempvar();

      EMIT("if (_qi_equals(state, %s, ", varname);
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, pair->data[0]);
      EMIT(")) goto %s;\n", label);

      pair->data[0] = label;
    }

    EMIT("goto __default%d;\n", gid);

    SPUSH(gid);
    CTXPUSH("switch");

    int has_default = 0;

    for (size_t i = 0; i < node->l->length; i++) {
      list_t *pair = node->l->data[i];
      char *label = pair->data[0];
      node_t *block = pair->data[1];

      if (!label) {
        EMIT("__default%d:;\n", gid);

        has_default = 1;
      } else {
        EMIT("%s:;\n", label);
      }

      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, block);
    }

    CTXPOP();
    CTXPOP();
    SPOP();

    if (!has_default) {
      EMIT("__default%d:;\n", gid);
    }

    EMIT("__break%d:;\n", gid);

    EMIT("qi_old_scope(state);\n");
  } break;

  case N_FOR: {
    NEWGID();

    CTXPUSH("scope");
    EMIT("qi_new_scope(state);\n");

    if (node->t2) {
      if (table_get(ltab, node->t2->text))
        COMPILE_ERROR("redeclaration of loop label: '%s'", node->t2->text);

      int_stack_t *triple = stack_new();

      stack_push(triple, 0);
      stack_push(triple, gid);
      stack_push(triple, scope_index(ctx));

      table_set(ltab, node->t2->text, triple);
    }

    if (!node->a) {
      EMIT("for (;;) {\n");
    } else if (node->a && !node->b) {
      EMIT("while (_qi_truthy(state, ");
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
      EMIT(")) {\n");
    } else {
      node_t *a = node->a;
      if (IS_EXPR(a))
        a = node1(N_EXPRSTMT, a);

      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, a);

      EMIT("while (_qi_truthy(state, ");
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b);
      EMIT(")) {\n");
    }

    CTXPUSH("scope");
    EMIT("qi_new_scope(state);\n");

    LPUSH(gid);
    CTXPUSH("for");
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->d);

    EMIT("__continue%d:;\n", gid);

    if (node->c) {
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->c);

      EMIT(";\n");
    }

    CTXPOP();
    LPOP();

    CTXPOP();
    EMIT("qi_old_scope(state);\n");

    EMIT("}\n");

    EMIT("goto __exit%d;\n", gid);
    EMIT("__break%d:;\n", gid);
    EMIT("qi_old_scope(state);\n");
    EMIT("__exit%d:;\n", gid);

    CTXPOP();
    EMIT("qi_old_scope(state);\n");
  } break;

  case N_FOROF:
  case N_FOROFVAR:
  case N_FOROFUNPACK:
  case N_FOROFVARUNPACK: {
    NEWGID();

    CTXPUSH("scope");
    EMIT("qi_new_scope(state);\n");

    if (node->t2) {
      if (table_get(ltab, node->t2->text))
        COMPILE_ERROR("redeclaration of loop label: '%s'", node->t2->text);

      int_stack_t *triple = stack_new();

      stack_push(triple, 0);
      stack_push(triple, gid);
      stack_push(triple, scope_index(ctx));

      table_set(ltab, node->t2->text, triple);
    }

    char *varname = tempvar();

    EMIT("qi_value_t *%s = qi_iter(state, ", varname);
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
    EMIT(");\n");

    if (node->tag == N_FOROFVAR) {
      EMIT("qi_decl(state, \"%s\", state->nil);\n", node->t->text);
    } else if (node->tag == N_FOROFVARUNPACK) {
      for (size_t i = 0; i < node->l->length; i++)
        EMIT("qi_decl(state, \"%s\", state->nil);\n", node->l->data[i]);
    }

    EMIT("for (qi_size_t length = _qi_length(state, %s), i = 0; i < length; "
         "i++) {\n",
         varname);

    if (node->tag == N_FOROFUNPACK || node->tag == N_FOROFVARUNPACK) {
      for (size_t i = 0; i < node->l->length; i++)
        EMIT("qi_set(state, false, \"%s\", qi_index(state, qi_index(state, %s, "
             "qi_make_number(state, i)), qi_make_number(state, %d)));\n",
             node->l->data[i], varname, i);
    } else
      EMIT("qi_set(state, false, \"%s\", qi_index(state, %s, "
           "qi_make_number(state, i)));\n",
           node->t->text, varname);

    CTXPUSH("scope");
    EMIT("qi_new_scope(state);\n");

    LPUSH(gid);
    CTXPUSH("for");
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b);
    CTXPOP();
    LPOP();

    EMIT("__continue%d:;\n", gid);

    CTXPOP();
    EMIT("qi_old_scope(state);\n");

    EMIT("}\n");

    EMIT("goto __exit%d;\n", gid);
    EMIT("__break%d:;\n", gid);
    EMIT("qi_old_scope(state);\n");
    EMIT("__exit%d:;\n", gid);

    CTXPOP();
    EMIT("qi_old_scope(state);\n");
  } break;

  case N_BREAK: {
    if (!INCTX("for") && !INCTX("switch"))
      COMPILE_ERROR("break outside of a loop or a switch");

    if (node->t) {
      if (node->t->tag == T_NUMBER) {
        unsigned int offset = abs(atoi(node->t->text)) + 1;

        if (offset < 2 || offset > lstk->length)
          COMPILE_ERROR("%d is not a valid break loop offset", offset - 1);

        int_stack_t *pair = lstk->data[lstk->length - offset];
        size_t scopes_k = count_scopes(ctx, pair->data[1]);

        for (size_t i = 0; i < scopes_k; i++) {
          EMIT("qi_old_scope(state);\n");
        }

        EMIT("goto __break%d;", pair->data[0]);
      } else {
        char *label = node->t->text;

        int_stack_t *triple = table_get(ltab, label);

        if (!triple)
          COMPILE_ERROR("undefined loop label: '%s'", label);

        size_t scopes_k = count_scopes(ctx, triple->data[2]);

        for (size_t i = 0; i < scopes_k; i++) {
          EMIT("qi_old_scope(state);\n");
        }

        EMIT("goto __break%d;", triple->data[1]);
      }

      break;
    }

    size_t gid;
    int_stack_t *pair;

    if (in_switch(ctx)) {
      pair = sstk->data[sstk->length - 1];
      gid = pair->data[0];
    } else {
      pair = lstk->data[lstk->length - 1];
      gid = pair->data[0];
    }

    size_t scopes_k = count_scopes(ctx, pair->data[1]);

    for (size_t i = 0; i < scopes_k; i++) {
      EMIT("qi_old_scope(state);\n");
    }

    EMIT("goto __break%d;", gid);
  } break;

  case N_CONTINUE: {
    if (!INCTX("for"))
      COMPILE_ERROR("continue outside of a loop");

    if (node->t) {
      if (node->t->tag == T_NUMBER) {
        unsigned int offset = abs(atoi(node->t->text)) + 1;

        if (offset < 2 || offset > lstk->length)
          COMPILE_ERROR("%d is not a valid break loop offset", offset - 1);

        int_stack_t *pair = lstk->data[lstk->length - offset];
        size_t scopes_k = count_scopes(ctx, pair->data[1]);

        for (size_t i = 0; i < scopes_k; i++) {
          EMIT("qi_old_scope(state);\n");
        }

        EMIT("goto __continue%d;", pair->data[0]);
      } else {
        char *label = node->t->text;

        int_stack_t *triple = table_get(ltab, label);

        if (!triple)
          COMPILE_ERROR("undefined loop label: '%s'", label);

        if (triple->data[0])
          COMPILE_ERROR("continue on a switch loop label: '%s'", label);

        size_t scopes_k = count_scopes(ctx, triple->data[2]);

        for (size_t i = 0; i < scopes_k; i++) {
          EMIT("qi_old_scope(state);\n");
        }

        EMIT("goto __continue%d;", triple->data[1]);
      }

      break;
    }

    int_stack_t *pair = lstk->data[lstk->length - 1];
    size_t gid = pair->data[0];

    size_t scopes_k = count_scopes(ctx, pair->data[1]);

    for (size_t i = 0; i < scopes_k; i++) {
      EMIT("qi_old_scope(state);\n");
    }

    EMIT("goto __continue%d;", gid);
  } break;

  case N_DEFER: {
    NEWGID();

    buffer_t *tbuf = buffer_new();

    buffer_fmt(tbuf, "void __%s%d(qi_state_t *state) {\n", PREFIX, gid);

    LBPUSH();
    CTXPUSH("gap");
    list_push(CONSTANTS, table_new());
    list_push(MACROS, table_new());
    compile_node(gbuf, tbuf, ctx, table_new(), list_new(), list_new(), lbl,
                 node->a);
    list_pop(MACROS);
    list_pop(CONSTANTS);
    CTXPOP();
    LBPOP();

    buffer_fmt(tbuf, "\n}\n");

    buffer_appendb(gbuf, tbuf);

    EMIT("qi_add_defer(state, -1, __%s%d);", PREFIX, gid);
  } break;

  case N_RETURN: {
    if (!INCTX("func"))
      COMPILE_ERROR("return outside of a function");

    char *varname = NULL;

    if (node->a) {
      varname = tempvar();

      EMIT("qi_value_t *%s = ", varname);
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
      EMIT(";\n");
    }

    for (size_t i = 0; i < SCOPESK; i++)
      EMIT("qi_old_scope(state);\n");

    for (size_t i = 0; i < TRAPSK; i++)
      EMIT("qi_unset_trap(state, trap);\n");

    EMIT("return %s;", varname ? varname : "state->nil");
  } break;

  case N_FUNCDEF:
    break;
  case N_CLASS:
    break;
  case N_PASS:
    break;

  case N_DEL:
    EMIT("qi_del(state, ");

    if (node->a->tag == N_INDEX) {
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a->a);
      EMIT(", ");
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a->b);
    } else if (node->a->tag == N_MEMBER) {
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a->a);
      EMIT(", qi_make_string(state, \"%s\")", node->a->t->text);
    } else
      COMPILE_ERROR("not a index/member expression");

    EMIT(");");
    break;

  case N_WITH: {
    NEWGID();
    char *varname = tempvar();

    buffer_fmt(gbuf, "qi_value_t *%s;\n", varname);

    buffer_t *tbuf = buffer_new();
    buffer_fmt(tbuf, "void __%s%d(qi_state_t *state) {\n", PREFIX, gid);
    buffer_fmt(tbuf,
               "qi_call(state, qi_index(state, %s, qi_make_string(state, "
               "\"__leave\")), qi_list_push(qi_list_make(), %s));\n",
               varname, varname);
    buffer_fmt(tbuf, "}\n");

    buffer_appendb(gbuf, tbuf);

    EMIT("%s = ", varname);
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
    EMIT(";\n");

    EMIT("qi_call(state, qi_index(state, %s, qi_make_string(state, "
         "\"__enter\")), qi_list_push(qi_list_make(), %s));\n",
         varname, varname);

    CTXPUSH("scope");
    EMIT("qi_new_scope(state);\n");

    EMIT("qi_add_local_defer(state, 0, __%s%d);\n", PREFIX, gid);

    EMIT("qi_decl(state, \"%s\", %s);\n", node->t->text, varname);

    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b);

    CTXPOP();
    EMIT("qi_old_scope(state);\n");
  } break;

  case N_TRY:
    EMIT("qi_try(state, {\n");
    LBPUSH();
    CTXPUSH("gap");
    CTXPUSH("trap");
    compile_node(gbuf, buf, ctx, table_new(), list_new(), list_new(), lbl,
                 node->a);
    CTXPOP();
    CTXPOP();
    LBPOP();
    EMIT("}, {\n");
    if (node->t)
      EMIT("qi_decl(state, \"%s\", trap->value);\n", node->t->text);
    LBPUSH();
    CTXPUSH("gap");
    compile_node(gbuf, buf, ctx, table_new(), list_new(), list_new(), lbl,
                 node->b);
    CTXPOP();
    LBPOP();

    if (node->c) {
      NEWGID();

      buffer_t *tbuf = buffer_new();

      buffer_fmt(tbuf, "void __%s%d(qi_state_t *state) {\n", PREFIX, gid);
      LBPUSH();
      CTXPUSH("gap");
      compile_node(gbuf, tbuf, ctx, table_new(), list_new(), list_new(), lbl,
                   node->c);
      CTXPOP();
      LBPOP();

      buffer_fmt(tbuf, "\n}\n");

      buffer_appendb(gbuf, tbuf);

      EMIT("}, __%s%d);\n", PREFIX, gid);
    } else {
      EMIT("}, NULL);\n");
    }
    break;

  case N_THROW:
    if (!node->a) {
      EMIT("qi_throw(state, state->nil);");
    } else if (DEBUG) {
      char *varname = tempvar();

      EMIT("qi_value_t *%s = ", varname);
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
      EMIT(";\n");

      emit_debug(buf, node);

      EMIT("qi_throw(state, %s);", varname);
    } else {
      EMIT("qi_throw(state, ");
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
      EMIT(");");
    }
    break;

  case N_CATCH: {
    NEWGID();

    buffer_t *tbuf = buffer_new();

    buffer_fmt(tbuf, "qi_value_t *__%s%d(qi_state_t *state) {\n", PREFIX, gid);

    char *varname1 = tempvar();
    char *varname2 = tempvar();

    buffer_fmt(tbuf, "qi_value_t *%s = state->nil;\n", varname1);
    buffer_fmt(tbuf, "qi_value_t *%s = state->nil;\n", varname2);

    buffer_fmt(tbuf, "qi_try(state, {\n");
    buffer_fmt(tbuf, "%s = ", varname1);
    compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->a);
    buffer_fmt(tbuf, ";\n}, {\n");
    buffer_fmt(tbuf, "%s = trap->value;\n", varname2);
    buffer_fmt(tbuf, "}, NULL);\n");

    char *varname3 = tempvar();
    buffer_fmt(tbuf, "qi_list_t *%s = qi_list_make_n(2);\n", varname3);
    buffer_fmt(tbuf, "qi_list_data(%s, 0) = %s;\n", varname3, varname1);
    buffer_fmt(tbuf, "qi_list_data(%s, 1) = %s;\n", varname3, varname2);
    buffer_fmt(tbuf, "return qi_make_tuple(state, %s);\n", varname3);
    buffer_fmt(tbuf, "}\n");

    buffer_appendb(gbuf, tbuf);

    EMIT("__%s%d(state)", PREFIX, gid);
  } break;

  case N_LABEL: {
    int_stack_t *pair = table_get(list_index(lbl, -1), node->t->text);

    EMIT("__label%d:;", pair->data[0]);
  } break;

  case N_GOTO: {
    char *label = node->t->text;
    int_stack_t *pair = table_get(list_index(lbl, -1), label);
    if (!pair)
      COMPILE_ERROR("undefined label: '%s'", label);

    size_t offset = pair->data[1];

    if (offset >= ctx->length)
      COMPILE_ERROR("cannot goto inwards");

    size_t scopes_k = count_scopes(ctx, offset);

    for (size_t i = 0; i < scopes_k; i++) {
      EMIT("qi_old_scope(state);\n");
    }

    EMIT("goto __label%d;", pair->data[0]);
  } break;

  case N_REQUIRE:
    for (size_t i = 0; i < node->l->length; i++) {
      token_t *t = node->l->data[i];
      char *path = unescape(t->text);

      if (require_once(gbuf, buf, ctx, ltab, lstk, sstk, lbl, path) < 0)
        COMPILE_ERROR("'%s' is not a valid file path or a builtin library name",
                      path);
    }
    break;

  case N_IFEXPR:
    EMIT("(_qi_truthy(state, ");
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
    EMIT(")? ");
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b);
    EMIT(": ");
    compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->c);
    EMIT(")");
    break;

  case N_SWITCHEXPR: {
    NEWGID();

    buffer_t *tbuf = buffer_new();
    char *varname1 = tempvar();
    char *varname2 = tempvar();
    char *labelname = tempvar();

    buffer_fmt(tbuf, "qi_value_t *__%s%d(qi_state_t *state) {\n", PREFIX, gid);
    buffer_fmt(tbuf, "qi_value_t *%s = state->nil;\n", varname1);
    buffer_fmt(tbuf, "qi_value_t *%s = ", varname2);
    compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->a);
    buffer_fmt(tbuf, ";\n");

    for (size_t i = 0; i < node->l->length; i++) {
      list_t *pair = node->l->data[i];

      buffer_fmt(tbuf, "if (_qi_equals(state, %s, ", varname2);
      compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, pair->data[0]);
      buffer_fmt(tbuf, ")) {\n");
      buffer_fmt(tbuf, "%s = ", varname1);
      compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, pair->data[1]);
      buffer_fmt(tbuf, ";\n");
      buffer_fmt(tbuf, "goto %s;\n}\n", labelname);
    }

    if (node->b) {
      buffer_fmt(tbuf, "%s = ", varname1);
      compile_node(gbuf, tbuf, ctx, ltab, lstk, sstk, lbl, node->b);
      buffer_fmt(tbuf, ";\n");
    }

    buffer_fmt(tbuf, "%s: return %s;\n", labelname, varname1);
    buffer_fmt(tbuf, "}\n");

    buffer_appendb(gbuf, tbuf);

    EMIT("__%s%d(state)", PREFIX, gid);
  } break;

  case N_FUNCEXPR:
    compile_func(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node, NULL);
    break;

  case N_EQUALS:
    BINOP("equals");
    break;

  case N_NOTEQUALS:
    BINOP("not_equals");
    break;

  case N_IS:
    BINOP("is");
    break;

  case N_NOTIS:
    BINOP("not_is");
    break;

  case N_IN:
    BINOP("in");
    break;

  case N_NOTIN:
    BINOP("not_in");
    break;

  case N_LT:
    BINOP("lt");
    break;

  case N_GT:
    BINOP("gt");
    break;

  case N_LE:
    BINOP("le");
    break;

  case N_GE:
    BINOP("ge");
    break;

  case N_ADD:
    BINOP("add");
    break;

  case N_SUB:
    BINOP("sub");
    break;

  case N_MUL:
    BINOP("mul");
    break;

  case N_DIV:
    BINOP("div");
    break;

  case N_IDIV:
    BINOP("idiv");
    break;

  case N_MOD:
    BINOP("mod");
    break;

  case N_POW:
    BINOP("pow");
    break;

  case N_SHL:
    BINOP("shl");
    break;

  case N_SHR:
    BINOP("shr");
    break;

  case N_XOR:
    BINOP("xor");
    break;

  case N_BOR:
    BINOP("bor");
    break;

  case N_BAND:
    BINOP("band");
    break;

  case N_LOGOR:
    BINOP("or");
    break;

  case N_LOGAND:
    BINOP("and");
    break;

  case N_NEGATE:
    UNOP("negate");
    break;

  case N_UNARY_PLUS:
    UNOP("unary_plus");
    break;

  case N_NOT:
    UNOP("not");
    break;

  case N_BNOT:
    UNOP("bnot");
    break;

  case N_MACRO_CALL:
    compile_macro_call(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node, 1);
    break;
  case N_MVAR:
    COMPILE_ERROR("macro variable outside of a macro");

  case N_INLINE: {
    char *text = unescape(node->t->text);

    if (text[0] == '#') {
      EMIT("%s", text);
    } else {
      EMIT("%s;", text);
    }
  } break;
  case N_HEADER:
    buffer_fmt(HBUF, "%s\n", unescape(node->t->text));
    break;
  case N_INCLUDE:
    buffer_fmt(HBUF, "#include <%s>\n", unescape(node->t->text));
    break;

  case N_BUFFER:
    buffer_appendb(buf, node->buf);
    break;

  default:
    COMPILE_ERROR("not yet implemented");
  }
}

void compile_into(char *source, buffer_t *gbuf, buffer_t *buf, list_t *ctx,
                  table_t *ltab, list_t *lstk, list_t *sstk, list_t *lbl) {
  node_t *n = parse(source);
  if (NEEDS_UTF8 && !is_required("utf8")) {
    NEEDS_UTF8 = 0;

    require_once(gbuf, buf, ctx, ltab, lstk, sstk, lbl, "utf8");
  }

  compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, n);
}

char *escape(char *s) {
  buffer_t *buf = buffer_new();

  while (*s) {
    if (*s == '\\' || *s == '"')
      buffer_append(buf, '\\');

    buffer_append(buf, *s++);
  }

  return buffer_read(buf);
}

char *compile(char *source, list_t *required) {
  list_t *ctx = list_new();
  list_push(ctx, "top");

  table_t *ltab = table_new();
  list_t *lstk = list_new();
  list_t *sstk = list_new();
  list_t *lbl = list_new();
  LBPUSH();

  buffer_t *gbuf = buffer_new();
  buffer_t *buf = buffer_new();

  compile_into("const __QIC = \"" QIC_VERSION "\"", gbuf, buf, ctx, ltab, lstk,
               sstk, lbl);
  compile_into("macro E(x) {\n$set r E(x)\n$if r = nil\n$x\n$else\n$r\n$endif}",
               gbuf, buf, ctx, ltab, lstk, sstk, lbl);

  if (required && required->length)
    for (size_t i = 0; i < required->length; i++)
      if (require_once(gbuf, buf, ctx, ltab, lstk, sstk, lbl,
                       required->data[i]) < 0) {
        fprintf(
            stderr,
            "fatal: '%s' is not a valid file path or a builtin library name\n",
            (char *)required->data[i]);

        exit(1);
      }

  compile_into(source, gbuf, buf, ctx, ltab, lstk, sstk, lbl);

  buffer_t *rbuf = buffer_new();

  buffer_appends(rbuf, "#include <qirt.h>\n");

  if (DEBUG && DEBUGDATA->length) {
    buffer_fmt(rbuf, "static const char *__debugData[%d] = {\n",
               DEBUGDATA->length);

    for (size_t i = 0; i < DEBUGDATA->length; i++)
      buffer_fmt(rbuf, "\"%s\",\n", escape(DEBUGDATA->data[i]));

    buffer_fmt(rbuf, "};\n");
  }

  buffer_appendb(rbuf, HBUF);

  buffer_appendb(rbuf, gbuf);

  buffer_appends(rbuf, "int main(int argc, char **argv) {\n");
  buffer_appends(rbuf, "qi_state_t *state;\n");

  if (DEBUG)
    buffer_appends(rbuf, "qi_state_init_debug(&state);\n");
  else
    buffer_appends(rbuf, "qi_state_init(&state);\n");

  buffer_appends(rbuf, "qi_list_t *args = qi_list_make();\n");
  buffer_appends(rbuf, "for (int i = 0; i < argc; i++)\n");
  buffer_appends(rbuf,
                 "  qi_list_push(args, qi_make_string(state, argv[i]));\n");
  buffer_appends(
      rbuf, "qi_decl_const(state, \"ARGS\", qi_make_list(state, args));\n");
  buffer_appendb(rbuf, buf);
  buffer_appends(rbuf, "qi_old_scope(state);\n");
  buffer_appends(rbuf, "qi_finalize();\n");
  buffer_appends(rbuf, "return 0;\n");
  buffer_appends(rbuf, "}\n");

  return buffer_read(rbuf);
}

char *compile_file(char *filename, FILE *fd, list_t *required) {
  buffer_t *buf = buffer_new();

  for (;;) {
    char line[512];

    if (!fgets(line, sizeof(line), fd))
      break;

    buffer_appends(buf, line);
  }

  char *source = buffer_read(buf);

  list_t *pair = list_new();
  list_push(pair, filename);
  list_push(pair, source);

  list_push(FILES, pair);

  char *out = compile(source, required);

  list_pop(FILES);

  return out;
}

int main(int argc, char **argv) {
  YES = nodet(N_LITERAL, token(T_STRING, "yes"));

  DEBUGDATA = list_new();
  FUNCNAMES = list_new();

  FILES = list_new();
  REQUIRED = list_new();

  CONSTANTS = list_new();
  list_push(CONSTANTS, table_new());
  MACROS = list_new();
  list_push(MACROS, table_new());

  macro_stk = list_new();

  HBUF = buffer_new();
  MVARS = list_new();

  genmathlib();

  char *out;
  char *main = NULL;
  char *outf = NULL;
  list_t *required = NULL;
  int readstdin = 0;

  for (size_t i = 1; i < argc; i++) {
    if (*argv[i] == '-') {
      if (strcmp(argv[i], "-d") == 0 || strcmp(argv[i], "--debug") == 0)
        DEBUG = 1;
      else if (strcmp(argv[i], "-s") == 0 || strcmp(argv[i], "--stdin") == 0)
        readstdin = 1;
      else if (strcmp(argv[i], "-p") == 0 || strcmp(argv[i], "--prefix") == 0) {
        if (i + 1 >= argc) {
          fprintf(stderr,
                  "fatal: missing argument after '-p/--prefix' parameter\n");

          return 1;
        }

        PREFIX = argv[++i];
      } else if (strcmp(argv[i], "-o") == 0 ||
                 strcmp(argv[i], "--output") == 0) {
        if (i + 1 >= argc) {
          fprintf(stderr,
                  "fatal: missing argument after '-o/--output' parameter\n");

          return 1;
        }

        outf = argv[++i];
      } else if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "-?") == 0 ||
                 strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-v") == 0 ||
                 strcmp(argv[i], "--version") == 0) {
        fprintf(stderr, "qilang compiler, " QIC_VERSION "\n");
        fprintf(
            stderr,
            "usage: %s [-dsh] [-o out.c] [input0.qi input1.qi ... inputN.qi]\n",
            argv[0]);
        fprintf(stderr, "-h --help\tprint this message and exit\n");
        fprintf(stderr, "-d --debug\tenable debug mode\n");
        fprintf(stderr, "-s --stdin\tread stdin as input\n");
        fprintf(stderr,
                "-o --output\toutput generated C code to the specified file\n");

        return 0;
      } else {
        fprintf(stderr, "fatal: unknown commandline argument: '%s'\n", argv[i]);

        return 1;
      }

      continue;
    }

    if (!readstdin && !main)
      main = argv[i];
    else {
      if (!required)
        required = list_new();

      list_push(required, argv[i]);
    }
  }

  if (!PREFIX) {
    const char chars[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

    srand(time(NULL));

    PREFIX = malloc_checked(sizeof(char) * 9);
    PREFIX[8] = 0;

    for (size_t i = 0; i < 8; i++)
      PREFIX[i] =
          chars[(size_t)((double)rand() / RAND_MAX * (sizeof(chars) - 1))];
  }

  if (readstdin || !main)
    out = compile_file("<stdin>", stdin, required);
  else {
    FILE *fd = fopen(main, "rb");
    if (!fd) {
      fprintf(stderr, "fatal: unable to open file: '%s'\n", main);

      return 1;
    }

    list_push(REQUIRED, main);

    out = compile_file(main, fd, required);

    fclose(fd);
  }

  if (outf && strcmp(outf, "-") != 0) {
    FILE *fd = fopen(outf, "wb");
    if (!fd) {
      fprintf(stderr, "fatal: unable to open output file: '%s'\n", outf);

      return 1;
    }

    fwrite(out, sizeof(char), strlen(out), fd);

    fclose(fd);
  } else
    fwrite(out, sizeof(char), strlen(out), stdout);

  return 0;
}