format

qirt.c

@@ -115,7 +115,7 @@ qi_bool qi_list_insert(qi_list_t *list, qi_ssize_t index, void *value) {
 
   qi_list_resize(list, qi_list_length(list) + 1);
 
-  for (qi_size_t i = qi_list_length(list); index == 0? i > 0: i >= index; i--)
+  for (qi_size_t i = qi_list_length(list); index == 0 ? i > 0 : i >= index; i--)
     qi_list_data(list, i) = qi_list_data(list, i - 1);
 
   qi_list_data(list, index) = value;
@@ -627,12 +627,10 @@ static qi_bool _qi_old_scope(qi_state_t *state, qi_bool ignore_barriers) {
   return true;
 }
 
-qi_bool qi_old_scope(qi_state_t *state) {
-  return _qi_old_scope(state, false);
-}
+qi_bool qi_old_scope(qi_state_t *state) { return _qi_old_scope(state, false); }
 
-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, ...);
 
 void qi_value_finalizer(GC_PTR _value, GC_PTR _state) {
   qi_state_t *state = (qi_state_t *)_state;
@@ -767,7 +765,7 @@ 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 *value = qi_make_value(QI_LIST);
   value->mutex = qi_mutex_create();
-  value->value.list = !list? qi_list_make(): list;
+  value->value.list = !list ? qi_list_make() : list;
 
   GC_register_finalizer(value, qi_value_finalizer, (void *)state, NULL, NULL);
 
@@ -789,7 +787,7 @@ 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 *value = qi_make_value(QI_TABLE);
   value->mutex = qi_mutex_create();
-  value->value.table.table = !table? qi_table_make(): table;
+  value->value.table.table = !table ? qi_table_make() : table;
   value->value.table.metatable = state->nil;
 
   GC_register_finalizer(value, qi_value_finalizer, (void *)state, NULL, NULL);
@@ -879,8 +877,8 @@ qi_value_t *qi_get_method(qi_state_t *state, qi_value_t *value, char *name) {
   return method;
 }
 
-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, ...) {
   qi_value_t *meta = qi_get_method(state, value, name);
   if (!meta)
     return NULL;
@@ -1120,8 +1118,9 @@ char *_qi_repr(qi_state_t *state, qi_list_t *tempstack, qi_value_t *value,
       qi_buffer_append(buffer, '[');
 
       for (qi_size_t i = 0; i < qi_list_length(value->value.list); i++) {
-        qi_buffer_append_str(buffer,
-                             _qi_repr(state, tempstack, qi_list_data(value->value.list, i), true));
+        qi_buffer_append_str(
+            buffer, _qi_repr(state, tempstack,
+                             qi_list_data(value->value.list, i), true));
 
         if (i != qi_list_length(value->value.list) - 1)
           qi_buffer_append_str(buffer, ", ");
@@ -1146,14 +1145,16 @@ char *_qi_repr(qi_state_t *state, qi_list_t *tempstack, qi_value_t *value,
     qi_buffer_append(buffer, '(');
 
     if (qi_list_length(value->value.list) == 1) {
-      qi_buffer_append_str(buffer,
-                           _qi_repr(state, tempstack, qi_list_first(value->value.list), true));
+      qi_buffer_append_str(
+          buffer,
+          _qi_repr(state, tempstack, qi_list_first(value->value.list), true));
 
       qi_buffer_append_str(buffer, ", ");
     } else
       for (qi_size_t i = 0; i < qi_list_length(value->value.list); i++) {
-        qi_buffer_append_str(buffer,
-                             _qi_repr(state, tempstack, qi_list_data(value->value.list, i), true));
+        qi_buffer_append_str(
+            buffer, _qi_repr(state, tempstack,
+                             qi_list_data(value->value.list, i), true));
 
         if (i != qi_list_length(value->value.list) - 1)
           qi_buffer_append_str(buffer, ", ");
@@ -1267,8 +1268,7 @@ void qi_fatal(qi_state_t *state, char *format, ...) {
         fprintf(stderr, "  %s, call to %s\n", debug_data,
                 func->value.function.name);
       else
-        fprintf(stderr, "  Call to %s\n",
-                func->value.function.name);
+        fprintf(stderr, "  Call to %s\n", func->value.function.name);
     }
   }
 
@@ -1550,9 +1550,8 @@ qi_value_t *qi_del(qi_state_t *state, qi_value_t *value, qi_value_t *index) {
     if (index->type == QI_NUMBER) {
       qi_bool res;
 
-      LOCKED(value, {
-        res = qi_list_delete(value->value.list, index->value.number);
-      });
+      LOCKED(value,
+             { res = qi_list_delete(value->value.list, index->value.number); });
 
       if (!res)
         qi_throw_format(state, "list index out of range: %s",
@@ -1582,8 +1581,8 @@ qi_value_t *qi_del(qi_state_t *state, qi_value_t *value, qi_value_t *index) {
   }
 
 leave:
-  qi_throw_format(state, "cannot delete index %s with %s", _qi_type(state, value),
-                  _qi_type(state, index));
+  qi_throw_format(state, "cannot delete index %s with %s",
+                  _qi_type(state, value), _qi_type(state, index));
 
   return NULL;
 }
@@ -1707,8 +1706,10 @@ qi_value_t *qi_cast(qi_state_t *state, qi_type_t type, qi_value_t *value) {
               qi_mutex_unlock(value->mutex);
 
               qi_throw_format(state,
-                              "cannot cast %s to %s (expected list of numbers, but element #%zu is %s)",
-                              _qi_type(state, value), qi_repr_type(type), i, _qi_type(state, byte));
+                              "cannot cast %s to %s (expected list of numbers, "
+                              "but element #%zu is %s)",
+                              _qi_type(state, value), qi_repr_type(type), i,
+                              _qi_type(state, byte));
             }
 
             temp[i] = (unsigned char)(byte->value.number);
@@ -1751,7 +1752,8 @@ qi_value_t *qi_cast(qi_state_t *state, qi_type_t type, qi_value_t *value) {
       qi_list_t *list = qi_list_make_n(value->value.bytes->size);
 
       for (qi_size_t i = 0; i < value->value.bytes->size; i++)
-        qi_list_data(list, i) = qi_make_number(state, value->value.bytes->data[i]);
+        qi_list_data(list, i) =
+            qi_make_number(state, value->value.bytes->data[i]);
 
       return qi_make_list(state, list);
     }
@@ -1767,7 +1769,8 @@ qi_value_t *qi_cast(qi_state_t *state, qi_type_t type, qi_value_t *value) {
       return qi_make_list(state, keys);
     }
 
-    case QI_TUPLE: return qi_make_list(state, qi_list_copy(value->value.list));
+    case QI_TUPLE:
+      return qi_make_list(state, qi_list_copy(value->value.list));
 
     default:
       break;
@@ -1865,9 +1868,7 @@ qi_value_t *qi_cast(qi_state_t *state, qi_type_t type, qi_value_t *value) {
     case QI_LIST: {
       qi_list_t *list;
 
-      LOCKED(value, {
-        list = qi_list_copy(value->value.list);
-      });
+      LOCKED(value, { list = qi_list_copy(value->value.list); });
 
       return qi_make_tuple(state, list);
     }
@@ -1876,7 +1877,8 @@ qi_value_t *qi_cast(qi_state_t *state, qi_type_t type, qi_value_t *value) {
       qi_list_t *list = qi_list_make_n(value->value.bytes->size);
 
       for (qi_size_t i = 0; i < value->value.bytes->size; i++)
-        qi_list_data(list, i) = qi_make_number(state, value->value.bytes->data[i]);
+        qi_list_data(list, i) =
+            qi_make_number(state, value->value.bytes->data[i]);
 
       return qi_make_tuple(state, list);
     }
@@ -2069,7 +2071,8 @@ qi_value_t *qi_index_set(qi_state_t *state, qi_bool is_pf, qi_value_t *value,
           old = qi_list_index(value->value.list,
                               (qi_ssize_t)(index->value.number));
 
-        qi_list_set(value->value.list, (qi_ssize_t)(index->value.number), newvalue);
+        qi_list_set(value->value.list, (qi_ssize_t)(index->value.number),
+                    newvalue);
       });
 
       if (!newvalue)
@@ -2119,7 +2122,7 @@ static qi_value_t *_qi_call(qi_state_t *state, qi_value_t *value,
   }
 
   if (value->value.function._this) {
-    qi_list_t *temp = !pargs? qi_list_make(): qi_list_copy(pargs);
+    qi_list_t *temp = !pargs ? qi_list_make() : qi_list_copy(pargs);
     qi_list_insert(temp, 0, value->value.function._this);
 
     pargs = temp;
@@ -2891,7 +2894,8 @@ static qi_state_t *qi_state_clone(qi_state_t *state) {
 }
 
 void qi_exit(qi_state_t *state, int code) {
-  while (_qi_old_scope(state, true)) ;
+  while (_qi_old_scope(state, true))
+    ;
 
   qi_finalize();
 
@@ -2997,9 +3001,7 @@ void qi_cond_wait(void *cond, void *mutex) {
   pthread_cond_wait((pthread_cond_t *)cond, (pthread_mutex_t *)mutex);
 }
 
-void qi_cond_signal(void *cond) {
-  pthread_cond_signal((pthread_cond_t *)cond);
-}
+void qi_cond_signal(void *cond) { pthread_cond_signal((pthread_cond_t *)cond); }
 
 void qi_cond_broadcast(void *cond) {
   pthread_cond_broadcast((pthread_cond_t *)cond);
@@ -3156,12 +3158,14 @@ qi_value_t *qi_builtin_set_pseudomethod(qi_state_t *state, qi_size_t pargc,
                     _qi_type(state, a));
 
   if (b->type != QI_FUNCTION)
-    qi_throw_format(state, "expected second argument to be: function, but got: %s",
+    qi_throw_format(state,
+                    "expected second argument to be: function, but got: %s",
                     _qi_type(state, b));
 
   char *name = a->value.string;
 
-  qi_value_t *method = qi_make_function(state, name, b->value.function.pargc, b->value.function.handle, NULL);
+  qi_value_t *method = qi_make_function(state, name, b->value.function.pargc,
+                                        b->value.function.handle, NULL);
   method->value.function.is_pm = true;
 
   qi_mutex_lock(state->pseudomethods_mutex);
@@ -3187,11 +3191,11 @@ qi_value_t *qi_builtin_has_pseudomethod(qi_state_t *state, qi_size_t pargc,
 
   qi_mutex_unlock(state->pseudomethods_mutex);
 
-  return res? state->_true: state->_false;
+  return res ? state->_true : state->_false;
 }
 
 qi_value_t *qi_builtin_unset_pseudomethod(qi_state_t *state, qi_size_t pargc,
-                                        qi_list_t *pargs) {
+                                          qi_list_t *pargs) {
   qi_value_t *a = qi_list_data(pargs, 0);
 
   if (a->type != QI_STRING)
@@ -3710,8 +3714,7 @@ qi_value_t *qi_builtin_list_insert(qi_state_t *state, qi_size_t pargc,
 
   qi_bool res = false;
 
-  LOCKED(a,
-         { res = qi_list_insert(a->value.list, b->value.number, c); });
+  LOCKED(a, { res = qi_list_insert(a->value.list, b->value.number, c); });
 
   if (!res)
     qi_throw_format(state, "list index out of range: %s",
@@ -4064,7 +4067,8 @@ static void qi_state_setup(qi_state_t *state) {
   qi_decl_const(state, "false", state->_false);
   qi_decl_const(state, "NAN", state->nan);
   qi_decl_const(state, "INFINITY", state->infinity);
-  qi_decl_const(state, "__LIBQIRT", qi_make_string(state, (char *)LIBQIRT_INFO));
+  qi_decl_const(state, "__LIBQIRT",
+                qi_make_string(state, (char *)LIBQIRT_INFO));
 
   qi_decl_const(state, "STDIN", state->_stdin);
   qi_decl_const(state, "STDERR", state->_stderr);