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>

int fileno(FILE *stream);

static const char *LIBQIRT_INFO = "libqirt v01 " __DATE__;

typedef int qi_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;

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

qi_buffer_t *qi_buffer_make(void);
void qi_buffer_append(qi_buffer_t *buf, char c);
void qi_buffer_appendn(qi_buffer_t *buf, char *s, qi_size_t z);
void qi_buffer_append_str(qi_buffer_t *buf, char *s);
void qi_buffer_append_str_escaped(qi_buffer_t *buf, char *s);
char *qi_buffer_read(qi_buffer_t *buf);
char *qi_buffer_get(qi_buffer_t *buf);
void qi_buffer_destroy(qi_buffer_t *buf);

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

  QI_OBJECT
} qi_type_t;

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

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

typedef struct _qi_scope_t qi_scope_t;

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
  {
    qi_bool boolean;
    double number;
    char *string;
    qi_bytes_t *bytes;
    struct qi_file_t
    {
      FILE *fd;
      char mode[4];
      qi_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;

      qi_bool is_builtin;
      qi_bool is_pm;
    } function;
    struct
    {
      unsigned int tag;
      void *data;
    } data;
    struct
    {
      char *name;
      qi_scope_t *scope;
    } ref;
  } value;
};

#define QI_DEFAULT_RLIMIT 1000

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_value_t *listiterator;
  qi_value_t *typeerror;
  qi_value_t *valueerror;
  qi_value_t *indexerror;
  qi_value_t *keyerror;
  qi_value_t *recursionerror;
  qi_value_t *nameerror;
  qi_value_t *ioerror;

  qi_table_t *pseudomethods;
  void *pseudomethods_mutex;

  qi_table_t *intern_strs;
  void *intern_strs_mutex;

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

  qi_size_t rlimit;

  const char *_debug_data;
};

struct _qi_scope_t
{
  qi_table_t *scope;
  qi_list_t *defers;

  qi_bool is_barrier;
  qi_bool is_sticky;

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

  qi_bool is_constant;
};

#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_to_ref(state, x) (qi_cast((state), QI_REFERENCE, (x)))

#define qi_typeerror(state, format, ...) qi_throw_class((state), (state)->typeerror, (format), __VA_ARGS__)

#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_class((state), (state)->typeerror, "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); \
  }

#define qi_iter_begin(state, v) (qi_call((state), (qi_get_method((state), (v), "__begin")), qi_list_push(qi_list_make(), (v))))
#define qi_iter_end(state, v) (_qi_truthy((state), qi_call((state), (qi_get_method((state), (v), "__end")), qi_list_push(qi_list_make(), (v)))))
#define qi_iter_next(state, v) (qi_call((state), (qi_get_method((state), (v), "__next")), qi_list_push(qi_list_make(), (v))))

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);
qi_bool qi_list_insert(qi_list_t *list, qi_ssize_t index, void *value);
qi_bool qi_list_delete(qi_list_t *list, qi_ssize_t index);
qi_bool qi_list_set(qi_list_t *list, qi_ssize_t index, void *value);
void *qi_list_pop(qi_list_t *list);
qi_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);
qi_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);
qi_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_bool is_local);
#define qi_add_defer(state, index, defer) \
  (_qi_add_defer((state), (index), (defer), false))
#define qi_add_local_defer(state, index, defer) \
  (_qi_add_defer((state), (index), (defer), true))
qi_defer_t qi_pop_defer(qi_state_t *state, qi_ssize_t index);
void qi_new_scope(qi_state_t *state);
void qi_new_sticky_scope(qi_state_t *state);
qi_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_make_ref(qi_state_t *state, char *name);
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, qi_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,
               qi_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, ...);
void qi_throw_class(qi_state_t *state, qi_value_t *class, 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_decl_expr(qi_state_t *state, char *name, qi_value_t *value);
qi_value_t *_qi_set(qi_state_t *state, qi_bool is_pf, qi_bool is_constant,
                    char *name, qi_value_t *value);
qi_value_t *qi_deref(qi_state_t *state, qi_value_t *value);
qi_value_t *qi_set_ref(qi_state_t *state, qi_bool is_pf, qi_value_t *ref, 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);
qi_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_bool qi_is_iter(qi_state_t *state, 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, qi_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);
qi_bool _qi_equals(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_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);
qi_bool _qi_lt(qi_state_t *state, qi_value_t *a, qi_value_t *b);
qi_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_unary_plus(qi_state_t *state, qi_value_t *a);
qi_value_t *qi_bnot(qi_state_t *state, qi_value_t *a);
void qi_exit(qi_state_t *state, int code);
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);
qi_bool qi_thread_main(void);
void *qi_mutex_create(void);
void qi_mutex_destroy(void *mutex);
void qi_mutex_lock(void *mutex);
qi_bool qi_mutex_trylock(void *mutex);
void qi_mutex_unlock(void *mutex);
void *qi_cond_create(void);
void qi_cond_destroy(void *cond);
void qi_cond_wait(void *cond, void *mutex);
void qi_cond_signal(void *cond);
void qi_cond_broadcast(void *cond);
void qi_state_init(qi_state_t **state);
void qi_state_init_debug(qi_state_t **state);

#endif