qic/qic.c

#include <time.h>
#include <ctype.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.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;
}

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

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_NAME,

    T_VAR,
    T_LET,
    T_CONST,
    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_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_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 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) {
  char term = source[(*pos)++];

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

        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:
          buffer_append(text, nc);
          break;
      }

      continue;
    }

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

    buffer_append(text, c);
  }

  (*pos)++;

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

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);
  else if (source[*pos] == 'f' && (source[(*pos)+1] == '"' || source[(*pos)+1] == '\'' || source[(*pos)+1] == '`')) {
    (*pos)++;

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

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

    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 (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_NOT,
    N_NEGATE,
    N_UNARY_PLUS,
    N_BNOT,

    N_LITERAL,
    N_LIST,
    N_LISTGEN,
    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_EQUALS,
    N_NOTEQUALS,
    N_IS,
    N_IN,
    N_NOTIS,
    N_NOTIN,

    N_LT,
    N_GT,
    N_LE,
    N_GE,

    N_INC,
    N_DEC,

    N_IFEXPR,
    N_FUNCEXPR,

    N_LOGOR,
    N_LOGAND,

    N_EXPRS_END,

    N_STAR,

    N_VAR,
    N_LET,
    N_VARUNPACK,
    N_LETUNPACK,
    N_CONST,
    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_INLINE,
    N_HEADER,
    N_INCLUDE,

    N_BUFFER,

    N_MACRO_CALL,
    N_MVAR,

    N_MIF,
    N_MSET,
    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;

  int flag;
};
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 *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 {
  list_t *params;
  list_t *body;
  int variable;
} macro_t;

table_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(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)) {
      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");

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

        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)) {
    table_t *table = table_new();

    do {
      if (AT(RCB))
        break;

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

      int is_str = AT(STRING);

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

      EXPECT(COLON, ":");

      node_t *val = parse_expr(tokens, pos);

      table_set(table, is_str? unescape(key): key, val);
    } while (MATCH(COMMA));

    EXPECT(RCB, "}");

    return NODEH(TABLE, table);
  } else if (MATCH(NUMBER) || MATCH(STRING) || MATCH(FSTRING) || MATCH(NAME))
    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);

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

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

  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(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_block(list_t *tokens, size_t *pos) {
  EXPECT(LCB, "{");

  list_t *stmts = list_new();
  while (!AT(EOF) && !AT(RCB)) {
    list_push(stmts, parse_stmt(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_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) {
  if (MATCH(LCB)) {
    list_t *stmts = list_new();

    while (!AT(EOF) && !AT(RCB)) {
      node_t *n = parse_stmt(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(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_expr(tokens, pos);
        EXPECT(SEMI, ";");
        c = parse_expr(tokens, pos);
      } else a = parse_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(RCB) && !AT(EOF) && !CLIFF)
      a = parse_expr(tokens, pos);

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

    EXPECT(LCB, "{");

    list_t *triples = list_new();

    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(INLINE)) {
    if (!AT(STRING))
      PARSE_ERROR("expected string");

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

    return NODET(INLINE, t);
  }

  node_t *n = parse_expr(tokens, pos);
  if (n->tag == N_MVAR) {
    n->flag = 1;

    return n;
  }

  return NODE1(EXPRSTMT, n);
}

#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 (MATCH(LPAR)) {
    node_t *a = parse_mexpr(tokens, pos);

    EXPECT(RPAR, ")");

    return a;
  } else if (MATCH(NAME)) {
    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(ASSIGN)) {
      node_t *b = parse_mprimary(tokens, pos);

      a = NODE2(EQUALS, 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));

    MATCH(SEMI);
  }

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

      MATCH(SEMI);
    }
  }

  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("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("$")) {
    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));

  PARSE_ERROR("expected m-statement");

  return NULL;
}

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))
          PARSE_ERROR("expected string");

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

          MATCH(SEMI);
        }

        EXPECT(RCB, "}");
      }

      list_t *ms = table_get(MACROS, name);
      if (!ms) {
        ms = list_new();

        table_set(MACROS, name, ms);
      }

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

      list_push(ms, m);
    } else { n = parse_stmt(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) {\
  if ((lhs)->tag == N_LITERAL && (lhs)->t->tag == T_NAME) {\
    buffer_fmt(buf, "qi_set(state, false, \"%s\", ", (lhs)->t->text);\
    rhs;\
    buffer_fmt(buf, ")");\
  } else if ((lhs)->tag == N_INDEX) {\
    buffer_fmt(buf, "qi_index_set(state, false, ");\
    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, false, ");\
    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)
#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 COMPILE_ERROR(fmt, ...) { format_error(GETFNAME(node->fi), GETSRC(node->fi), node->pos, fmt, ##__VA_ARGS__); exit(1); }

void compile_node(buffer_t *gbuf, buffer_t *buf, list_t *ctx, table_t *ltab, int_stack_t *lstk, int_stack_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, int_stack_t *lstk, int_stack_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, int_stack_t *lstk, int_stack_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);
}

#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) stack_push(lstk, (i))
#define LPOP() stack_pop(lstk)
#define LID (lstk->data[lstk->length-1])

#define SPUSH(i) stack_push(sstk, (i))
#define SPOP() stack_pop(sstk)
#define SID (sstk->data[sstk->length-1])

#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, int_stack_t *lstk, int_stack_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(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(), stack_new(), stack_new(), lbl, node->a);

  list_pop(FUNCNAMES);
  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;
}

void compile_block(buffer_t *gbuf, buffer_t *buf, list_t *ctx, table_t *ltab, int_stack_t *lstk, int_stack_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_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();

      size_t *n = malloc_checked(sizeof(size_t));
      memcpy(n, &gid, sizeof(size_t));

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

  for (size_t i = 0; i < block->length; i++) {
    node_t *n = block->data[i];
    if (n->tag == N_CONST || 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] = {
  {"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"
  },

  {"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 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"
    "  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;

        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, int_stack_t *lstk, int_stack_t *sstk, list_t *lbl);

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

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

      break;
    }
  }

  if (is_required(path))
    return 1;

  if (!source) {
    FILE *fd = fopen(path, "rb");
    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_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 *mf_isExpr(list_t *t) {
  if (t->length != 1)
    return NULL;

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

  return a->tag > N_EXPRS_BEGIN && a->tag < N_EXPRS_END? 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 (!t->data[i])
      return NULL;

  return nodel(N_LIST, 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 (!(b->tag > N_EXPRS_BEGIN && b->tag < N_EXPRS_END))
      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;
}

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

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

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

  { NULL, NULL }
};

macro_t *find_macro(char *name, size_t argc, int *res) {
  list_t *ms = table_get(MACROS, 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;
}

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

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_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_EQUALS: {
      node_t *a = run_mexpr(node->a);
      node_t *b = run_mexpr(node->b);

      return mexpr_equals(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_MSET:
      table_set(list_index(MVARS, -1), node->t->text, run_mexpr(node->a));
      break;

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

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

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

  return r;
}

node_t *run_macro(macro_t *macro, list_t *args) {
  table_t *mvars = list_index(MVARS, -1);
  table_set(mvars, "nil", NULL);

  if (macro->variable)
    table_set(mvars, "*", nodel(N_LIST, args));
  else 
    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;
  }

  return r;
}

void compile_macro_call(buffer_t *gbuf, buffer_t *buf, list_t *ctx, table_t *ltab, int_stack_t *lstk, int_stack_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());

  node_t *r = run_macro(m, node->l);

  if (r) {
    if (expr && !(r->tag > N_EXPRS_BEGIN && r->tag < N_EXPRS_END))
      COMPILE_ERROR("macro '%s' expanded to non-expression in expression context", name);

    if (!expr && r->tag > N_EXPRS_BEGIN && r->tag < N_EXPRS_END)
      r = node1(N_EXPRSTMT, r);

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

  list_pop(MVARS);
}

void compile_node(buffer_t *gbuf, buffer_t *buf, list_t *ctx, table_t *ltab, int_stack_t *lstk, int_stack_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_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());
      EMIT("qi_new_scope(state);\n");
      compile_block(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->l);
      EMIT("qi_old_scope(state);");
      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 = 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_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;

        default:
          COMPILE_ERROR("not yet implemented");
      }
      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();

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

      buffer_fmt(tbuf, "return qi_make_list(state, list);\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_table(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->h);
      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_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++) {
          ASSIGNIN(tbuf, (node_t *)node->a->l->data[i], buffer_fmt(tbuf, "qi_index(state, %s, qi_make_number(state, %d))", varname, i));
          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];

          ASSIGNIN(tbuf, (node_t *)node->a->l->data[i], buffer_fmt(tbuf, "%s", varname));
          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;
      }

      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_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:break;

    case N_IF:
      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("}");
      break;

    case N_SWITCH: {
      NEWGID();

      if (node->t2) {
        if (table_get(ltab, node->t2->text))
          COMPILE_ERROR("redeclaration of loop label: '%s'", node->t2->text);

        int_stack_t *pair = stack_new();

        stack_push(pair, 1);
        stack_push(pair, gid);

        table_set(ltab, node->t2->text, pair);
      }

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

      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);
        } else {
          EMIT("%s:;\n", label);
        }

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

      CTXPOP();
      SPOP();

      EMIT("__break%d:;\n", gid);
      } break;

    case N_FOR: {
      NEWGID();

      if (node->t2) {
        if (table_get(ltab, node->t2->text))
          COMPILE_ERROR("redeclaration of loop label: '%s'", node->t2->text);

        int_stack_t *pair = stack_new();

        stack_push(pair, 0);
        stack_push(pair, gid);

        table_set(ltab, node->t2->text, pair);
      }

      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 {
        compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
        EMIT("while (_qi_truthy(state, ");
        compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b);
        EMIT(")) {\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();
     
      EMIT("}\n");

      EMIT("__break%d:;\n", gid);
      } break;

    case N_FOROF: case N_FOROFVAR: case N_FOROFUNPACK: case N_FOROFVARUNPACK: {
      NEWGID();

      if (node->t2) {
        if (table_get(ltab, node->t2->text))
          COMPILE_ERROR("redeclaration of loop label: '%s'", node->t2->text);

        int_stack_t *pair = stack_new();

        stack_push(pair, 0);
        stack_push(pair, gid);

        table_set(ltab, node->t2->text, pair);
      }

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

      LPUSH(gid);
      CTXPUSH("for");
      compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->b);
      CTXPOP();
      LPOP();

      EMIT("__continue%d:;\n", gid);
      EMIT("}\n");

      EMIT("__break%d:;\n", gid);
      } 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);

          EMIT("goto __break%d;", lstk->data[lstk->length-offset]);
        } else {
          char *label = node->t->text;

          int_stack_t *pair = table_get(ltab, label);

          if (!pair)
            COMPILE_ERROR("undefined loop label: '%s'", label);

          EMIT("goto __break%d;", pair->data[1]);
        }
        
        break;
      }

      EMIT("goto __break%d;", in_switch(ctx)? SID: LID);
      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);

          EMIT("goto __continue%d;", lstk->data[lstk->length-offset]);
        } else {
          char *label = node->t->text;

          int_stack_t *pair = table_get(ltab, label);

          if (pair->data[1])
            COMPILE_ERROR("continue on a switch loop label: '%s'", label);

          if (!pair)
            COMPILE_ERROR("undefined loop label: '%s'", label);

          EMIT("goto __continue%d;", pair->data[1]);
        }
        
        break;
      }

      EMIT("goto __continue%d;", LID);
      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());
      compile_node(gbuf, tbuf, ctx, table_new(), stack_new(), stack_new(), lbl, node->a);
      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");

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

      if (node->a)
        compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
      else EMIT("state->nil");

      EMIT(";");
      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_TRY:
      EMIT("qi_try(state, {\n");
      LBPUSH();
      CTXPUSH("gap");
      CTXPUSH("trap");
      compile_node(gbuf, buf, ctx, table_new(), stack_new(), stack_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(), stack_new(), stack_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(), stack_new(), stack_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:
      EMIT("qi_throw(state, ");
      if (node->a)
        compile_node(gbuf, buf, ctx, ltab, lstk, sstk, lbl, node->a);
      else {
        EMIT("state->nil");
      }
      EMIT(");");
      break;

    case N_LABEL: {
      size_t *gid = table_get(list_index(lbl, -1), node->t->text);

      EMIT("__label%d:;", *gid);
      } break;

    case N_GOTO: {
      char *label = node->t->text;
      size_t *gid = table_get(list_index(lbl, -1), label);
      if (!gid)
        COMPILE_ERROR("undefined label: '%s'", label);

      EMIT("goto __label%d;", *gid);
      } 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_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: {
      if (!MVARS->length)
        COMPILE_ERROR("macro variable outside of a macro");

      table_t *mvars = list_index(MVARS, -1);
      node_t *n = table_get(mvars, node->t->text);

      if (!n)
        COMPILE_ERROR("undefined macro variable: '%s'", node->t);

      if (node->flag)
        n = node1(N_EXPRSTMT, n);

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

    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, int_stack_t *lstk, int_stack_t *sstk, list_t *lbl) {
  node_t *n = parse(source);

  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();
  table_t *ltab = table_new();
  int_stack_t *lstk = stack_new();
  int_stack_t *sstk = stack_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);

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

  HBUF = buffer_new();
  MVARS = list_new();

  MACROS = table_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;
}