format

qirt.c

@@ -555,7 +555,8 @@ static char *qi_buffer_read(qi_buffer_t *buf) {
   return buf->str;
 }
 
-void _qi_add_defer(qi_state_t *state, qi_ssize_t index, qi_defer_t defer, qi_bool is_local) {
+void _qi_add_defer(qi_state_t *state, qi_ssize_t index, qi_defer_t defer,
+                   qi_bool is_local) {
   if (qi_list_empty(state->scopes))
     return;
 
@@ -1344,7 +1345,8 @@ void qi_unset_trap(qi_state_t *state, qi_trap_t *trap) {
          i < k; i++)
       qi_old_scope(state);
 
-    for (size_t i = 0, k = qi_list_length(state->calltrace) - trap->calltrace_size;
+    for (size_t i = 0,
+                k = qi_list_length(state->calltrace) - trap->calltrace_size;
          i < k; i++)
       qi_list_pop(state->calltrace);
   }
@@ -1491,7 +1493,7 @@ qi_value_t *_qi_set(qi_state_t *state, qi_bool is_pf, qi_bool is_constant,
 
         qi_mutex_unlock(scope->mutex);
 
-        return !is_pf? old : value;
+        return !is_pf ? old : value;
       }
 
       qi_mutex_unlock(scope->mutex);
@@ -1508,8 +1510,7 @@ qi_value_t *_qi_set(qi_state_t *state, qi_bool is_pf, qi_bool is_constant,
     if (is_constant || symbol->is_constant) {
       qi_mutex_unlock(scope->mutex);
 
-      qi_throw_format(state, "redeclaration of constant symbol: '%s'",
-                      name);
+      qi_throw_format(state, "redeclaration of constant symbol: '%s'", name);
     }
 
     qi_value_t *old = symbol->value;
@@ -1518,7 +1519,7 @@ qi_value_t *_qi_set(qi_state_t *state, qi_bool is_pf, qi_bool is_constant,
 
     qi_mutex_unlock(scope->mutex);
 
-    return !is_pf? old : value;
+    return !is_pf ? old : value;
   }
 
   symbol = qi_malloc(sizeof(qi_symbol_t));
@@ -2094,7 +2095,8 @@ qi_value_t *qi_index_set(qi_state_t *state, qi_bool is_pf, qi_value_t *value,
   qi_bool fail = false;
 
   if (value->type == QI_TABLE && qi_has_metatable(value) &&
-      index->type == QI_STRING && qi_table_has(qi_get_metatable(value), index->value.string)) {
+      index->type == QI_STRING &&
+      qi_table_has(qi_get_metatable(value), index->value.string)) {
     qi_value_t *old;
 
     if (!is_pf)
@@ -2103,8 +2105,8 @@ qi_value_t *qi_index_set(qi_state_t *state, qi_bool is_pf, qi_value_t *value,
     qi_table_set(qi_get_metatable(value), index->value.string, newvalue);
 
     return !is_pf && old ? old : newvalue;
-  } else if ((meta = qi_call_meta(state, &fail, value, "__index_set", 3, value, index,
-                           newvalue)))
+  } else if ((meta = qi_call_meta(state, &fail, value, "__index_set", 3, value,
+                                  index, newvalue)))
     return meta;
 
   if (fail)
@@ -2171,7 +2173,8 @@ static qi_value_t *_qi_call(qi_state_t *state, qi_value_t *value,
   }
 
   if (qi_list_length(state->calltrace) >= state->rlimit)
-    qi_throw_format(state, "max. recursion depth limit reached (%zu)", state->rlimit);
+    qi_throw_format(state, "max. recursion depth limit reached (%zu)",
+                    state->rlimit);
 
   if (value->value.function._this) {
     qi_list_t *temp = !pargs ? qi_list_make() : qi_list_copy(pargs);
@@ -3405,8 +3408,7 @@ qi_value_t *qi_builtin_set_rlimit(qi_state_t *state, qi_size_t pargc,
   qi_value_t *a = qi_list_data(pargs, 0);
 
   if (a->type != QI_NUMBER)
-    qi_throw_format(state,
-                    "expected first argument to be: number, but got: %s",
+    qi_throw_format(state, "expected first argument to be: number, but got: %s",
                     _qi_type(state, a));
 
   state->rlimit = (size_t)a->value.number;

qirt.h

@@ -150,7 +150,6 @@ struct _qi_value_t {
   } value;
 };
 
-
 #define QI_DEFAULT_RLIMIT 1000
 
 struct _qi_state_t {
@@ -234,7 +233,7 @@ struct _qi_trap_t {
     if (setjmp(trap->label)) {                                                 \
       qi_unset_trap(state, trap);                                              \
       if (trap->finally)                                                       \
-        qi_add_local_defer(state, 0, trap->finally);                                 \
+        qi_add_local_defer(state, 0, trap->finally);                           \
       handle;                                                                  \
       if (trap->finally) {                                                     \
         qi_pop_defer(state, 0);                                                \
@@ -256,9 +255,9 @@ struct _qi_symbol_t {
   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)                                                \
@@ -340,11 +339,11 @@ struct _qi_symbol_t {
 
 #define LOCKED(value, code)                                                    \
   {                                                                            \
-    if ((value)->mutex)                                                         \
-      qi_mutex_lock((value)->mutex);                                          \
+    if ((value)->mutex)                                                        \
+      qi_mutex_lock((value)->mutex);                                           \
     code;                                                                      \
-    if ((value)->mutex)                                                         \
-      qi_mutex_unlock((value)->mutex);                                          \
+    if ((value)->mutex)                                                        \
+      qi_mutex_unlock((value)->mutex);                                         \
   }
 
 void *qi_malloc(qi_size_t size);
@@ -370,9 +369,12 @@ 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))
+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);
@@ -397,8 +399,8 @@ 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, qi_bool *fail_flag, qi_value_t *value,
-                         char *name, qi_size_t count, ...);
+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);