upd

qirt.h

@@ -24,7 +24,8 @@ typedef long qi_ssize_t;
 
 typedef struct _qi_list_t qi_list_t;
 
-struct _qi_list_t {
+struct _qi_list_t
+{
   void **data;
 
   qi_size_t length;
@@ -40,14 +41,16 @@ struct _qi_list_t {
 typedef struct _qi_table_t qi_table_t;
 typedef struct _qi_table_entry_t qi_table_entry_t;
 
-struct _qi_table_entry_t {
+struct _qi_table_entry_t
+{
   char *key;
   void *value;
 
   qi_bool is_deleted;
 };
 
-struct _qi_table_t {
+struct _qi_table_t
+{
   qi_table_entry_t *entries;
 
   qi_size_t used;
@@ -58,28 +61,33 @@ struct _qi_table_t {
 
 #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++;                                                                   \
-      }                                                                        \
-    }                                                                          \
+#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 {
+typedef struct
+{
   char *str;
 
   qi_size_t used;
   qi_size_t allocated;
 } qi_buffer_t;
 
-typedef enum {
+typedef enum
+{
   QI_NULL,
   QI_BOOLEAN,
   QI_NUMBER,
@@ -97,8 +105,8 @@ typedef enum {
 } qi_type_t;
 
 static const char qi_type_names[13][10] = {
-    "nil",  "boolean", "number", "string",   "bytes", "file",
-    "list", "tuple",   "table",  "function", "data", "reference", "object"};
+    "nil", "boolean", "number", "string", "bytes", "file",
+    "list", "tuple", "table", "function", "data", "reference", "object"};
 
 #define qi_repr_type(type) (qi_type_names[(type)])
 
@@ -109,31 +117,37 @@ 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 {
+typedef struct
+{
   unsigned char *data;
   qi_size_t size;
 } qi_bytes_t;
 
-struct _qi_value_t {
+struct _qi_value_t
+{
   qi_type_t type;
   void *mutex;
 
-  union {
+  union
+  {
     qi_bool boolean;
     double number;
     char *string;
     qi_bytes_t *bytes;
-    struct qi_file_t {
+    struct qi_file_t
+    {
       FILE *fd;
       char mode[4];
       qi_bool is_open;
     } file;
     qi_list_t *list;
-    struct {
+    struct
+    {
       qi_table_t *table;
       qi_value_t *metatable;
     } table;
-    struct qi_function_t {
+    struct qi_function_t
+    {
       qi_handle_t handle;
 
       char *name;
@@ -146,11 +160,13 @@ struct _qi_value_t {
       qi_bool is_builtin;
       qi_bool is_pm;
     } function;
-    struct {
+    struct
+    {
       unsigned int tag;
       void *data;
     } data;
-    struct {
+    struct
+    {
       char *name;
       qi_scope_t *scope;
     } ref;
@@ -159,7 +175,8 @@ struct _qi_value_t {
 
 #define QI_DEFAULT_RLIMIT 1000
 
-struct _qi_state_t {
+struct _qi_state_t
+{
   qi_value_t *nil;
   qi_value_t *_true;
   qi_value_t *_false;
@@ -202,7 +219,8 @@ struct _qi_state_t {
   const char *_debug_data;
 };
 
-struct _qi_scope_t {
+struct _qi_scope_t
+{
   qi_table_t *scope;
   qi_list_t *defers;
 
@@ -217,19 +235,20 @@ 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)                                                     \
+#define is_meta_name(name) \
   ((name)->type == QI_STRING && _is_meta_name((name)->value.string))
 
-#define qi_type(state, value)                                                  \
+#define qi_type(state, value) \
   (qi_make_string((state), _qi_type((state), (value))))
-#define qi_repr(state, value, quote)                                           \
+#define qi_repr(state, value, quote) \
   (_qi_repr((state), qi_list_make(), (value), (quote)))
-#define qi_show(state, value)                                                  \
+#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 {
+struct _qi_trap_t
+{
   qi_value_t *value;
 
   qi_defer_t finally;
@@ -242,42 +261,47 @@ struct _qi_trap_t {
   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);                                                  \
-    }                                                                          \
+#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 {
+struct _qi_symbol_t
+{
   qi_value_t *value;
 
   qi_bool is_constant;
 };
 
-#define qi_set(state, is_pf, name, value)                                      \
+#define qi_set(state, is_pf, name, value) \
   (_qi_set((state), is_pf, false, (name), (value)))
-#define qi_bind(state, is_pf, name, value)                                     \
+#define qi_bind(state, is_pf, name, value) \
   (_qi_set((state), is_pf, true, (name), (value)))
 
-#define qi_length(state, value)                                                \
+#define qi_length(state, value) \
   (qi_make_number((state), _qi_length((state), (value))))
-#define qi_truthy(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)))
@@ -289,77 +313,79 @@ struct _qi_symbol_t {
 #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_get_boolean(state, x)                                               \
-  ((x)->type == QI_BOOLEAN ? (x)->value.boolean                                \
+#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                                  \
+#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                                  \
+#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                                    \
+#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)                                                  \
+#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                              \
+#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)      \
+#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)),            \
+#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)                                                 \
+#define qi_equals(state, a, b) \
   (qi_make_boolean((state), _qi_equals((state), (a), (b))))
-#define qi_not_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)                                                 \
+#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)                                                    \
+#define _qi_le(state, a, b) \
   (_qi_equals((state), (a), (b)) || _qi_lt((state), (a), (b)))
-#define _qi_ge(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)                                                    \
+#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)                                                   \
+#define _qi_and(state, a, b) \
   (_qi_truthy((state), (a)) && _qi_truthy((state), (b)))
-#define qi_and(state, a, 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,                                                \
+#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 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))))
@@ -391,9 +417,9 @@ 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)                                      \
+#define qi_add_defer(state, index, defer) \
   (_qi_add_defer((state), (index), (defer), false))
-#define qi_add_local_defer(state, index, defer)                                \
+#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);

std.qi

@@ -44,6 +44,7 @@ class KeyError(Error)
 class RecursionError(Error)
 class NameError(Error)
 class IOError(Error)
+func isinstance(a, b): return type(a) == type(b)
 func head(l): return l[0]
 func tail(l): return slice(l, 1)
 func min(x, y): x < y? x: y