libqirt/qirt.h

#ifndef _QI_RUNTIME_H
#define _QI_RUNTIME_H

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

typedef int bool;
#define true 1
#define false 0

typedef unsigned long qi_size_t;
typedef long qi_ssize_t;

typedef struct _qi_list_t qi_list_t;

struct _qi_list_t {
  void **data;

  qi_size_t length;
};

#define qi_list_make_n(size) (qi_list_resize(qi_list_make(), (size)))
#define qi_list_data(list, index) ((list)->data[(index)])
#define qi_list_length(list) ((list)->length)
#define qi_list_empty(list) (!(list)->length)
#define qi_list_first(list) ((list)->data[0])
#define qi_list_last(list) ((list)->data[(list)->length - 1])

typedef struct _qi_table_t qi_table_t;
typedef struct _qi_table_entry_t qi_table_entry_t;

struct _qi_table_entry_t {
  char *key;
  void *value;

  bool is_deleted;
};

struct _qi_table_t {
  qi_table_entry_t *entries;

  qi_size_t used;
  qi_size_t capacity;
};

#define QI_TABLE_MIN_CAP 32

#define qi_table_length(table) ((table)->used)
#define qi_table_empty(table) ((table)->used == 0)
#define qi_table_iterate(table, code)                                          \
  {                                                                            \
    if (!qi_table_empty(table)) {                                              \
      qi_size_t i = 0;                                                         \
      while (i < (table)->capacity) {                                          \
        qi_table_entry_t entry = (table)->entries[i];                          \
        if (entry.key && !entry.is_deleted) {                                  \
          code;                                                                \
        }                                                                      \
        i++;                                                                   \
      }                                                                        \
    }                                                                          \
  }

typedef struct {
  char *str;

  qi_size_t used;
  qi_size_t allocated;
} qi_buffer_t;

typedef enum {
  QI_NULL,
  QI_BOOLEAN,
  QI_NUMBER,
  QI_STRING,
  QI_BYTES,
  QI_FILE,
  QI_LIST,
  QI_TUPLE,
  QI_TABLE,
  QI_FUNCTION,
  QI_DATA,

  QI_OBJECT
} qi_type_t;

static const char qi_type_names[12][10] = {
    "nil",  "boolean", "number", "string",   "bytes", "file",
    "list", "tuple",   "table",  "function", "data",  "object"};

#define qi_repr_type(type) (qi_type_names[(type)])

typedef struct _qi_state_t qi_state_t;
typedef struct _qi_value_t qi_value_t;

typedef qi_value_t *(*qi_handle_t)(qi_state_t *, qi_size_t, qi_list_t *);

typedef struct {
  unsigned char *data;
  qi_size_t size;
} qi_bytes_t;

struct _qi_value_t {
  qi_type_t type;
  void *mutex;

  union {
    bool boolean;
    double number;
    char *string;
    qi_bytes_t *bytes;
    struct qi_file_t {
      FILE *fd;
      char mode[4];
      bool is_open;
    } file;
    qi_list_t *list;
    struct {
      qi_table_t *table;
      qi_value_t *metatable;
    } table;
    struct qi_function_t {
      qi_handle_t handle;

      char *name;
      qi_size_t pargc;

      qi_table_t *captured;

      qi_value_t *_this;

      bool is_builtin;
      bool is_pm;
    } function;
    struct {
      unsigned int tag;
      void *data;
    } data;
  } value;
};

struct _qi_state_t {
  qi_value_t *nil;
  qi_value_t *_true;
  qi_value_t *_false;
  qi_value_t *zero;
  qi_value_t *one;
  qi_value_t *nan;
  qi_value_t *infinity;
  qi_value_t *ninfinity;
  qi_value_t *empty_string;
  qi_value_t *empty_bytes;
  qi_value_t *empty_tuple;
  qi_value_t *_stdin;
  qi_value_t *_stderr;
  qi_value_t *_stdout;
  qi_value_t *nnumbers[8];
  qi_value_t *numbers[256];

  qi_table_t *pseudomethods;
  void *pseudomethods_mutex;

  qi_table_t *intern_strs;
  void *intern_strs_mutex;

  qi_list_t *traps;
  qi_list_t *scopes;
  qi_list_t *calltrace;

  const char *_debug_data;
};

typedef struct _qi_scope_t qi_scope_t;

struct _qi_scope_t {
  qi_table_t *scope;
  qi_list_t *defers;

  bool is_barrier;

  void *mutex;
};

typedef void (*qi_defer_t)(qi_state_t *);

#define qi_has_metatable(obj) ((obj)->value.table.metatable->type == QI_TABLE)
#define qi_get_metatable(obj) ((obj)->value.table.metatable->value.table.table)
#define _is_meta_name(name) (strncmp((name), "__", 2) == 0)
#define is_meta_name(name)                                                     \
  ((name)->type == QI_STRING && _is_meta_name((name)->value.string))

#define qi_type(state, value)                                                  \
  (qi_make_string((state), _qi_type((state), (value))))
#define qi_repr(state, value, quote)                                           \
  (_qi_repr((state), qi_list_make(), (value), (quote)))
#define qi_show(state, value)                                                  \
  (qi_repr(state, value, (value)->type != QI_STRING))

typedef struct _qi_trap_t qi_trap_t;

struct _qi_trap_t {
  qi_value_t *value;

  qi_defer_t finally;

  qi_scope_t *scope;

  qi_size_t scopes_count;
  qi_size_t calltrace_size;

  jmp_buf label;
};

#define qi_try(state, code, handle, defer)                                     \
  {                                                                            \
    qi_trap_t *trap = qi_set_trap(state, defer);                               \
    if (setjmp(trap->label)) {                                                 \
      qi_unset_trap(state, trap);                                              \
      if (trap->finally)                                                       \
        qi_add_defer(state, 0, trap->finally);                                 \
      handle;                                                                  \
      if (trap->finally) {                                                     \
        qi_pop_defer(state, 0);                                                \
        trap->finally(state);                                                  \
      }                                                                        \
    } else {                                                                   \
      code;                                                                    \
      qi_unset_trap(state, trap);                                              \
      if (trap->finally)                                                       \
        trap->finally(state);                                                  \
    }                                                                          \
  }

typedef struct _qi_symbol_t qi_symbol_t;

struct _qi_symbol_t {
  qi_value_t *value;

  bool is_constant;
};

typedef struct _qi_lock_t qi_lock_t;

struct _qi_lock_t {
  bool locked;

  void *mutex;
  void *cond;
};

#define qi_set(state, is_pf, name, value)                                     \
  (_qi_set((state), is_pf, false, (name), (value)))
#define qi_bind(state, is_pf, name, value)                                    \
  (_qi_set((state), is_pf, true, (name), (value)))

#define qi_length(state, value)                                                \
  (qi_make_number((state), _qi_length((state), (value))))
#define qi_truthy(state, value)                                                \
  (qi_make_boolean((state), _qi_truthy((state), (value))))

#define qi_to_boolean(state, x) (qi_cast((state), QI_BOOLEAN, (x)))
#define qi_to_number(state, x) (qi_cast((state), QI_NUMBER, (x)))
#define qi_to_string(state, x) (qi_cast((state), QI_STRING, (x)))
#define qi_to_bytes(state, x) (qi_cast((state), QI_BYTES, (x)))
#define qi_to_list(state, x) (qi_cast((state), QI_LIST, (x)))
#define qi_to_tuple(state, x) (qi_cast((state), QI_TUPLE, (x)))
#define qi_to_table(state, x) (qi_cast((state), QI_TABLE, (x)))

#define qi_get_boolean(state, x)                                               \
  ((x)->type == QI_BOOLEAN ? (x)->value.boolean                                \
                           : qi_to_boolean(state, x)->value.boolean)
#define qi_get_number(state, x)                                                \
  ((x)->type == QI_NUMBER ? (x)->value.number                                  \
                          : qi_to_number(state, x)->value.number)
#define qi_get_string(state, x)                                                \
  ((x)->type == QI_STRING ? (x)->value.string                                  \
                          : qi_to_string(state, x)->value.string)
#define qi_get_bytes(state, x)                                                 \
  ((x)->type == QI_BYTES ? (x)->value.bytes                                    \
                         : qi_to_bytes(state, x)->value.bytes)
#define qi_get_list(state, x)                                                  \
  ((x)->type == QI_LIST ? (x)->value.list : qi_to_list(state, x)->value.list)
#define qi_get_table(state, x)                                                 \
  ((x)->type == QI_TABLE ? (x)->value.table.table                              \
                         : qi_to_table(state, x)->value.table.table)
#define qi_get_data(state, t, x)                                               \
  ((x)->type != QI_DATA || (x)->value.data.tag != (t)                          \
       ? (qi_throw_format((state), "expected data (tag: %d)", (t)), NULL)      \
       : (x)->value.data.data)

#define qi_push_trace(state, fn, debug_data)                                   \
  (qi_list_push((state)->calltrace,                                            \
                qi_list_push(qi_list_push(qi_list_make(), (value)),            \
                             (void *)(debug_data))))
#define qi_pop_trace(state) (qi_list_pop((state)->calltrace))

#define qi_equals(state, a, b)                                                 \
  (qi_make_boolean((state), _qi_equals((state), (a), (b))))
#define qi_not_equals(state, a, b)                                             \
  (qi_make_boolean((state), !_qi_equals((state), (a), (b))))
#define qi_is(state, a, b) (qi_make_boolean((state), (a) == (b)))
#define qi_not_is(state, a, b) (qi_make_boolean((state), (a) != (b)))

#define qi_in(state, a, b) (qi_make_boolean((state), _qi_in((state), (a), (b))))
#define qi_not_in(state, a, b)                                                 \
  (qi_make_boolean((state), !_qi_in((state), (a), (b))))

#define qi_lt(state, a, b) (qi_make_boolean((state), _qi_lt((state), (a), (b))))
#define qi_gt(state, a, b) (qi_make_boolean((state), _qi_gt((state), (a), (b))))

#define _qi_le(state, a, b)                                                    \
  (_qi_equals((state), (a), (b)) || _qi_lt((state), (a), (b)))
#define _qi_ge(state, a, b)                                                    \
  (_qi_equals((state), (a), (b)) || _qi_gt((state), (a), (b)))
#define qi_le(state, a, b) (qi_make_boolean((state), _qi_le((state), (a), (b))))
#define qi_ge(state, a, b) (qi_make_boolean((state), _qi_ge((state), (a), (b))))

#define _qi_or(state, a, b)                                                    \
  (_qi_truthy((state), (a)) || _qi_truthy((state), (b)))
#define qi_or(state, a, b) (qi_make_boolean((state), _qi_or((state), (a), (b))))
#define _qi_and(state, a, b)                                                   \
  (_qi_truthy((state), (a)) && _qi_truthy((state), (b)))
#define qi_and(state, a, b)                                                    \
  (qi_make_boolean((state), _qi_and((state), (a), (b))))

#define _qi_not(state, a) (!_qi_truthy((state), (a)))
#define qi_not(state, a) (qi_make_boolean((state), _qi_not((state), (a))))

#define qi_add_builtin(state, name, pargc, handle)                             \
  (qi_decl_const((state), name,                                                \
                 qi_make_builtin_function(state, name, pargc, handle)))

#define LOCKED(value, code)                                                    \
  {                                                                            \
    if ((value)->mutex)                                                         \
      qi_mutex_lock((value)->mutex);                                          \
    code;                                                                      \
    if ((value)->mutex)                                                         \
      qi_mutex_unlock((value)->mutex);                                          \
  }

void *qi_malloc(qi_size_t size);
void *qi_malloc_atomic(qi_size_t size);
void *qi_realloc(void *old_ptr, qi_size_t size);
void *qi_calloc(qi_size_t count, qi_size_t size);
char *qi_strdup(const char *s);
void qi_free(void *);
qi_list_t *qi_list_make(void);
qi_list_t *qi_list_resize(qi_list_t *list, qi_size_t size);
void *qi_list_index(qi_list_t *list, qi_ssize_t index);
qi_list_t *qi_list_push(qi_list_t *list, void *value);
bool qi_list_insert(qi_list_t *list, qi_ssize_t index, void *value);
bool qi_list_delete(qi_list_t *list, qi_ssize_t index);
bool qi_list_set(qi_list_t *list, qi_ssize_t index, void *value);
void *qi_list_pop(qi_list_t *list);
bool qi_list_contains(qi_list_t *list, void *value);
qi_list_t *qi_list_copy(qi_list_t *list);
qi_table_t *qi_table_make(void);
void *qi_table_get(qi_table_t *table, char *key);
bool qi_table_has(qi_table_t *table, char *key);
qi_table_t *qi_table_set(qi_table_t *table, char *key, void *value);
qi_list_t *qi_table_keys(qi_table_t *table);
bool qi_table_delete(qi_table_t *table, char *key);
qi_table_t *qi_table_copy(qi_table_t *table);
void qi_add_defer(qi_state_t *state, qi_ssize_t index, qi_defer_t defer);
qi_defer_t qi_pop_defer(qi_state_t *state, qi_ssize_t index);
void qi_new_scope(qi_state_t *state);
bool qi_old_scope(qi_state_t *state);
qi_value_t *qi_make_value(qi_type_t type);
#define qi_make_boolean(state, x) ((x) ? (state)->_true : (state)->_false)
qi_value_t *qi_make_number(qi_state_t *state, double number);
qi_value_t *qi_make_string(qi_state_t *state, char *string);
qi_value_t *qi_make_string_copy(qi_state_t *state, char *string);
qi_value_t *qi_make_bytes(qi_state_t *state, unsigned char *bytes,
                          qi_size_t size);
qi_value_t *qi_make_char(qi_state_t *state, char c);
qi_value_t *qi_make_file(qi_state_t *state, FILE *file, char *mode);
qi_value_t *qi_make_list(qi_state_t *state, qi_list_t *list);
qi_value_t *qi_make_tuple(qi_state_t *state, qi_list_t *tuple);
qi_value_t *qi_make_table(qi_state_t *state, qi_table_t *table);
qi_value_t *qi_make_function(qi_state_t *state, char *name, qi_size_t pargc,
                             qi_handle_t handle, qi_table_t *captured);
qi_value_t *qi_make_builtin_function(qi_state_t *state, char *name,
                                     qi_size_t pargc, qi_handle_t handle);
qi_value_t *qi_make_data(qi_state_t *state, unsigned int tag, void *data);
qi_value_t *qi_add_pseudomethod(qi_state_t *state, char *name, qi_size_t pargc,
                                qi_handle_t handle);
qi_value_t *qi_get_method(qi_state_t *state, qi_value_t *value, char *name);
qi_value_t *qi_call_meta(qi_state_t *state, bool *fail_flag, qi_value_t *value,
                         char *name, qi_size_t count, ...);
char *_qi_type(qi_state_t *state, qi_value_t *value);
char *_qi_repr(qi_state_t *state, qi_list_t *tempstack, qi_value_t *value,
               bool quote);
void qi_finalize(void);
void qi_fatal(qi_state_t *state, char *format, ...);
qi_trap_t *qi_set_trap(qi_state_t *state, qi_defer_t finally);
void qi_unset_trap(qi_state_t *state, qi_trap_t *trap);
void qi_throw(qi_state_t *state, qi_value_t *value);
void qi_throw_format(qi_state_t *state, char *format, ...);
qi_value_t *qi_find(qi_state_t *state, char *name);
qi_value_t *qi_get(qi_state_t *state, char *name);
void qi_decl_const(qi_state_t *state, char *name, qi_value_t *value);
void qi_decl(qi_state_t *state, char *name, qi_value_t *value);
qi_value_t *_qi_set(qi_state_t *state, bool is_pf, bool is_constant,
                    char *name, qi_value_t *value);
size_t _qi_length(qi_state_t *state, qi_value_t *value);
qi_value_t *qi_del(qi_state_t *state, qi_value_t *value, qi_value_t *index);
bool _qi_truthy(qi_state_t *state, qi_value_t *value);
qi_value_t *qi_cast(qi_state_t *state, qi_type_t type, qi_value_t *value);
qi_value_t *qi_iter(qi_state_t *state, qi_value_t *value);
qi_value_t *qi_index(qi_state_t *state, qi_value_t *value, qi_value_t *index);
qi_value_t *qi_index_set(qi_state_t *state, bool is_pf, qi_value_t *value,
                         qi_value_t *index, qi_value_t *newvalue);
qi_value_t *qi_call(qi_state_t *state, qi_value_t *value, qi_list_t *pargs);
qi_value_t *qi_call_debug(qi_state_t *state, qi_value_t *value,
                          qi_list_t *pargs, const char *debug_data);
bool _qi_equals(qi_state_t *state, qi_value_t *a, qi_value_t *b);
bool _qi_in(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_value_t *qi_add(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_value_t *qi_sub(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_value_t *qi_mul(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_value_t *qi_div(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_value_t *qi_idiv(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_value_t *qi_mod(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_value_t *qi_pow(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_value_t *qi_band(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_value_t *qi_bor(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_value_t *qi_xor(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_value_t *qi_shl(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_value_t *qi_shr(qi_state_t *state, qi_value_t *a, qi_value_t *b);
bool _qi_lt(qi_state_t *state, qi_value_t *a, qi_value_t *b);
bool _qi_gt(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_value_t *qi_negate(qi_state_t *state, qi_value_t *a);
qi_value_t *qi_bnot(qi_state_t *state, qi_value_t *a);
void *qi_thread_create(qi_state_t *state, qi_value_t *fn, qi_list_t *args);
qi_value_t *qi_thread_join(qi_state_t *state, void *td);
void qi_thread_exit(qi_state_t *state, qi_value_t *value);
bool qi_thread_main(void);
void *qi_mutex_create(void);
void qi_mutex_destroy(void *mutex);
void qi_mutex_lock(void *mutex);
bool qi_mutex_trylock(void *mutex);
void qi_mutex_unlock(void *mutex);
qi_lock_t *qi_lock_create(void);
void qi_lock_destroy(qi_lock_t *lock);
void qi_lock_acquire(qi_lock_t *lock);
bool qi_lock_tryacquire(qi_lock_t *lock);
bool qi_lock_acquired(qi_lock_t *lock);
void qi_lock_release(qi_lock_t *lock);
void qi_state_init(qi_state_t **state);
void qi_state_init_debug(qi_state_t **state);

#endif