Merge pull request #508 from akheron/clang-format

Format code with clang-format

47 files changed, 2441 insertions, 2832 deletions

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..0870245
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,5 @@
+BasedOnStyle: LLVM
+AlignConsecutiveMacros: true
+ColumnLimit: 90
+IndentCaseLabels: true
+IndentWidth: 4
diff --git a/.gitignore b/.gitignore
index 4d62549..0a985b4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -33,3 +33,5 @@ stamp-h1
 *.exe
 .idea
 cmake-build-debug/
+*.log
+*.trs
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
index 265e3ff..bc4e23c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,9 +1,13 @@
 env:
+  global:
+    - CLANG_FORMAT_VERSION=9
   matrix:
     - JANSSON_BUILD_METHOD=cmake JANSSON_CMAKE_OPTIONS="-DJANSSON_TEST_WITH_VALGRIND=ON" JANSSON_EXTRA_INSTALL="valgrind"
     - JANSSON_BUILD_METHOD=autotools
     - JANSSON_BUILD_METHOD=coverage JANSSON_CMAKE_OPTIONS="-DJANSSON_COVERAGE=ON -DJANSSON_COVERALLS=ON -DCMAKE_BUILD_TYPE=Debug" JANSSON_EXTRA_INSTALL="lcov curl"
     - JANSSON_BUILD_METHOD=fuzzer
+    - JANSSON_BUILD_METHOD=lint CLANG_FORMAT=clang-format-9
+dist: bionic
 language: c
 compiler:
   - gcc
@@ -14,13 +18,17 @@ matrix:
       env: JANSSON_BUILD_METHOD=coverage JANSSON_CMAKE_OPTIONS="-DJANSSON_COVERAGE=ON -DJANSSON_COVERALLS=ON -DCMAKE_BUILD_TYPE=Debug" JANSSON_EXTRA_INSTALL="lcov curl"
     - compiler: clang
       env: JANSSON_BUILD_METHOD=fuzzer
+    - compiler: gcc
+      env: JANSSON_BUILD_METHOD=lint CLANG_FORMAT=clang-format-9
   allow_failures:
     - env: JANSSON_BUILD_METHOD=coverage JANSSON_CMAKE_OPTIONS="-DJANSSON_COVERAGE=ON -DJANSSON_COVERALLS=ON -DCMAKE_BUILD_TYPE=Debug" JANSSON_EXTRA_INSTALL="lcov curl"
 install:
   - sudo apt-get update -qq
   - sudo apt-get install -y -qq cmake $JANSSON_EXTRA_INSTALL
+  - if [ "$TRAVIS_COMPILER" = "clang" ]; then sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y && wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add - && sudo apt-add-repository "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main" -y && sudo apt-get install -y -qq clang-9 clang-format-9; fi
 script:
   - if [ "$JANSSON_BUILD_METHOD" = "autotools" ]; then autoreconf -f -i && CFLAGS=-Werror ./configure && make check; fi
   - if [ "$JANSSON_BUILD_METHOD" = "cmake" ]; then mkdir build && cd build && cmake $JANSSON_CMAKE_OPTIONS .. && cmake --build . && ctest --output-on-failure; fi
   - if [ "$JANSSON_BUILD_METHOD" = "coverage" ]; then mkdir build && cd build && cmake $JANSSON_CMAKE_OPTIONS .. && cmake --build . && cmake --build . --target coveralls; fi
   - if [ "$JANSSON_BUILD_METHOD" = "fuzzer" ]; then ./test/ossfuzz/travisoss.sh; fi
+  - if [ "$JANSSON_BUILD_METHOD" = "lint" ]; then ./scripts/clang-format-check; fi
diff --git a/Makefile.am b/Makefile.am
index 0de2ac1..285d2f0 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -8,3 +8,5 @@ dvi:
 
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = jansson.pc
+
+TESTS = scripts/clang-format-check
diff --git a/configure.ac b/configure.ac
index a2da157..e845a4d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,5 +1,5 @@
 AC_PREREQ([2.60])
-AC_INIT([jansson], [2.12], [petri@digip.org])
+AC_INIT([jansson], [2.12], [https://github.com/akheron/jansson/issues])
 
 AC_CONFIG_AUX_DIR([.])
 AM_INIT_AUTOMAKE([1.10 foreign])
diff --git a/doc/github_commits.c b/doc/github_commits.c
index a9a84d8..c020f46 100644
--- a/doc/github_commits.c
+++ b/doc/github_commits.c
@@ -8,37 +8,33 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <jansson.h>
 #include <curl/curl.h>
+#include <jansson.h>
 
-#define BUFFER_SIZE  (256 * 1024)  /* 256 KB */
+#define BUFFER_SIZE (256 * 1024) /* 256 KB */
 
-#define URL_FORMAT   "https://api.github.com/repos/%s/%s/commits"
-#define URL_SIZE     256
+#define URL_FORMAT "https://api.github.com/repos/%s/%s/commits"
+#define URL_SIZE   256
 
 /* Return the offset of the first newline in text or the length of
    text if there's no newline */
-static int newline_offset(const char *text)
-{
+static int newline_offset(const char *text) {
     const char *newline = strchr(text, '\n');
-    if(!newline)
+    if (!newline)
         return strlen(text);
     else
         return (int)(newline - text);
 }
 
-struct write_result
-{
+struct write_result {
     char *data;
     int pos;
 };
 
-static size_t write_response(void *ptr, size_t size, size_t nmemb, void *stream)
-{
+static size_t write_response(void *ptr, size_t size, size_t nmemb, void *stream) {
     struct write_result *result = (struct write_result *)stream;
 
-    if(result->pos + size * nmemb >= BUFFER_SIZE - 1)
-    {
+    if (result->pos + size * nmemb >= BUFFER_SIZE - 1) {
         fprintf(stderr, "error: too small buffer\n");
         return 0;
     }
@@ -49,8 +45,7 @@ static size_t write_response(void *ptr, size_t size, size_t nmemb, void *stream)
     return size * nmemb;
 }
 
-static char *request(const char *url)
-{
+static char *request(const char *url) {
     CURL *curl = NULL;
     CURLcode status;
     struct curl_slist *headers = NULL;
@@ -59,17 +54,14 @@ static char *request(const char *url)
 
     curl_global_init(CURL_GLOBAL_ALL);
     curl = curl_easy_init();
-    if(!curl)
+    if (!curl)
         goto error;
 
     data = malloc(BUFFER_SIZE);
-    if(!data)
+    if (!data)
         goto error;
 
-    struct write_result write_result = {
-        .data = data,
-        .pos = 0
-    };
+    struct write_result write_result = {.data = data, .pos = 0};
 
     curl_easy_setopt(curl, CURLOPT_URL, url);
 
@@ -81,16 +73,14 @@ static char *request(const char *url)
     curl_easy_setopt(curl, CURLOPT_WRITEDATA, &write_result);
 
     status = curl_easy_perform(curl);
-    if(status != 0)
-    {
+    if (status != 0) {
         fprintf(stderr, "error: unable to request data from %s:\n", url);
         fprintf(stderr, "%s\n", curl_easy_strerror(status));
         goto error;
     }
 
     curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
-    if(code != 200)
-    {
+    if (code != 200) {
         fprintf(stderr, "error: server responded with code %ld\n", code);
         goto error;
     }
@@ -105,18 +95,17 @@ static char *request(const char *url)
     return data;
 
 error:
-    if(data)
+    if (data)
         free(data);
-    if(curl)
+    if (curl)
         curl_easy_cleanup(curl);
-    if(headers)
+    if (headers)
         curl_slist_free_all(headers);
     curl_global_cleanup();
     return NULL;
 }
 
-int main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
     size_t i;
     char *text;
     char url[URL_SIZE];
@@ -124,8 +113,7 @@ int main(int argc, char *argv[])
     json_t *root;
     json_error_t error;
 
-    if(argc != 3)
-    {
+    if (argc != 3) {
         fprintf(stderr, "usage: %s USER REPOSITORY\n\n", argv[0]);
         fprintf(stderr, "List commits at USER's REPOSITORY.\n\n");
         return 2;
@@ -134,65 +122,56 @@ int main(int argc, char *argv[])
     snprintf(url, URL_SIZE, URL_FORMAT, argv[1], argv[2]);
 
     text = request(url);
-    if(!text)
+    if (!text)
         return 1;
 
     root = json_loads(text, 0, &error);
     free(text);
 
-    if(!root)
-    {
+    if (!root) {
         fprintf(stderr, "error: on line %d: %s\n", error.line, error.text);
         return 1;
     }
 
-    if(!json_is_array(root))
-    {
+    if (!json_is_array(root)) {
         fprintf(stderr, "error: root is not an array\n");
         json_decref(root);
         return 1;
     }
 
-    for(i = 0; i < json_array_size(root); i++)
-    {
+    for (i = 0; i < json_array_size(root); i++) {
         json_t *data, *sha, *commit, *message;
         const char *message_text;
 
         data = json_array_get(root, i);
-        if(!json_is_object(data))
-        {
+        if (!json_is_object(data)) {
             fprintf(stderr, "error: commit data %d is not an object\n", (int)(i + 1));
             json_decref(root);
             return 1;
         }
 
         sha = json_object_get(data, "sha");
-        if(!json_is_string(sha))
-        {
+        if (!json_is_string(sha)) {
             fprintf(stderr, "error: commit %d: sha is not a string\n", (int)(i + 1));
             return 1;
         }
 
         commit = json_object_get(data, "commit");
-        if(!json_is_object(commit))
-        {
+        if (!json_is_object(commit)) {
             fprintf(stderr, "error: commit %d: commit is not an object\n", (int)(i + 1));
             json_decref(root);
             return 1;
         }
 
         message = json_object_get(commit, "message");
-        if(!json_is_string(message))
-        {
+        if (!json_is_string(message)) {
             fprintf(stderr, "error: commit %d: message is not a string\n", (int)(i + 1));
             json_decref(root);
             return 1;
         }
 
         message_text = json_string_value(message);
-        printf("%.8s %.*s\n",
-               json_string_value(sha),
-               newline_offset(message_text),
+        printf("%.8s %.*s\n", json_string_value(sha), newline_offset(message_text),
                message_text);
     }
 
diff --git a/examples/simple_parse.c b/examples/simple_parse.c
index 044337b..4554e4f 100644
--- a/examples/simple_parse.c
+++ b/examples/simple_parse.c
@@ -22,9 +22,9 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
+#include <jansson.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <jansson.h>
 
 /* forward refs */
 void print_json(json_t *root);
@@ -40,49 +40,47 @@ void print_json_true(json_t *element, int indent);
 void print_json_false(json_t *element, int indent);
 void print_json_null(json_t *element, int indent);
 
-void print_json(json_t *root) {
-    print_json_aux(root, 0);
-}
+void print_json(json_t *root) { print_json_aux(root, 0); }
 
 void print_json_aux(json_t *element, int indent) {
     switch (json_typeof(element)) {
-    case JSON_OBJECT:
-        print_json_object(element, indent);
-        break;
-    case JSON_ARRAY:
-        print_json_array(element, indent);
-        break;
-    case JSON_STRING:
-        print_json_string(element, indent);
-        break;
-    case JSON_INTEGER:
-        print_json_integer(element, indent);
-        break;
-    case JSON_REAL:
-        print_json_real(element, indent);
-        break;
-    case JSON_TRUE:
-        print_json_true(element, indent);
-        break;
-    case JSON_FALSE:
-        print_json_false(element, indent);
-        break;
-    case JSON_NULL:
-        print_json_null(element, indent);
-        break;
-    default:
-        fprintf(stderr, "unrecognized JSON type %d\n", json_typeof(element));
+        case JSON_OBJECT:
+            print_json_object(element, indent);
+            break;
+        case JSON_ARRAY:
+            print_json_array(element, indent);
+            break;
+        case JSON_STRING:
+            print_json_string(element, indent);
+            break;
+        case JSON_INTEGER:
+            print_json_integer(element, indent);
+            break;
+        case JSON_REAL:
+            print_json_real(element, indent);
+            break;
+        case JSON_TRUE:
+            print_json_true(element, indent);
+            break;
+        case JSON_FALSE:
+            print_json_false(element, indent);
+            break;
+        case JSON_NULL:
+            print_json_null(element, indent);
+            break;
+        default:
+            fprintf(stderr, "unrecognized JSON type %d\n", json_typeof(element));
     }
 }
 
 void print_json_indent(int indent) {
     int i;
-    for (i = 0; i < indent; i++) { putchar(' '); }
+    for (i = 0; i < indent; i++) {
+        putchar(' ');
+    }
 }
 
-const char *json_plural(int count) {
-    return count == 1 ? "" : "s";
-}
+const char *json_plural(int count) { return count == 1 ? "" : "s"; }
 
 void print_json_object(json_t *element, int indent) {
     size_t size;
@@ -98,7 +96,6 @@ void print_json_object(json_t *element, int indent) {
         printf("JSON Key: \"%s\"\n", key);
         print_json_aux(value, indent + 2);
     }
-
 }
 
 void print_json_array(json_t *element, int indent) {
diff --git a/scripts/clang-format b/scripts/clang-format
new file mode 100755
index 0000000..d46056c
--- /dev/null
+++ b/scripts/clang-format
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+find . -type f -a '(' -name '*.c' -o -name '*.h' ')' | xargs clang-format -i
diff --git a/scripts/clang-format-check b/scripts/clang-format-check
new file mode 100755
index 0000000..983e55d
--- /dev/null
+++ b/scripts/clang-format-check
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+CLANG_FORMAT=${CLANG_FORMAT:-clang-format}
+CLANG_FORMAT_VERSION=${CLANG_FORMAT_VERSION:-}
+
+if ! type $CLANG_FORMAT >/dev/null || \
+        ! $CLANG_FORMAT --version | grep -q "version ${CLANG_FORMAT_VERSION}"; then
+    # If running tests, mark this test as skipped.
+    exit 77
+fi
+
+errors=0
+paths=$(git ls-files | grep '\.[ch]$')
+for path in $paths; do
+    in=$(cat $path)
+    out=$($CLANG_FORMAT $path)
+
+    if [ "$in" != "$out" ]; then
+        diff -u -L $path -L "$path.formatted" $path - <<<$out
+        errors=1
+    fi
+done
+
+if [ $errors -ne 0 ]; then
+    echo "Formatting errors detected, run ./scripts/clang-format to fix!"
+    exit 1
+fi
diff --git a/src/dump.c b/src/dump.c
index b57282f..1baa248 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -11,10 +11,10 @@
 
 #include "jansson_private.h"
 
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
@@ -23,11 +23,11 @@
 #include "strbuffer.h"
 #include "utf.h"
 
-#define MAX_INTEGER_STR_LENGTH  100
-#define MAX_REAL_STR_LENGTH     100
+#define MAX_INTEGER_STR_LENGTH 100
+#define MAX_REAL_STR_LENGTH    100
 
-#define FLAGS_TO_INDENT(f)      ((f) & 0x1F)
-#define FLAGS_TO_PRECISION(f)   (((f) >> 11) & 0x1F)
+#define FLAGS_TO_INDENT(f)    ((f)&0x1F)
+#define FLAGS_TO_PRECISION(f) (((f) >> 11) & 0x1F)
 
 struct buffer {
     const size_t size;
@@ -35,35 +35,31 @@ struct buffer {
     char *data;
 };
 
-static int dump_to_strbuffer(const char *buffer, size_t size, void *data)
-{
+static int dump_to_strbuffer(const char *buffer, size_t size, void *data) {
     return strbuffer_append_bytes((strbuffer_t *)data, buffer, size);
 }
 
-static int dump_to_buffer(const char *buffer, size_t size, void *data)
-{
+static int dump_to_buffer(const char *buffer, size_t size, void *data) {
     struct buffer *buf = (struct buffer *)data;
 
-    if(buf->used + size <= buf->size)
+    if (buf->used + size <= buf->size)
         memcpy(&buf->data[buf->used], buffer, size);
 
     buf->used += size;
     return 0;
 }
 
-static int dump_to_file(const char *buffer, size_t size, void *data)
-{
+static int dump_to_file(const char *buffer, size_t size, void *data) {
     FILE *dest = (FILE *)data;
-    if(fwrite(buffer, size, 1, dest) != 1)
+    if (fwrite(buffer, size, 1, dest) != 1)
         return -1;
     return 0;
 }
 
-static int dump_to_fd(const char *buffer, size_t size, void *data)
-{
+static int dump_to_fd(const char *buffer, size_t size, void *data) {
 #ifdef HAVE_UNISTD_H
     int *dest = (int *)data;
-    if(write(*dest, buffer, size) == (ssize_t)size)
+    if (write(*dest, buffer, size) == (ssize_t)size)
         return 0;
 #endif
     return -1;
@@ -72,108 +68,116 @@ static int dump_to_fd(const char *buffer, size_t size, void *data)
 /* 32 spaces (the maximum indentation size) */
 static const char whitespace[] = "                                ";
 
-static int dump_indent(size_t flags, int depth, int space, json_dump_callback_t dump, void *data)
-{
-    if(FLAGS_TO_INDENT(flags) > 0)
-    {
+static int dump_indent(size_t flags, int depth, int space, json_dump_callback_t dump,
+                       void *data) {
+    if (FLAGS_TO_INDENT(flags) > 0) {
         unsigned int ws_count = FLAGS_TO_INDENT(flags), n_spaces = depth * ws_count;
 
-        if(dump("\n", 1, data))
+        if (dump("\n", 1, data))
             return -1;
 
-        while(n_spaces > 0)
-        {
-            int cur_n = n_spaces < sizeof whitespace - 1 ? n_spaces : sizeof whitespace - 1;
+        while (n_spaces > 0) {
+            int cur_n =
+                n_spaces < sizeof whitespace - 1 ? n_spaces : sizeof whitespace - 1;
 
-            if(dump(whitespace, cur_n, data))
+            if (dump(whitespace, cur_n, data))
                 return -1;
 
             n_spaces -= cur_n;
         }
-    }
-    else if(space && !(flags & JSON_COMPACT))
-    {
+    } else if (space && !(flags & JSON_COMPACT)) {
         return dump(" ", 1, data);
     }
     return 0;
 }
 
-static int dump_string(const char *str, size_t len, json_dump_callback_t dump, void *data, size_t flags)
-{
+static int dump_string(const char *str, size_t len, json_dump_callback_t dump, void *data,
+                       size_t flags) {
     const char *pos, *end, *lim;
     int32_t codepoint = 0;
 
-    if(dump("\"", 1, data))
+    if (dump("\"", 1, data))
         return -1;
 
     end = pos = str;
     lim = str + len;
-    while(1)
-    {
+    while (1) {
         const char *text;
         char seq[13];
         int length;
 
-        while(end < lim)
-        {
+        while (end < lim) {
             end = utf8_iterate(pos, lim - pos, &codepoint);
-            if(!end)
+            if (!end)
                 return -1;
 
             /* mandatory escape or control char */
-            if(codepoint == '\\' || codepoint == '"' || codepoint < 0x20)
+            if (codepoint == '\\' || codepoint == '"' || codepoint < 0x20)
                 break;
 
             /* slash */
-            if((flags & JSON_ESCAPE_SLASH) && codepoint == '/')
+            if ((flags & JSON_ESCAPE_SLASH) && codepoint == '/')
                 break;
 
             /* non-ASCII */
-            if((flags & JSON_ENSURE_ASCII) && codepoint > 0x7F)
+            if ((flags & JSON_ENSURE_ASCII) && codepoint > 0x7F)
                 break;
 
             pos = end;
         }
 
-        if(pos != str) {
-            if(dump(str, pos - str, data))
+        if (pos != str) {
+            if (dump(str, pos - str, data))
                 return -1;
         }
 
-        if(end == pos)
+        if (end == pos)
             break;
 
         /* handle \, /, ", and control codes */
         length = 2;
-        switch(codepoint)
-        {
-            case '\\': text = "\\\\"; break;
-            case '\"': text = "\\\""; break;
-            case '\b': text = "\\b"; break;
-            case '\f': text = "\\f"; break;
-            case '\n': text = "\\n"; break;
-            case '\r': text = "\\r"; break;
-            case '\t': text = "\\t"; break;
-            case '/':  text = "\\/"; break;
-            default:
-            {
+        switch (codepoint) {
+            case '\\':
+                text = "\\\\";
+                break;
+            case '\"':
+                text = "\\\"";
+                break;
+            case '\b':
+                text = "\\b";
+                break;
+            case '\f':
+                text = "\\f";
+                break;
+            case '\n':
+                text = "\\n";
+                break;
+            case '\r':
+                text = "\\r";
+                break;
+            case '\t':
+                text = "\\t";
+                break;
+            case '/':
+                text = "\\/";
+                break;
+            default: {
                 /* codepoint is in BMP */
-                if(codepoint < 0x10000)
-                {
+                if (codepoint < 0x10000) {
                     snprintf(seq, sizeof(seq), "\\u%04X", (unsigned int)codepoint);
                     length = 6;
                 }
 
                 /* not in BMP -> construct a UTF-16 surrogate pair */
-                else
-                {
+                else {
                     int32_t first, last;
 
                     codepoint -= 0x10000;
                     first = 0xD800 | ((codepoint & 0xffc00) >> 10);
                     last = 0xDC00 | (codepoint & 0x003ff);
 
-                    snprintf(seq, sizeof(seq), "\\u%04X\\u%04X", (unsigned int)first, (unsigned int)last);
+                    snprintf(seq, sizeof(seq), "\\u%04X\\u%04X", (unsigned int)first,
+                             (unsigned int)last);
                     length = 12;
                 }
 
@@ -182,7 +186,7 @@ static int dump_string(const char *str, size_t len, json_dump_callback_t dump, v
             }
         }
 
-        if(dump(text, length, data))
+        if (dump(text, length, data))
             return -1;
 
         str = pos = end;
@@ -191,22 +195,20 @@ static int dump_string(const char *str, size_t len, json_dump_callback_t dump, v
     return dump("\"", 1, data);
 }
 
-static int compare_keys(const void *key1, const void *key2)
-{
+static int compare_keys(const void *key1, const void *key2) {
     return strcmp(*(const char **)key1, *(const char **)key2);
 }
 
-static int do_dump(const json_t *json, size_t flags, int depth,
-                   hashtable_t *parents, json_dump_callback_t dump, void *data)
-{
+static int do_dump(const json_t *json, size_t flags, int depth, hashtable_t *parents,
+                   json_dump_callback_t dump, void *data) {
     int embed = flags & JSON_EMBED;
 
     flags &= ~JSON_EMBED;
 
-    if(!json)
+    if (!json)
         return -1;
 
-    switch(json_typeof(json)) {
+    switch (json_typeof(json)) {
         case JSON_NULL:
             return dump("null", 4, data);
 
@@ -216,42 +218,40 @@ static int do_dump(const json_t *json, size_t flags, int depth,
         case JSON_FALSE:
             return dump("false", 5, data);
 
-        case JSON_INTEGER:
-        {
+        case JSON_INTEGER: {
             char buffer[MAX_INTEGER_STR_LENGTH];
             int size;
 
-            size = snprintf(buffer, MAX_INTEGER_STR_LENGTH,
-                            "%" JSON_INTEGER_FORMAT,
+            size = snprintf(buffer, MAX_INTEGER_STR_LENGTH, "%" JSON_INTEGER_FORMAT,
                             json_integer_value(json));
-            if(size < 0 || size >= MAX_INTEGER_STR_LENGTH)
+            if (size < 0 || size >= MAX_INTEGER_STR_LENGTH)
                 return -1;
 
             return dump(buffer, size, data);
         }
 
-        case JSON_REAL:
-        {
+        case JSON_REAL: {
             char buffer[MAX_REAL_STR_LENGTH];
             int size;
             double value = json_real_value(json);
 
             size = jsonp_dtostr(buffer, MAX_REAL_STR_LENGTH, value,
                                 FLAGS_TO_PRECISION(flags));
-            if(size < 0)
+            if (size < 0)
                 return -1;
 
             return dump(buffer, size, data);
         }
 
         case JSON_STRING:
-            return dump_string(json_string_value(json), json_string_length(json), dump, data, flags);
+            return dump_string(json_string_value(json), json_string_length(json), dump,
+                               data, flags);
 
-        case JSON_ARRAY:
-        {
+        case JSON_ARRAY: {
             size_t n;
             size_t i;
-            /* Space for "0x", double the sizeof a pointer for the hex and a terminator. */
+            /* Space for "0x", double the sizeof a pointer for the hex and a
+             * terminator. */
             char key[2 + (sizeof(json) * 2) + 1];
 
             /* detect circular references */
@@ -260,29 +260,26 @@ static int do_dump(const json_t *json, size_t flags, int depth,
 
             n = json_array_size(json);
 
-            if(!embed && dump("[", 1, data))
+            if (!embed && dump("[", 1, data))
                 return -1;
-            if(n == 0) {
+            if (n == 0) {
                 hashtable_del(parents, key);
                 return embed ? 0 : dump("]", 1, data);
             }
-            if(dump_indent(flags, depth + 1, 0, dump, data))
+            if (dump_indent(flags, depth + 1, 0, dump, data))
                 return -1;
 
-            for(i = 0; i < n; ++i) {
-                if(do_dump(json_array_get(json, i), flags, depth + 1,
-                           parents, dump, data))
+            for (i = 0; i < n; ++i) {
+                if (do_dump(json_array_get(json, i), flags, depth + 1, parents, dump,
+                            data))
                     return -1;
 
-                if(i < n - 1)
-                {
-                    if(dump(",", 1, data) ||
-                       dump_indent(flags, depth + 1, 1, dump, data))
+                if (i < n - 1) {
+                    if (dump(",", 1, data) ||
+                        dump_indent(flags, depth + 1, 1, dump, data))
                         return -1;
-                }
-                else
-                {
-                    if(dump_indent(flags, depth, 0, dump, data))
+                } else {
+                    if (dump_indent(flags, depth, 0, dump, data))
                         return -1;
                 }
             }
@@ -291,18 +288,16 @@ static int do_dump(const json_t *json, size_t flags, int depth,
             return embed ? 0 : dump("]", 1, data);
         }
 
-        case JSON_OBJECT:
-        {
+        case JSON_OBJECT: {
             void *iter;
             const char *separator;
             int separator_length;
             char loop_key[LOOP_KEY_LEN];
 
-            if(flags & JSON_COMPACT) {
+            if (flags & JSON_COMPACT) {
                 separator = ":";
                 separator_length = 1;
-            }
-            else {
+            } else {
                 separator = ": ";
                 separator_length = 2;
             }
@@ -313,28 +308,26 @@ static int do_dump(const json_t *json, size_t flags, int depth,
 
             iter = json_object_iter((json_t *)json);
 
-            if(!embed && dump("{", 1, data))
+            if (!embed && dump("{", 1, data))
                 return -1;
-            if(!iter) {
+            if (!iter) {
                 hashtable_del(parents, loop_key);
                 return embed ? 0 : dump("}", 1, data);
             }
-            if(dump_indent(flags, depth + 1, 0, dump, data))
+            if (dump_indent(flags, depth + 1, 0, dump, data))
                 return -1;
 
-            if(flags & JSON_SORT_KEYS)
-            {
+            if (flags & JSON_SORT_KEYS) {
                 const char **keys;
                 size_t size, i;
 
                 size = json_object_size(json);
                 keys = jsonp_malloc(size * sizeof(const char *));
-                if(!keys)
+                if (!keys)
                     return -1;
 
                 i = 0;
-                while(iter)
-                {
+                while (iter) {
                     keys[i] = json_object_iter_key(iter);
                     iter = json_object_iter_next((json_t *)json, iter);
                     i++;
@@ -343,8 +336,7 @@ static int do_dump(const json_t *json, size_t flags, int depth,
 
                 qsort(keys, size, sizeof(const char *), compare_keys);
 
-                for(i = 0; i < size; i++)
-                {
+                for (i = 0; i < size; i++) {
                     const char *key;
                     json_t *value;
 
@@ -353,26 +345,20 @@ static int do_dump(const json_t *json, size_t flags, int depth,
                     assert(value);
 
                     dump_string(key, strlen(key), dump, data, flags);
-                    if(dump(separator, separator_length, data) ||
-                       do_dump(value, flags, depth + 1, parents, dump, data))
-                    {
+                    if (dump(separator, separator_length, data) ||
+                        do_dump(value, flags, depth + 1, parents, dump, data)) {
                         jsonp_free(keys);
                         return -1;
                     }
 
-                    if(i < size - 1)
-                    {
-                        if(dump(",", 1, data) ||
-                           dump_indent(flags, depth + 1, 1, dump, data))
-                        {
+                    if (i < size - 1) {
+                        if (dump(",", 1, data) ||
+                            dump_indent(flags, depth + 1, 1, dump, data)) {
                             jsonp_free(keys);
                             return -1;
                         }
-                    }
-                    else
-                    {
-                        if(dump_indent(flags, depth, 0, dump, data))
-                        {
+                    } else {
+                        if (dump_indent(flags, depth, 0, dump, data)) {
                             jsonp_free(keys);
                             return -1;
                         }
@@ -380,31 +366,25 @@ static int do_dump(const json_t *json, size_t flags, int depth,
                 }
 
                 jsonp_free(keys);
-            }
-            else
-            {
+            } else {
                 /* Don't sort keys */
 
-                while(iter)
-                {
+                while (iter) {
                     void *next = json_object_iter_next((json_t *)json, iter);
                     const char *key = json_object_iter_key(iter);
 
                     dump_string(key, strlen(key), dump, data, flags);
-                    if(dump(separator, separator_length, data) ||
-                       do_dump(json_object_iter_value(iter), flags, depth + 1,
-                               parents, dump, data))
+                    if (dump(separator, separator_length, data) ||
+                        do_dump(json_object_iter_value(iter), flags, depth + 1, parents,
+                                dump, data))
                         return -1;
 
-                    if(next)
-                    {
-                        if(dump(",", 1, data) ||
-                           dump_indent(flags, depth + 1, 1, dump, data))
+                    if (next) {
+                        if (dump(",", 1, data) ||
+                            dump_indent(flags, depth + 1, 1, dump, data))
                             return -1;
-                    }
-                    else
-                    {
-                        if(dump_indent(flags, depth, 0, dump, data))
+                    } else {
+                        if (dump_indent(flags, depth, 0, dump, data))
                             return -1;
                     }
 
@@ -422,15 +402,14 @@ static int do_dump(const json_t *json, size_t flags, int depth,
     }
 }
 
-char *json_dumps(const json_t *json, size_t flags)
-{
+char *json_dumps(const json_t *json, size_t flags) {
     strbuffer_t strbuff;
     char *result;
 
-    if(strbuffer_init(&strbuff))
+    if (strbuffer_init(&strbuff))
         return NULL;
 
-    if(json_dump_callback(json, dump_to_strbuffer, (void *)&strbuff, flags))
+    if (json_dump_callback(json, dump_to_strbuffer, (void *)&strbuff, flags))
         result = NULL;
     else
         result = jsonp_strdup(strbuffer_value(&strbuff));
@@ -439,50 +418,46 @@ char *json_dumps(const json_t *json, size_t flags)
     return result;
 }
 
-size_t json_dumpb(const json_t *json, char *buffer, size_t size, size_t flags)
-{
-    struct buffer buf = { size, 0, buffer };
+size_t json_dumpb(const json_t *json, char *buffer, size_t size, size_t flags) {
+    struct buffer buf = {size, 0, buffer};
 
-    if(json_dump_callback(json, dump_to_buffer, (void *)&buf, flags))
+    if (json_dump_callback(json, dump_to_buffer, (void *)&buf, flags))
         return 0;
 
     return buf.used;
 }
 
-int json_dumpf(const json_t *json, FILE *output, size_t flags)
-{
+int json_dumpf(const json_t *json, FILE *output, size_t flags) {
     return json_dump_callback(json, dump_to_file, (void *)output, flags);
 }
 
-int json_dumpfd(const json_t *json, int output, size_t flags)
-{
+int json_dumpfd(const json_t *json, int output, size_t flags) {
     return json_dump_callback(json, dump_to_fd, (void *)&output, flags);
 }
 
-int json_dump_file(const json_t *json, const char *path, size_t flags)
-{
+int json_dump_file(const json_t *json, const char *path, size_t flags) {
     int result;
 
     FILE *output = fopen(path, "w");
-    if(!output)
+    if (!output)
         return -1;
 
     result = json_dumpf(json, output, flags);
 
-    if(fclose(output) != 0)
+    if (fclose(output) != 0)
         return -1;
 
     return result;
 }
 
-int json_dump_callback(const json_t *json, json_dump_callback_t callback, void *data, size_t flags)
-{
+int json_dump_callback(const json_t *json, json_dump_callback_t callback, void *data,
+                       size_t flags) {
     int res;
     hashtable_t parents_set;
 
-    if(!(flags & JSON_ENCODE_ANY)) {
-        if(!json_is_array(json) && !json_is_object(json))
-           return -1;
+    if (!(flags & JSON_ENCODE_ANY)) {
+        if (!json_is_array(json) && !json_is_object(json))
+            return -1;
     }
 
     if (hashtable_init(&parents_set))
diff --git a/src/error.c b/src/error.c
index f5da6b9..14d0047 100644
--- a/src/error.c
+++ b/src/error.c
@@ -1,30 +1,27 @@
-#include <string.h>
 #include "jansson_private.h"
+#include <string.h>
 
-void jsonp_error_init(json_error_t *error, const char *source)
-{
-    if(error)
-    {
+void jsonp_error_init(json_error_t *error, const char *source) {
+    if (error) {
         error->text[0] = '\0';
         error->line = -1;
         error->column = -1;
         error->position = 0;
-        if(source)
+        if (source)
             jsonp_error_set_source(error, source);
         else
             error->source[0] = '\0';
     }
 }
 
-void jsonp_error_set_source(json_error_t *error, const char *source)
-{
+void jsonp_error_set_source(json_error_t *error, const char *source) {
     size_t length;
 
-    if(!error || !source)
+    if (!error || !source)
         return;
 
     length = strlen(source);
-    if(length < JSON_ERROR_SOURCE_LENGTH)
+    if (length < JSON_ERROR_SOURCE_LENGTH)
         strncpy(error->source, source, length + 1);
     else {
         size_t extra = length - JSON_ERROR_SOURCE_LENGTH + 4;
@@ -33,10 +30,8 @@ void jsonp_error_set_source(json_error_t *error, const char *source)
     }
 }
 
-void jsonp_error_set(json_error_t *error, int line, int column,
-                     size_t position, enum json_error_code code,
-                     const char *msg, ...)
-{
+void jsonp_error_set(json_error_t *error, int line, int column, size_t position,
+                     enum json_error_code code, const char *msg, ...) {
     va_list ap;
 
     va_start(ap, msg);
@@ -44,14 +39,12 @@ void jsonp_error_set(json_error_t *error, int line, int column,
     va_end(ap);
 }
 
-void jsonp_error_vset(json_error_t *error, int line, int column,
-                      size_t position, enum json_error_code code,
-                      const char *msg, va_list ap)
-{
-    if(!error)
+void jsonp_error_vset(json_error_t *error, int line, int column, size_t position,
+                      enum json_error_code code, const char *msg, va_list ap) {
+    if (!error)
         return;
 
-    if(error->text[0] != '\0') {
+    if (error->text[0] != '\0') {
         /* error already set */
         return;
     }
diff --git a/src/hashtable.c b/src/hashtable.c
index c819319..fd1e706 100644
--- a/src/hashtable.c
+++ b/src/hashtable.c
@@ -16,9 +16,9 @@
 #include <stdint.h>
 #endif
 
-#include <jansson_config.h>   /* for JSON_INLINE */
-#include "jansson_private.h"  /* for container_of() */
 #include "hashtable.h"
+#include "jansson_private.h" /* for container_of() */
+#include <jansson_config.h>  /* for JSON_INLINE */
 
 #ifndef INITIAL_HASHTABLE_ORDER
 #define INITIAL_HASHTABLE_ORDER 3
@@ -33,67 +33,56 @@ extern volatile uint32_t hashtable_seed;
 /* Implementation of the hash function */
 #include "lookup3.h"
 
-#define list_to_pair(list_)  container_of(list_, pair_t, list)
-#define ordered_list_to_pair(list_)  container_of(list_, pair_t, ordered_list)
-#define hash_str(key)        ((size_t)hashlittle((key), strlen(key), hashtable_seed))
+#define list_to_pair(list_)         container_of(list_, pair_t, list)
+#define ordered_list_to_pair(list_) container_of(list_, pair_t, ordered_list)
+#define hash_str(key)               ((size_t)hashlittle((key), strlen(key), hashtable_seed))
 
-static JSON_INLINE void list_init(list_t *list)
-{
+static JSON_INLINE void list_init(list_t *list) {
     list->next = list;
     list->prev = list;
 }
 
-static JSON_INLINE void list_insert(list_t *list, list_t *node)
-{
+static JSON_INLINE void list_insert(list_t *list, list_t *node) {
     node->next = list;
     node->prev = list->prev;
     list->prev->next = node;
     list->prev = node;
 }
 
-static JSON_INLINE void list_remove(list_t *list)
-{
+static JSON_INLINE void list_remove(list_t *list) {
     list->prev->next = list->next;
     list->next->prev = list->prev;
 }
 
-static JSON_INLINE int bucket_is_empty(hashtable_t *hashtable, bucket_t *bucket)
-{
+static JSON_INLINE int bucket_is_empty(hashtable_t *hashtable, bucket_t *bucket) {
     return bucket->first == &hashtable->list && bucket->first == bucket->last;
 }
 
-static void insert_to_bucket(hashtable_t *hashtable, bucket_t *bucket,
-                             list_t *list)
-{
-    if(bucket_is_empty(hashtable, bucket))
-    {
+static void insert_to_bucket(hashtable_t *hashtable, bucket_t *bucket, list_t *list) {
+    if (bucket_is_empty(hashtable, bucket)) {
         list_insert(&hashtable->list, list);
         bucket->first = bucket->last = list;
-    }
-    else
-    {
+    } else {
         list_insert(bucket->first, list);
         bucket->first = list;
     }
 }
 
 static pair_t *hashtable_find_pair(hashtable_t *hashtable, bucket_t *bucket,
-                                   const char *key, size_t hash)
-{
+                                   const char *key, size_t hash) {
     list_t *list;
     pair_t *pair;
 
-    if(bucket_is_empty(hashtable, bucket))
+    if (bucket_is_empty(hashtable, bucket))
         return NULL;
 
     list = bucket->first;
-    while(1)
-    {
+    while (1) {
         pair = list_to_pair(list);
-        if(pair->hash == hash && strcmp(pair->key, key) == 0)
+        if (pair->hash == hash && strcmp(pair->key, key) == 0)
             return pair;
 
-        if(list == bucket->last)
+        if (list == bucket->last)
             break;
 
         list = list->next;
@@ -103,9 +92,7 @@ static pair_t *hashtable_find_pair(hashtable_t *hashtable, bucket_t *bucket,
 }
 
 /* returns 0 on success, -1 if key was not found */
-static int hashtable_do_del(hashtable_t *hashtable,
-                            const char *key, size_t hash)
-{
+static int hashtable_do_del(hashtable_t *hashtable, const char *key, size_t hash) {
     pair_t *pair;
     bucket_t *bucket;
     size_t index;
@@ -114,16 +101,16 @@ static int hashtable_do_del(hashtable_t *hashtable,
     bucket = &hashtable->buckets[index];
 
     pair = hashtable_find_pair(hashtable, bucket, key, hash);
-    if(!pair)
+    if (!pair)
         return -1;
 
-    if(&pair->list == bucket->first && &pair->list == bucket->last)
+    if (&pair->list == bucket->first && &pair->list == bucket->last)
         bucket->first = bucket->last = &hashtable->list;
 
-    else if(&pair->list == bucket->first)
+    else if (&pair->list == bucket->first)
         bucket->first = pair->list.next;
 
-    else if(&pair->list == bucket->last)
+    else if (&pair->list == bucket->last)
         bucket->last = pair->list.prev;
 
     list_remove(&pair->list);
@@ -136,13 +123,11 @@ static int hashtable_do_del(hashtable_t *hashtable,
     return 0;
 }
 
-static void hashtable_do_clear(hashtable_t *hashtable)
-{
+static void hashtable_do_clear(hashtable_t *hashtable) {
     list_t *list, *next;
     pair_t *pair;
 
-    for(list = hashtable->list.next; list != &hashtable->list; list = next)
-    {
+    for (list = hashtable->list.next; list != &hashtable->list; list = next) {
         next = list->next;
         pair = list_to_pair(list);
         json_decref(pair->value);
@@ -150,8 +135,7 @@ static void hashtable_do_clear(hashtable_t *hashtable)
     }
 }
 
-static int hashtable_do_rehash(hashtable_t *hashtable)
-{
+static int hashtable_do_rehash(hashtable_t *hashtable) {
     list_t *list, *next;
     pair_t *pair;
     size_t i, index, new_size, new_order;
@@ -161,23 +145,21 @@ static int hashtable_do_rehash(hashtable_t *hashtable)
     new_size = hashsize(new_order);
 
     new_buckets = jsonp_malloc(new_size * sizeof(bucket_t));
-    if(!new_buckets)
+    if (!new_buckets)
         return -1;
 
     jsonp_free(hashtable->buckets);
     hashtable->buckets = new_buckets;
     hashtable->order = new_order;
 
-    for(i = 0; i < hashsize(hashtable->order); i++)
-    {
-        hashtable->buckets[i].first = hashtable->buckets[i].last =
-            &hashtable->list;
+    for (i = 0; i < hashsize(hashtable->order); i++) {
+        hashtable->buckets[i].first = hashtable->buckets[i].last = &hashtable->list;
     }
 
     list = hashtable->list.next;
     list_init(&hashtable->list);
 
-    for(; list != &hashtable->list; list = next) {
+    for (; list != &hashtable->list; list = next) {
         next = list->next;
         pair = list_to_pair(list);
         index = pair->hash % new_size;
@@ -187,44 +169,38 @@ static int hashtable_do_rehash(hashtable_t *hashtable)
     return 0;
 }
 
-
-int hashtable_init(hashtable_t *hashtable)
-{
+int hashtable_init(hashtable_t *hashtable) {
     size_t i;
 
     hashtable->size = 0;
     hashtable->order = INITIAL_HASHTABLE_ORDER;
     hashtable->buckets = jsonp_malloc(hashsize(hashtable->order) * sizeof(bucket_t));
-    if(!hashtable->buckets)
+    if (!hashtable->buckets)
         return -1;
 
     list_init(&hashtable->list);
     list_init(&hashtable->ordered_list);
 
-    for(i = 0; i < hashsize(hashtable->order); i++)
-    {
-        hashtable->buckets[i].first = hashtable->buckets[i].last =
-            &hashtable->list;
+    for (i = 0; i < hashsize(hashtable->order); i++) {
+        hashtable->buckets[i].first = hashtable->buckets[i].last = &hashtable->list;
     }
 
     return 0;
 }
 
-void hashtable_close(hashtable_t *hashtable)
-{
+void hashtable_close(hashtable_t *hashtable) {
     hashtable_do_clear(hashtable);
     jsonp_free(hashtable->buckets);
 }
 
-int hashtable_set(hashtable_t *hashtable, const char *key, json_t *value)
-{
+int hashtable_set(hashtable_t *hashtable, const char *key, json_t *value) {
     pair_t *pair;
     bucket_t *bucket;
     size_t hash, index;
 
     /* rehash if the load ratio exceeds 1 */
-    if(hashtable->size >= hashsize(hashtable->order))
-        if(hashtable_do_rehash(hashtable))
+    if (hashtable->size >= hashsize(hashtable->order))
+        if (hashtable_do_rehash(hashtable))
             return -1;
 
     hash = hash_str(key);
@@ -232,25 +208,22 @@ int hashtable_set(hashtable_t *hashtable, const char *key, json_t *value)
     bucket = &hashtable->buckets[index];
     pair = hashtable_find_pair(hashtable, bucket, key, hash);
 
-    if(pair)
-    {
+    if (pair) {
         json_decref(pair->value);
         pair->value = value;
-    }
-    else
-    {
+    } else {
         /* offsetof(...) returns the size of pair_t without the last,
            flexible member. This way, the correct amount is
            allocated. */
 
         size_t len = strlen(key);
-        if(len >= (size_t)-1 - offsetof(pair_t, key)) {
+        if (len >= (size_t)-1 - offsetof(pair_t, key)) {
             /* Avoid an overflow if the key is very long */
             return -1;
         }
 
         pair = jsonp_malloc(offsetof(pair_t, key) + len + 1);
-        if(!pair)
+        if (!pair)
             return -1;
 
         pair->hash = hash;
@@ -267,8 +240,7 @@ int hashtable_set(hashtable_t *hashtable, const char *key, json_t *value)
     return 0;
 }
 
-void *hashtable_get(hashtable_t *hashtable, const char *key)
-{
+void *hashtable_get(hashtable_t *hashtable, const char *key) {
     pair_t *pair;
     size_t hash;
     bucket_t *bucket;
@@ -277,28 +249,24 @@ void *hashtable_get(hashtable_t *hashtable, const char *key)
     bucket = &hashtable->buckets[hash & hashmask(hashtable->order)];
 
     pair = hashtable_find_pair(hashtable, bucket, key, hash);
-    if(!pair)
+    if (!pair)
         return NULL;
 
     return pair->value;
 }
 
-int hashtable_del(hashtable_t *hashtable, const char *key)
-{
+int hashtable_del(hashtable_t *hashtable, const char *key) {
     size_t hash = hash_str(key);
     return hashtable_do_del(hashtable, key, hash);
 }
 
-void hashtable_clear(hashtable_t *hashtable)
-{
+void hashtable_clear(hashtable_t *hashtable) {
     size_t i;
 
     hashtable_do_clear(hashtable);
 
-    for(i = 0; i < hashsize(hashtable->order); i++)
-    {
-        hashtable->buckets[i].first = hashtable->buckets[i].last =
-            &hashtable->list;
+    for (i = 0; i < hashsize(hashtable->order); i++) {
+        hashtable->buckets[i].first = hashtable->buckets[i].last = &hashtable->list;
     }
 
     list_init(&hashtable->list);
@@ -306,13 +274,11 @@ void hashtable_clear(hashtable_t *hashtable)
     hashtable->size = 0;
 }
 
-void *hashtable_iter(hashtable_t *hashtable)
-{
+void *hashtable_iter(hashtable_t *hashtable) {
     return hashtable_iter_next(hashtable, &hashtable->ordered_list);
 }
 
-void *hashtable_iter_at(hashtable_t *hashtable, const char *key)
-{
+void *hashtable_iter_at(hashtable_t *hashtable, const char *key) {
     pair_t *pair;
     size_t hash;
     bucket_t *bucket;
@@ -321,34 +287,30 @@ void *hashtable_iter_at(hashtable_t *hashtable, const char *key)
     bucket = &hashtable->buckets[hash & hashmask(hashtable->order)];
 
     pair = hashtable_find_pair(hashtable, bucket, key, hash);
-    if(!pair)
+    if (!pair)
         return NULL;
 
     return &pair->ordered_list;
 }
 
-void *hashtable_iter_next(hashtable_t *hashtable, void *iter)
-{
+void *hashtable_iter_next(hashtable_t *hashtable, void *iter) {
     list_t *list = (list_t *)iter;
-    if(list->next == &hashtable->ordered_list)
+    if (list->next == &hashtable->ordered_list)
         return NULL;
     return list->next;
 }
 
-void *hashtable_iter_key(void *iter)
-{
+void *hashtable_iter_key(void *iter) {
     pair_t *pair = ordered_list_to_pair((list_t *)iter);
     return pair->key;
 }
 
-void *hashtable_iter_value(void *iter)
-{
+void *hashtable_iter_value(void *iter) {
     pair_t *pair = ordered_list_to_pair((list_t *)iter);
     return pair->value;
 }
 
-void hashtable_iter_set(void *iter, json_t *value)
-{
+void hashtable_iter_set(void *iter, json_t *value) {
     pair_t *pair = ordered_list_to_pair((list_t *)iter);
 
     json_decref(pair->value);
diff --git a/src/hashtable.h b/src/hashtable.h
index 00d44a9..6c4845d 100644
--- a/src/hashtable.h
+++ b/src/hashtable.h
@@ -8,8 +8,8 @@
 #ifndef HASHTABLE_H
 #define HASHTABLE_H
 
-#include <stdlib.h>
 #include "jansson.h"
+#include <stdlib.h>
 
 struct hashtable_list {
     struct hashtable_list *prev;
@@ -35,16 +35,14 @@ struct hashtable_bucket {
 typedef struct hashtable {
     size_t size;
     struct hashtable_bucket *buckets;
-    size_t order;  /* hashtable has pow(2, order) buckets */
+    size_t order; /* hashtable has pow(2, order) buckets */
     struct hashtable_list list;
     struct hashtable_list ordered_list;
 } hashtable_t;
 
-
-#define hashtable_key_to_iter(key_) \
+#define hashtable_key_to_iter(key_)                                                      \
     (&(container_of(key_, struct hashtable_pair, key)->ordered_list))
 
-
 /**
  * hashtable_init - Initialize a hashtable object
  *
diff --git a/src/hashtable_seed.c b/src/hashtable_seed.c
index 540358a..d156b40 100644
--- a/src/hashtable_seed.c
+++ b/src/hashtable_seed.c
@@ -44,7 +44,6 @@
 
 #include "jansson.h"
 
-
 static uint32_t buf_to_uint32(char *data) {
     size_t i;
     uint32_t result = 0;
@@ -55,8 +54,6 @@ static uint32_t buf_to_uint32(char *data) {
     return result;
 }
 
-
-
 /* /dev/urandom */
 #if !defined(_WIN32) && defined(USE_URANDOM)
 static int seed_from_urandom(uint32_t *seed) {
@@ -97,12 +94,13 @@ static int seed_from_urandom(uint32_t *seed) {
 #if defined(_WIN32) && defined(USE_WINDOWS_CRYPTOAPI)
 #include <wincrypt.h>
 
-typedef BOOL (WINAPI *CRYPTACQUIRECONTEXTA)(HCRYPTPROV *phProv, LPCSTR pszContainer, LPCSTR pszProvider, DWORD dwProvType, DWORD dwFlags);
-typedef BOOL (WINAPI *CRYPTGENRANDOM)(HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer);
-typedef BOOL (WINAPI *CRYPTRELEASECONTEXT)(HCRYPTPROV hProv, DWORD dwFlags);
+typedef BOOL(WINAPI *CRYPTACQUIRECONTEXTA)(HCRYPTPROV *phProv, LPCSTR pszContainer,
+                                           LPCSTR pszProvider, DWORD dwProvType,
+                                           DWORD dwFlags);
+typedef BOOL(WINAPI *CRYPTGENRANDOM)(HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer);
+typedef BOOL(WINAPI *CRYPTRELEASECONTEXT)(HCRYPTPROV hProv, DWORD dwFlags);
 
-static int seed_from_windows_cryptoapi(uint32_t *seed)
-{
+static int seed_from_windows_cryptoapi(uint32_t *seed) {
     HINSTANCE hAdvAPI32 = NULL;
     CRYPTACQUIRECONTEXTA pCryptAcquireContext = NULL;
     CRYPTGENRANDOM pCryptGenRandom = NULL;
@@ -112,10 +110,11 @@ static int seed_from_windows_cryptoapi(uint32_t *seed)
     int ok;
 
     hAdvAPI32 = GetModuleHandle(TEXT("advapi32.dll"));
-    if(hAdvAPI32 == NULL)
+    if (hAdvAPI32 == NULL)
         return 1;
 
-    pCryptAcquireContext = (CRYPTACQUIRECONTEXTA)GetProcAddress(hAdvAPI32, "CryptAcquireContextA");
+    pCryptAcquireContext =
+        (CRYPTACQUIRECONTEXTA)GetProcAddress(hAdvAPI32, "CryptAcquireContextA");
     if (!pCryptAcquireContext)
         return 1;
 
@@ -123,11 +122,13 @@ static int seed_from_windows_cryptoapi(uint32_t *seed)
     if (!pCryptGenRandom)
         return 1;
 
-    pCryptReleaseContext = (CRYPTRELEASECONTEXT)GetProcAddress(hAdvAPI32, "CryptReleaseContext");
+    pCryptReleaseContext =
+        (CRYPTRELEASECONTEXT)GetProcAddress(hAdvAPI32, "CryptReleaseContext");
     if (!pCryptReleaseContext)
         return 1;
 
-    if (!pCryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
+    if (!pCryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL,
+                              CRYPT_VERIFYCONTEXT))
         return 1;
 
     ok = pCryptGenRandom(hCryptProv, sizeof(uint32_t), data);
@@ -190,7 +191,6 @@ static uint32_t generate_seed() {
     return seed;
 }
 
-
 volatile uint32_t hashtable_seed = 0;
 
 #if defined(HAVE_ATOMIC_BUILTINS) && (defined(HAVE_SCHED_YIELD) || !defined(_WIN32))
@@ -212,7 +212,7 @@ void json_object_seed(size_t seed) {
 #ifdef HAVE_SCHED_YIELD
                 sched_yield();
 #endif
-            } while(__atomic_load_n(&hashtable_seed, __ATOMIC_ACQUIRE) == 0);
+            } while (__atomic_load_n(&hashtable_seed, __ATOMIC_ACQUIRE) == 0);
         }
     }
 }
@@ -239,7 +239,7 @@ void json_object_seed(size_t seed) {
                 sched_yield();
 #endif
             }
-        } while(hashtable_seed == 0);
+        } while (hashtable_seed == 0);
     }
 }
 #elif defined(_WIN32)
diff --git a/src/jansson.h b/src/jansson.h
index 3436465..ae1842c 100644
--- a/src/jansson.h
+++ b/src/jansson.h
@@ -8,9 +8,9 @@
 #ifndef JANSSON_H
 #define JANSSON_H
 
-#include <stdio.h>
-#include <stdlib.h>  /* for size_t */
 #include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h> /* for size_t */
 
 #include "jansson_config.h"
 
@@ -20,18 +20,18 @@ extern "C" {
 
 /* version */
 
-#define JANSSON_MAJOR_VERSION  2
-#define JANSSON_MINOR_VERSION  12
-#define JANSSON_MICRO_VERSION  0
+#define JANSSON_MAJOR_VERSION 2
+#define JANSSON_MINOR_VERSION 12
+#define JANSSON_MICRO_VERSION 0
 
 /* Micro version is omitted if it's 0 */
-#define JANSSON_VERSION  "2.12"
+#define JANSSON_VERSION "2.12"
 
 /* Version as a 3-byte hex number, e.g. 0x010201 == 1.2.1. Use this
    for numeric comparisons, e.g. #if JANSSON_VERSION_HEX >= ... */
-#define JANSSON_VERSION_HEX  ((JANSSON_MAJOR_VERSION << 16) |   \
-                              (JANSSON_MINOR_VERSION << 8)  |   \
-                              (JANSSON_MICRO_VERSION << 0))
+#define JANSSON_VERSION_HEX                                                              \
+    ((JANSSON_MAJOR_VERSION << 16) | (JANSSON_MINOR_VERSION << 8) |                      \
+     (JANSSON_MICRO_VERSION << 0))
 
 /* If __atomic or __sync builtins are available the library is thread
  * safe for all read-only functions plus reference counting. */
@@ -77,18 +77,18 @@ typedef long json_int_t;
 #endif /* JSON_INTEGER_IS_LONG_LONG */
 #endif
 
-#define json_typeof(json)      ((json)->type)
-#define json_is_object(json)   ((json) && json_typeof(json) == JSON_OBJECT)
-#define json_is_array(json)    ((json) && json_typeof(json) == JSON_ARRAY)
-#define json_is_string(json)   ((json) && json_typeof(json) == JSON_STRING)
-#define json_is_integer(json)  ((json) && json_typeof(json) == JSON_INTEGER)
-#define json_is_real(json)     ((json) && json_typeof(json) == JSON_REAL)
-#define json_is_number(json)   (json_is_integer(json) || json_is_real(json))
-#define json_is_true(json)     ((json) && json_typeof(json) == JSON_TRUE)
-#define json_is_false(json)    ((json) && json_typeof(json) == JSON_FALSE)
-#define json_boolean_value     json_is_true
-#define json_is_boolean(json)  (json_is_true(json) || json_is_false(json))
-#define json_is_null(json)     ((json) && json_typeof(json) == JSON_NULL)
+#define json_typeof(json)     ((json)->type)
+#define json_is_object(json)  ((json) && json_typeof(json) == JSON_OBJECT)
+#define json_is_array(json)   ((json) && json_typeof(json) == JSON_ARRAY)
+#define json_is_string(json)  ((json) && json_typeof(json) == JSON_STRING)
+#define json_is_integer(json) ((json) && json_typeof(json) == JSON_INTEGER)
+#define json_is_real(json)    ((json) && json_typeof(json) == JSON_REAL)
+#define json_is_number(json)  (json_is_integer(json) || json_is_real(json))
+#define json_is_true(json)    ((json) && json_typeof(json) == JSON_TRUE)
+#define json_is_false(json)   ((json) && json_typeof(json) == JSON_FALSE)
+#define json_boolean_value    json_is_true
+#define json_is_boolean(json) (json_is_true(json) || json_is_false(json))
+#define json_is_null(json)    ((json) && json_typeof(json) == JSON_NULL)
 
 /* construction, destruction, reference counting */
 
@@ -102,13 +102,15 @@ json_t *json_integer(json_int_t value);
 json_t *json_real(double value);
 json_t *json_true(void);
 json_t *json_false(void);
-#define json_boolean(val)      ((val) ? json_true() : json_false())
+#define json_boolean(val) ((val) ? json_true() : json_false())
 json_t *json_null(void);
 
 /* do not call JSON_INTERNAL_INCREF or JSON_INTERNAL_DECREF directly */
 #if JSON_HAVE_ATOMIC_BUILTINS
-#define JSON_INTERNAL_INCREF(json) __atomic_add_fetch(&json->refcount, 1, __ATOMIC_ACQUIRE)
-#define JSON_INTERNAL_DECREF(json) __atomic_sub_fetch(&json->refcount, 1, __ATOMIC_RELEASE)
+#define JSON_INTERNAL_INCREF(json)                                                       \
+    __atomic_add_fetch(&json->refcount, 1, __ATOMIC_ACQUIRE)
+#define JSON_INTERNAL_DECREF(json)                                                       \
+    __atomic_sub_fetch(&json->refcount, 1, __ATOMIC_RELEASE)
 #elif JSON_HAVE_SYNC_BUILTINS
 #define JSON_INTERNAL_INCREF(json) __sync_add_and_fetch(&json->refcount, 1)
 #define JSON_INTERNAL_DECREF(json) __sync_sub_and_fetch(&json->refcount, 1)
@@ -117,10 +119,8 @@ json_t *json_null(void);
 #define JSON_INTERNAL_DECREF(json) (--json->refcount)
 #endif
 
-static JSON_INLINE
-json_t *json_incref(json_t *json)
-{
-    if(json && json->refcount != (size_t)-1)
+static JSON_INLINE json_t *json_incref(json_t *json) {
+    if (json && json->refcount != (size_t)-1)
         JSON_INTERNAL_INCREF(json);
     return json;
 }
@@ -128,31 +128,26 @@ json_t *json_incref(json_t *json)
 /* do not call json_delete directly */
 void json_delete(json_t *json);
 
-static JSON_INLINE
-void json_decref(json_t *json)
-{
-    if(json && json->refcount != (size_t)-1 && JSON_INTERNAL_DECREF(json) == 0)
+static JSON_INLINE void json_decref(json_t *json) {
+    if (json && json->refcount != (size_t)-1 && JSON_INTERNAL_DECREF(json) == 0)
         json_delete(json);
 }
 
 #if defined(__GNUC__) || defined(__clang__)
-static JSON_INLINE
-void json_decrefp(json_t **json)
-{
-    if(json) {
+static JSON_INLINE void json_decrefp(json_t **json) {
+    if (json) {
         json_decref(*json);
-	*json = NULL;
+        *json = NULL;
     }
 }
 
 #define json_auto_t json_t __attribute__((cleanup(json_decrefp)))
 #endif
 
-
 /* error reporting */
 
-#define JSON_ERROR_TEXT_LENGTH    160
-#define JSON_ERROR_SOURCE_LENGTH   80
+#define JSON_ERROR_TEXT_LENGTH   160
+#define JSON_ERROR_SOURCE_LENGTH 80
 
 typedef struct json_error_t {
     int line;
@@ -191,7 +186,8 @@ static JSON_INLINE enum json_error_code json_error_code(const json_error_t *e) {
 
 void json_object_seed(size_t seed);
 size_t json_object_size(const json_t *object);
-json_t *json_object_get(const json_t *object, const char *key) JANSSON_ATTRS((warn_unused_result));
+json_t *json_object_get(const json_t *object, const char *key)
+    JANSSON_ATTRS((warn_unused_result));
 int json_object_set_new(json_t *object, const char *key, json_t *value);
 int json_object_set_new_nocheck(json_t *object, const char *key, json_t *value);
 int json_object_del(json_t *object, const char *key);
@@ -208,67 +204,58 @@ const char *json_object_iter_key(void *iter);
 json_t *json_object_iter_value(void *iter);
 int json_object_iter_set_new(json_t *object, void *iter, json_t *value);
 
-#define json_object_foreach(object, key, value) \
-    for(key = json_object_iter_key(json_object_iter(object)); \
-        key && (value = json_object_iter_value(json_object_key_to_iter(key))); \
-        key = json_object_iter_key(json_object_iter_next(object, json_object_key_to_iter(key))))
-
-#define json_object_foreach_safe(object, n, key, value)     \
-    for(key = json_object_iter_key(json_object_iter(object)), \
-            n = json_object_iter_next(object, json_object_key_to_iter(key)); \
-        key && (value = json_object_iter_value(json_object_key_to_iter(key))); \
-        key = json_object_iter_key(n), \
-            n = json_object_iter_next(object, json_object_key_to_iter(key)))
-
-#define json_array_foreach(array, index, value) \
-	for(index = 0; \
-		index < json_array_size(array) && (value = json_array_get(array, index)); \
-		index++)
-
-static JSON_INLINE
-int json_object_set(json_t *object, const char *key, json_t *value)
-{
+#define json_object_foreach(object, key, value)                                          \
+    for (key = json_object_iter_key(json_object_iter(object));                           \
+         key && (value = json_object_iter_value(json_object_key_to_iter(key)));          \
+         key = json_object_iter_key(                                                     \
+             json_object_iter_next(object, json_object_key_to_iter(key))))
+
+#define json_object_foreach_safe(object, n, key, value)                                  \
+    for (key = json_object_iter_key(json_object_iter(object)),                           \
+        n = json_object_iter_next(object, json_object_key_to_iter(key));                 \
+         key && (value = json_object_iter_value(json_object_key_to_iter(key)));          \
+         key = json_object_iter_key(n),                                                  \
+        n = json_object_iter_next(object, json_object_key_to_iter(key)))
+
+#define json_array_foreach(array, index, value)                                          \
+    for (index = 0;                                                                      \
+         index < json_array_size(array) && (value = json_array_get(array, index));       \
+         index++)
+
+static JSON_INLINE int json_object_set(json_t *object, const char *key, json_t *value) {
     return json_object_set_new(object, key, json_incref(value));
 }
 
-static JSON_INLINE
-int json_object_set_nocheck(json_t *object, const char *key, json_t *value)
-{
+static JSON_INLINE int json_object_set_nocheck(json_t *object, const char *key,
+                                               json_t *value) {
     return json_object_set_new_nocheck(object, key, json_incref(value));
 }
 
-static JSON_INLINE
-int json_object_iter_set(json_t *object, void *iter, json_t *value)
-{
+static JSON_INLINE int json_object_iter_set(json_t *object, void *iter, json_t *value) {
     return json_object_iter_set_new(object, iter, json_incref(value));
 }
 
-static JSON_INLINE
-int json_object_update_new(json_t *object, json_t *other)
-{
+static JSON_INLINE int json_object_update_new(json_t *object, json_t *other) {
     int ret = json_object_update(object, other);
     json_decref(other);
     return ret;
 }
 
-static JSON_INLINE
-int json_object_update_existing_new(json_t *object, json_t *other)
-{
+static JSON_INLINE int json_object_update_existing_new(json_t *object, json_t *other) {
     int ret = json_object_update_existing(object, other);
     json_decref(other);
     return ret;
 }
 
-static JSON_INLINE
-int json_object_update_missing_new(json_t *object, json_t *other)
-{
+static JSON_INLINE int json_object_update_missing_new(json_t *object, json_t *other) {
     int ret = json_object_update_missing(object, other);
     json_decref(other);
     return ret;
 }
 
 size_t json_array_size(const json_t *array);
-json_t *json_array_get(const json_t *array, size_t index) JANSSON_ATTRS((warn_unused_result));
+json_t *json_array_get(const json_t *array, size_t index)
+    JANSSON_ATTRS((warn_unused_result));
 int json_array_set_new(json_t *array, size_t index, json_t *value);
 int json_array_append_new(json_t *array, json_t *value);
 int json_array_insert_new(json_t *array, size_t index, json_t *value);
@@ -276,21 +263,15 @@ int json_array_remove(json_t *array, size_t index);
 int json_array_clear(json_t *array);
 int json_array_extend(json_t *array, json_t *other);
 
-static JSON_INLINE
-int json_array_set(json_t *array, size_t ind, json_t *value)
-{
+static JSON_INLINE int json_array_set(json_t *array, size_t ind, json_t *value) {
     return json_array_set_new(array, ind, json_incref(value));
 }
 
-static JSON_INLINE
-int json_array_append(json_t *array, json_t *value)
-{
+static JSON_INLINE int json_array_append(json_t *array, json_t *value) {
     return json_array_append_new(array, json_incref(value));
 }
 
-static JSON_INLINE
-int json_array_insert(json_t *array, size_t ind, json_t *value)
-{
+static JSON_INLINE int json_array_insert(json_t *array, size_t ind, json_t *value) {
     return json_array_insert_new(array, ind, json_incref(value));
 }
 
@@ -310,33 +291,35 @@ int json_real_set(json_t *real, double value);
 /* pack, unpack */
 
 json_t *json_pack(const char *fmt, ...) JANSSON_ATTRS((warn_unused_result));
-json_t *json_pack_ex(json_error_t *error, size_t flags, const char *fmt, ...) JANSSON_ATTRS((warn_unused_result));
-json_t *json_vpack_ex(json_error_t *error, size_t flags, const char *fmt, va_list ap) JANSSON_ATTRS((warn_unused_result));
+json_t *json_pack_ex(json_error_t *error, size_t flags, const char *fmt, ...)
+    JANSSON_ATTRS((warn_unused_result));
+json_t *json_vpack_ex(json_error_t *error, size_t flags, const char *fmt, va_list ap)
+    JANSSON_ATTRS((warn_unused_result));
 
-#define JSON_VALIDATE_ONLY  0x1
-#define JSON_STRICT         0x2
+#define JSON_VALIDATE_ONLY 0x1
+#define JSON_STRICT        0x2
 
 int json_unpack(json_t *root, const char *fmt, ...);
 int json_unpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, ...);
-int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, va_list ap);
+int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt,
+                    va_list ap);
 
 /* sprintf */
 
-json_t *json_sprintf(const char *fmt, ...) JANSSON_ATTRS((warn_unused_result, format(printf, 1, 2)));
-json_t *json_vsprintf(const char *fmt, va_list ap) JANSSON_ATTRS((warn_unused_result, format(printf, 1, 0)));
-
+json_t *json_sprintf(const char *fmt, ...)
+    JANSSON_ATTRS((warn_unused_result, format(printf, 1, 2)));
+json_t *json_vsprintf(const char *fmt, va_list ap)
+    JANSSON_ATTRS((warn_unused_result, format(printf, 1, 0)));
 
 /* equality */
 
 int json_equal(const json_t *value1, const json_t *value2);
 
-
 /* copying */
 
 json_t *json_copy(json_t *value) JANSSON_ATTRS((warn_unused_result));
 json_t *json_deep_copy(const json_t *value) JANSSON_ATTRS((warn_unused_result));
 
-
 /* decoding */
 
 #define JSON_REJECT_DUPLICATES  0x1
@@ -347,26 +330,31 @@ json_t *json_deep_copy(const json_t *value) JANSSON_ATTRS((warn_unused_result));
 
 typedef size_t (*json_load_callback_t)(void *buffer, size_t buflen, void *data);
 
-json_t *json_loads(const char *input, size_t flags, json_error_t *error) JANSSON_ATTRS((warn_unused_result));
-json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t *error) JANSSON_ATTRS((warn_unused_result));
-json_t *json_loadf(FILE *input, size_t flags, json_error_t *error) JANSSON_ATTRS((warn_unused_result));
-json_t *json_loadfd(int input, size_t flags, json_error_t *error) JANSSON_ATTRS((warn_unused_result));
-json_t *json_load_file(const char *path, size_t flags, json_error_t *error) JANSSON_ATTRS((warn_unused_result));
-json_t *json_load_callback(json_load_callback_t callback, void *data, size_t flags, json_error_t *error) JANSSON_ATTRS((warn_unused_result));
-
+json_t *json_loads(const char *input, size_t flags, json_error_t *error)
+    JANSSON_ATTRS((warn_unused_result));
+json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t *error)
+    JANSSON_ATTRS((warn_unused_result));
+json_t *json_loadf(FILE *input, size_t flags, json_error_t *error)
+    JANSSON_ATTRS((warn_unused_result));
+json_t *json_loadfd(int input, size_t flags, json_error_t *error)
+    JANSSON_ATTRS((warn_unused_result));
+json_t *json_load_file(const char *path, size_t flags, json_error_t *error)
+    JANSSON_ATTRS((warn_unused_result));
+json_t *json_load_callback(json_load_callback_t callback, void *data, size_t flags,
+                           json_error_t *error) JANSSON_ATTRS((warn_unused_result));
 
 /* encoding */
 
-#define JSON_MAX_INDENT         0x1F
-#define JSON_INDENT(n)          ((n) & JSON_MAX_INDENT)
-#define JSON_COMPACT            0x20
-#define JSON_ENSURE_ASCII       0x40
-#define JSON_SORT_KEYS          0x80
-#define JSON_PRESERVE_ORDER     0x100
-#define JSON_ENCODE_ANY         0x200
-#define JSON_ESCAPE_SLASH       0x400
-#define JSON_REAL_PRECISION(n)  (((n) & 0x1F) << 11)
-#define JSON_EMBED              0x10000
+#define JSON_MAX_INDENT        0x1F
+#define JSON_INDENT(n)         ((n)&JSON_MAX_INDENT)
+#define JSON_COMPACT           0x20
+#define JSON_ENSURE_ASCII      0x40
+#define JSON_SORT_KEYS         0x80
+#define JSON_PRESERVE_ORDER    0x100
+#define JSON_ENCODE_ANY        0x200
+#define JSON_ESCAPE_SLASH      0x400
+#define JSON_REAL_PRECISION(n) (((n)&0x1F) << 11)
+#define JSON_EMBED             0x10000
 
 typedef int (*json_dump_callback_t)(const char *buffer, size_t size, void *data);
 
@@ -375,7 +363,8 @@ size_t json_dumpb(const json_t *json, char *buffer, size_t size, size_t flags);
 int json_dumpf(const json_t *json, FILE *output, size_t flags);
 int json_dumpfd(const json_t *json, int output, size_t flags);
 int json_dump_file(const json_t *json, const char *path, size_t flags);
-int json_dump_callback(const json_t *json, json_dump_callback_t callback, void *data, size_t flags);
+int json_dump_callback(const json_t *json, json_dump_callback_t callback, void *data,
+                       size_t flags);
 
 /* custom memory allocation */
 
diff --git a/src/jansson_private.h b/src/jansson_private.h
index 42882a8..d3b2a64 100644
--- a/src/jansson_private.h
+++ b/src/jansson_private.h
@@ -8,18 +8,18 @@
 #ifndef JANSSON_PRIVATE_H
 #define JANSSON_PRIVATE_H
 
-#include "jansson_private_config.h"
-#include <stddef.h>
-#include "jansson.h"
 #include "hashtable.h"
+#include "jansson.h"
+#include "jansson_private_config.h"
 #include "strbuffer.h"
+#include <stddef.h>
 
-#define container_of(ptr_, type_, member_)  \
+#define container_of(ptr_, type_, member_)                                               \
     ((type_ *)((char *)ptr_ - offsetof(type_, member_)))
 
 /* On some platforms, max() may already be defined */
 #ifndef max
-#define max(a, b)  ((a) > (b) ? (a) : (b))
+#define max(a, b) ((a) > (b) ? (a) : (b))
 #endif
 
 /* va_copy is a C99 feature. In C89 implementations, it's sometimes
@@ -28,7 +28,7 @@
 #ifdef __va_copy
 #define va_copy __va_copy
 #else
-#define va_copy(a, b)  memcpy(&(a), &(b), sizeof(va_list))
+#define va_copy(a, b) memcpy(&(a), &(b), sizeof(va_list))
 #endif
 #endif
 
@@ -72,19 +72,17 @@ json_t *jsonp_stringn_nocheck_own(const char *value, size_t len);
 /* Error message formatting */
 void jsonp_error_init(json_error_t *error, const char *source);
 void jsonp_error_set_source(json_error_t *error, const char *source);
-void jsonp_error_set(json_error_t *error, int line, int column,
-                     size_t position, enum json_error_code code,
-                     const char *msg, ...);
-void jsonp_error_vset(json_error_t *error, int line, int column,
-                      size_t position, enum json_error_code code,
-                      const char *msg, va_list ap);
+void jsonp_error_set(json_error_t *error, int line, int column, size_t position,
+                     enum json_error_code code, const char *msg, ...);
+void jsonp_error_vset(json_error_t *error, int line, int column, size_t position,
+                      enum json_error_code code, const char *msg, va_list ap);
 
 /* Locale independent string<->double conversions */
 int jsonp_strtod(strbuffer_t *strbuffer, double *out);
 int jsonp_dtostr(char *buffer, size_t size, double value, int prec);
 
 /* Wrappers for custom memory functions */
-void* jsonp_malloc(size_t size) JANSSON_ATTRS((warn_unused_result));
+void *jsonp_malloc(size_t size) JANSSON_ATTRS((warn_unused_result));
 void jsonp_free(void *ptr);
 char *jsonp_strndup(const char *str, size_t length) JANSSON_ATTRS((warn_unused_result));
 char *jsonp_strdup(const char *str) JANSSON_ATTRS((warn_unused_result));
@@ -93,22 +91,24 @@ char *jsonp_strndup(const char *str, size_t len) JANSSON_ATTRS((warn_unused_resu
 /* Circular reference check*/
 /* Space for "0x", double the sizeof a pointer for the hex and a terminator. */
 #define LOOP_KEY_LEN (2 + (sizeof(json_t *) * 2) + 1)
-int jsonp_loop_check(hashtable_t *parents, const json_t *json, char *key, size_t key_size);
-
+int jsonp_loop_check(hashtable_t *parents, const json_t *json, char *key,
+                     size_t key_size);
 
 /* Windows compatibility */
 #if defined(_WIN32) || defined(WIN32)
-#  if defined(_MSC_VER)  /* MS compiller */
-#    if (_MSC_VER < 1900) && !defined(snprintf)  /* snprintf not defined yet & not introduced */
-#      define snprintf _snprintf
-#    endif
-#    if (_MSC_VER < 1500) && !defined(vsnprintf)  /* vsnprintf not defined yet & not introduced */
-#      define vsnprintf(b,c,f,a) _vsnprintf(b,c,f,a)
-#    endif
-#  else  /* Other Windows compiller, old definition */
-#    define snprintf _snprintf
-#    define vsnprintf _vsnprintf
-#  endif
+#if defined(_MSC_VER) /* MS compiller */
+#if (_MSC_VER < 1900) &&                                                                 \
+    !defined(snprintf) /* snprintf not defined yet & not introduced */
+#define snprintf _snprintf
+#endif
+#if (_MSC_VER < 1500) &&                                                                 \
+    !defined(vsnprintf) /* vsnprintf not defined yet & not introduced */
+#define vsnprintf(b, c, f, a) _vsnprintf(b, c, f, a)
+#endif
+#else /* Other Windows compiller, old definition */
+#define snprintf  _snprintf
+#define vsnprintf _vsnprintf
+#endif
 #endif
 
 #endif
diff --git a/src/load.c b/src/load.c
index 8700919..ea6692f 100644
--- a/src/load.c
+++ b/src/load.c
@@ -11,12 +11,12 @@
 
 #include "jansson_private.h"
 
+#include <assert.h>
 #include <errno.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
@@ -25,25 +25,25 @@
 #include "strbuffer.h"
 #include "utf.h"
 
-#define STREAM_STATE_OK        0
-#define STREAM_STATE_EOF      -1
-#define STREAM_STATE_ERROR    -2
+#define STREAM_STATE_OK    0
+#define STREAM_STATE_EOF   -1
+#define STREAM_STATE_ERROR -2
 
-#define TOKEN_INVALID         -1
-#define TOKEN_EOF              0
-#define TOKEN_STRING         256
-#define TOKEN_INTEGER        257
-#define TOKEN_REAL           258
-#define TOKEN_TRUE           259
-#define TOKEN_FALSE          260
-#define TOKEN_NULL           261
+#define TOKEN_INVALID -1
+#define TOKEN_EOF     0
+#define TOKEN_STRING  256
+#define TOKEN_INTEGER 257
+#define TOKEN_REAL    258
+#define TOKEN_TRUE    259
+#define TOKEN_FALSE   260
+#define TOKEN_NULL    261
 
 /* Locale independent versions of isxxx() functions */
-#define l_isupper(c)  ('A' <= (c) && (c) <= 'Z')
-#define l_islower(c)  ('a' <= (c) && (c) <= 'z')
-#define l_isalpha(c)  (l_isupper(c) || l_islower(c))
-#define l_isdigit(c)  ('0' <= (c) && (c) <= '9')
-#define l_isxdigit(c) \
+#define l_isupper(c) ('A' <= (c) && (c) <= 'Z')
+#define l_islower(c) ('a' <= (c) && (c) <= 'z')
+#define l_isalpha(c) (l_isupper(c) || l_islower(c))
+#define l_isdigit(c) ('0' <= (c) && (c) <= '9')
+#define l_isxdigit(c)                                                                    \
     (l_isdigit(c) || ('A' <= (c) && (c) <= 'F') || ('a' <= (c) && (c) <= 'f'))
 
 /* Read one byte from stream, convert to unsigned char, then int, and
@@ -80,13 +80,10 @@ typedef struct {
 
 #define stream_to_lex(stream) container_of(stream, lex_t, stream)
 
-
 /*** error reporting ***/
 
-static void error_set(json_error_t *error, const lex_t *lex,
-                      enum json_error_code code,
-                      const char *msg, ...)
-{
+static void error_set(json_error_t *error, const lex_t *lex, enum json_error_code code,
+                      const char *msg, ...) {
     va_list ap;
     char msg_text[JSON_ERROR_TEXT_LENGTH];
     char msg_with_context[JSON_ERROR_TEXT_LENGTH];
@@ -95,7 +92,7 @@ static void error_set(json_error_t *error, const lex_t *lex,
     size_t pos = 0;
     const char *result = msg_text;
 
-    if(!error)
+    if (!error)
         return;
 
     va_start(ap, msg);
@@ -103,36 +100,31 @@ static void error_set(json_error_t *error, const lex_t *lex,
     msg_text[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
     va_end(ap);
 
-    if(lex)
-    {
+    if (lex) {
         const char *saved_text = strbuffer_value(&lex->saved_text);
 
         line = lex->stream.line;
         col = lex->stream.column;
         pos = lex->stream.position;
 
-        if(saved_text && saved_text[0])
-        {
-            if(lex->saved_text.length <= 20) {
-                snprintf(msg_with_context, JSON_ERROR_TEXT_LENGTH,
-                         "%s near '%s'", msg_text, saved_text);
+        if (saved_text && saved_text[0]) {
+            if (lex->saved_text.length <= 20) {
+                snprintf(msg_with_context, JSON_ERROR_TEXT_LENGTH, "%s near '%s'",
+                         msg_text, saved_text);
                 msg_with_context[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
                 result = msg_with_context;
             }
-        }
-        else
-        {
-            if(code == json_error_invalid_syntax) {
+        } else {
+            if (code == json_error_invalid_syntax) {
                 /* More specific error code for premature end of file. */
                 code = json_error_premature_end_of_input;
             }
-            if(lex->stream.state == STREAM_STATE_ERROR) {
+            if (lex->stream.state == STREAM_STATE_ERROR) {
                 /* No context for UTF-8 decoding errors */
                 result = msg_text;
-            }
-            else {
-                snprintf(msg_with_context, JSON_ERROR_TEXT_LENGTH,
-                         "%s near end of file", msg_text);
+            } else {
+                snprintf(msg_with_context, JSON_ERROR_TEXT_LENGTH, "%s near end of file",
+                         msg_text);
                 msg_with_context[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
                 result = msg_with_context;
             }
@@ -142,12 +134,9 @@ static void error_set(json_error_t *error, const lex_t *lex,
     jsonp_error_set(error, line, col, pos, code, "%s", result);
 }
 
-
 /*** lexical analyzer ***/
 
-static void
-stream_init(stream_t *stream, get_func get, void *data)
-{
+static void stream_init(stream_t *stream, get_func get, void *data) {
     stream->get = get;
     stream->data = data;
     stream->buffer[0] = '\0';
@@ -159,17 +148,15 @@ stream_init(stream_t *stream, get_func get, void *data)
     stream->position = 0;
 }
 
-static int stream_get(stream_t *stream, json_error_t *error)
-{
+static int stream_get(stream_t *stream, json_error_t *error) {
     int c;
 
-    if(stream->state != STREAM_STATE_OK)
+    if (stream->state != STREAM_STATE_OK)
         return stream->state;
 
-    if(!stream->buffer[stream->buffer_pos])
-    {
+    if (!stream->buffer[stream->buffer_pos]) {
         c = stream->get(stream->data);
-        if(c == EOF) {
+        if (c == EOF) {
             stream->state = STREAM_STATE_EOF;
             return STREAM_STATE_EOF;
         }
@@ -177,38 +164,35 @@ static int stream_get(stream_t *stream, json_error_t *error)
         stream->buffer[0] = c;
         stream->buffer_pos = 0;
 
-        if(0x80 <= c && c <= 0xFF)
-        {
+        if (0x80 <= c && c <= 0xFF) {
             /* multi-byte UTF-8 sequence */
             size_t i, count;
 
             count = utf8_check_first(c);
-            if(!count)
+            if (!count)
                 goto out;
 
             assert(count >= 2);
 
-            for(i = 1; i < count; i++)
+            for (i = 1; i < count; i++)
                 stream->buffer[i] = stream->get(stream->data);
 
-            if(!utf8_check_full(stream->buffer, count, NULL))
+            if (!utf8_check_full(stream->buffer, count, NULL))
                 goto out;
 
             stream->buffer[count] = '\0';
-        }
-        else
+        } else
             stream->buffer[1] = '\0';
     }
 
     c = stream->buffer[stream->buffer_pos++];
 
     stream->position++;
-    if(c == '\n') {
+    if (c == '\n') {
         stream->line++;
         stream->last_column = stream->column;
         stream->column = 0;
-    }
-    else if(utf8_check_first(c)) {
+    } else if (utf8_check_first(c)) {
         /* track the Unicode character column, so increment only if
            this is the first character of a UTF-8 sequence */
         stream->column++;
@@ -218,21 +202,20 @@ static int stream_get(stream_t *stream, json_error_t *error)
 
 out:
     stream->state = STREAM_STATE_ERROR;
-    error_set(error, stream_to_lex(stream), json_error_invalid_utf8, "unable to decode byte 0x%x", c);
+    error_set(error, stream_to_lex(stream), json_error_invalid_utf8,
+              "unable to decode byte 0x%x", c);
     return STREAM_STATE_ERROR;
 }
 
-static void stream_unget(stream_t *stream, int c)
-{
-    if(c == STREAM_STATE_EOF || c == STREAM_STATE_ERROR)
+static void stream_unget(stream_t *stream, int c) {
+    if (c == STREAM_STATE_EOF || c == STREAM_STATE_ERROR)
         return;
 
     stream->position--;
-    if(c == '\n') {
+    if (c == '\n') {
         stream->line--;
         stream->column = stream->last_column;
-    }
-    else if(utf8_check_first(c))
+    } else if (utf8_check_first(c))
         stream->column--;
 
     assert(stream->buffer_pos > 0);
@@ -240,82 +223,68 @@ static void stream_unget(stream_t *stream, int c)
     assert(stream->buffer[stream->buffer_pos] == c);
 }
 
-
-static int lex_get(lex_t *lex, json_error_t *error)
-{
+static int lex_get(lex_t *lex, json_error_t *error) {
     return stream_get(&lex->stream, error);
 }
 
-static void lex_save(lex_t *lex, int c)
-{
-    strbuffer_append_byte(&lex->saved_text, c);
-}
+static void lex_save(lex_t *lex, int c) { strbuffer_append_byte(&lex->saved_text, c); }
 
-static int lex_get_save(lex_t *lex, json_error_t *error)
-{
+static int lex_get_save(lex_t *lex, json_error_t *error) {
     int c = stream_get(&lex->stream, error);
-    if(c != STREAM_STATE_EOF && c != STREAM_STATE_ERROR)
+    if (c != STREAM_STATE_EOF && c != STREAM_STATE_ERROR)
         lex_save(lex, c);
     return c;
 }
 
-static void lex_unget(lex_t *lex, int c)
-{
-    stream_unget(&lex->stream, c);
-}
+static void lex_unget(lex_t *lex, int c) { stream_unget(&lex->stream, c); }
 
-static void lex_unget_unsave(lex_t *lex, int c)
-{
-    if(c != STREAM_STATE_EOF && c != STREAM_STATE_ERROR) {
-        /* Since we treat warnings as errors, when assertions are turned
-         * off the "d" variable would be set but never used. Which is
-         * treated as an error by GCC.
-         */
-        #ifndef NDEBUG
+static void lex_unget_unsave(lex_t *lex, int c) {
+    if (c != STREAM_STATE_EOF && c != STREAM_STATE_ERROR) {
+/* Since we treat warnings as errors, when assertions are turned
+ * off the "d" variable would be set but never used. Which is
+ * treated as an error by GCC.
+ */
+#ifndef NDEBUG
         char d;
-        #endif
+#endif
         stream_unget(&lex->stream, c);
-        #ifndef NDEBUG
+#ifndef NDEBUG
         d =
-        #endif
+#endif
             strbuffer_pop(&lex->saved_text);
         assert(c == d);
     }
 }
 
-static void lex_save_cached(lex_t *lex)
-{
-    while(lex->stream.buffer[lex->stream.buffer_pos] != '\0')
-    {
+static void lex_save_cached(lex_t *lex) {
+    while (lex->stream.buffer[lex->stream.buffer_pos] != '\0') {
         lex_save(lex, lex->stream.buffer[lex->stream.buffer_pos]);
         lex->stream.buffer_pos++;
         lex->stream.position++;
     }
 }
 
-static void lex_free_string(lex_t *lex)
-{
+static void lex_free_string(lex_t *lex) {
     jsonp_free(lex->value.string.val);
     lex->value.string.val = NULL;
     lex->value.string.len = 0;
 }
 
 /* assumes that str points to 'u' plus at least 4 valid hex digits */
-static int32_t decode_unicode_escape(const char *str)
-{
+static int32_t decode_unicode_escape(const char *str) {
     int i;
     int32_t value = 0;
 
     assert(str[0] == 'u');
 
-    for(i = 1; i <= 4; i++) {
+    for (i = 1; i <= 4; i++) {
         char c = str[i];
         value <<= 4;
-        if(l_isdigit(c))
+        if (l_isdigit(c))
             value += c - '0';
-        else if(l_islower(c))
+        else if (l_islower(c))
             value += c - 'a' + 10;
-        else if(l_isupper(c))
+        else if (l_isupper(c))
             value += c - 'A' + 10;
         else
             return -1;
@@ -324,8 +293,7 @@ static int32_t decode_unicode_escape(const char *str)
     return value;
 }
 
-static void lex_scan_string(lex_t *lex, json_error_t *error)
-{
+static void lex_scan_string(lex_t *lex, json_error_t *error) {
     int c;
     const char *p;
     char *t;
@@ -336,46 +304,47 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
 
     c = lex_get_save(lex, error);
 
-    while(c != '"') {
-        if(c == STREAM_STATE_ERROR)
+    while (c != '"') {
+        if (c == STREAM_STATE_ERROR)
             goto out;
 
-        else if(c == STREAM_STATE_EOF) {
-            error_set(error, lex, json_error_premature_end_of_input, "premature end of input");
+        else if (c == STREAM_STATE_EOF) {
+            error_set(error, lex, json_error_premature_end_of_input,
+                      "premature end of input");
             goto out;
         }
 
-        else if(0 <= c && c <= 0x1F) {
+        else if (0 <= c && c <= 0x1F) {
             /* control character */
             lex_unget_unsave(lex, c);
-            if(c == '\n')
+            if (c == '\n')
                 error_set(error, lex, json_error_invalid_syntax, "unexpected newline");
             else
-                error_set(error, lex, json_error_invalid_syntax, "control character 0x%x", c);
+                error_set(error, lex, json_error_invalid_syntax, "control character 0x%x",
+                          c);
             goto out;
         }
 
-        else if(c == '\\') {
+        else if (c == '\\') {
             c = lex_get_save(lex, error);
-            if(c == 'u') {
+            if (c == 'u') {
                 c = lex_get_save(lex, error);
-                for(i = 0; i < 4; i++) {
-                    if(!l_isxdigit(c)) {
-                        error_set(error, lex, json_error_invalid_syntax, "invalid escape");
+                for (i = 0; i < 4; i++) {
+                    if (!l_isxdigit(c)) {
+                        error_set(error, lex, json_error_invalid_syntax,
+                                  "invalid escape");
                         goto out;
                     }
                     c = lex_get_save(lex, error);
                 }
-            }
-            else if(c == '"' || c == '\\' || c == '/' || c == 'b' ||
-                    c == 'f' || c == 'n' || c == 'r' || c == 't')
+            } else if (c == '"' || c == '\\' || c == '/' || c == 'b' || c == 'f' ||
+                       c == 'n' || c == 'r' || c == 't')
                 c = lex_get_save(lex, error);
             else {
                 error_set(error, lex, json_error_invalid_syntax, "invalid escape");
                 goto out;
             }
-        }
-        else
+        } else
             c = lex_get_save(lex, error);
     }
 
@@ -387,7 +356,7 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
            are converted to 4 bytes
     */
     t = jsonp_malloc(lex->saved_text.length + 1);
-    if(!t) {
+    if (!t) {
         /* this is not very nice, since TOKEN_INVALID is returned */
         goto out;
     }
@@ -396,78 +365,86 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
     /* + 1 to skip the " */
     p = strbuffer_value(&lex->saved_text) + 1;
 
-    while(*p != '"') {
-        if(*p == '\\') {
+    while (*p != '"') {
+        if (*p == '\\') {
             p++;
-            if(*p == 'u') {
+            if (*p == 'u') {
                 size_t length;
                 int32_t value;
 
                 value = decode_unicode_escape(p);
-                if(value < 0) {
-                    error_set(error, lex, json_error_invalid_syntax, "invalid Unicode escape '%.6s'", p - 1);
+                if (value < 0) {
+                    error_set(error, lex, json_error_invalid_syntax,
+                              "invalid Unicode escape '%.6s'", p - 1);
                     goto out;
                 }
                 p += 5;
 
-                if(0xD800 <= value && value <= 0xDBFF) {
+                if (0xD800 <= value && value <= 0xDBFF) {
                     /* surrogate pair */
-                    if(*p == '\\' && *(p + 1) == 'u') {
+                    if (*p == '\\' && *(p + 1) == 'u') {
                         int32_t value2 = decode_unicode_escape(++p);
-                        if(value2 < 0) {
-                            error_set(error, lex, json_error_invalid_syntax, "invalid Unicode escape '%.6s'", p - 1);
+                        if (value2 < 0) {
+                            error_set(error, lex, json_error_invalid_syntax,
+                                      "invalid Unicode escape '%.6s'", p - 1);
                             goto out;
                         }
                         p += 5;
 
-                        if(0xDC00 <= value2 && value2 <= 0xDFFF) {
+                        if (0xDC00 <= value2 && value2 <= 0xDFFF) {
                             /* valid second surrogate */
                             value =
-                                ((value - 0xD800) << 10) +
-                                (value2 - 0xDC00) +
-                                0x10000;
-                        }
-                        else {
+                                ((value - 0xD800) << 10) + (value2 - 0xDC00) + 0x10000;
+                        } else {
                             /* invalid second surrogate */
-                            error_set(error, lex,
-                                      json_error_invalid_syntax,
-                                      "invalid Unicode '\\u%04X\\u%04X'",
-                                      value, value2);
+                            error_set(error, lex, json_error_invalid_syntax,
+                                      "invalid Unicode '\\u%04X\\u%04X'", value, value2);
                             goto out;
                         }
-                    }
-                    else {
+                    } else {
                         /* no second surrogate */
-                        error_set(error, lex, json_error_invalid_syntax, "invalid Unicode '\\u%04X'",
-                                  value);
+                        error_set(error, lex, json_error_invalid_syntax,
+                                  "invalid Unicode '\\u%04X'", value);
                         goto out;
                     }
-                }
-                else if(0xDC00 <= value && value <= 0xDFFF) {
-                    error_set(error, lex, json_error_invalid_syntax, "invalid Unicode '\\u%04X'", value);
+                } else if (0xDC00 <= value && value <= 0xDFFF) {
+                    error_set(error, lex, json_error_invalid_syntax,
+                              "invalid Unicode '\\u%04X'", value);
                     goto out;
                 }
 
-                if(utf8_encode(value, t, &length))
+                if (utf8_encode(value, t, &length))
                     assert(0);
                 t += length;
-            }
-            else {
-                switch(*p) {
-                    case '"': case '\\': case '/':
-                        *t = *p; break;
-                    case 'b': *t = '\b'; break;
-                    case 'f': *t = '\f'; break;
-                    case 'n': *t = '\n'; break;
-                    case 'r': *t = '\r'; break;
-                    case 't': *t = '\t'; break;
-                    default: assert(0);
+            } else {
+                switch (*p) {
+                    case '"':
+                    case '\\':
+                    case '/':
+                        *t = *p;
+                        break;
+                    case 'b':
+                        *t = '\b';
+                        break;
+                    case 'f':
+                        *t = '\f';
+                        break;
+                    case 'n':
+                        *t = '\n';
+                        break;
+                    case 'r':
+                        *t = '\r';
+                        break;
+                    case 't':
+                        *t = '\t';
+                        break;
+                    default:
+                        assert(0);
                 }
                 t++;
                 p++;
             }
-        }
-        else
+        } else
             *(t++) = *(p++);
     }
     *t = '\0';
@@ -481,47 +458,42 @@ out:
 
 #ifndef JANSSON_USING_CMAKE /* disabled if using cmake */
 #if JSON_INTEGER_IS_LONG_LONG
-#ifdef _MSC_VER  /* Microsoft Visual Studio */
-#define json_strtoint     _strtoi64
+#ifdef _MSC_VER /* Microsoft Visual Studio */
+#define json_strtoint _strtoi64
 #else
-#define json_strtoint     strtoll
+#define json_strtoint strtoll
 #endif
 #else
-#define json_strtoint     strtol
+#define json_strtoint strtol
 #endif
 #endif
 
-static int lex_scan_number(lex_t *lex, int c, json_error_t *error)
-{
+static int lex_scan_number(lex_t *lex, int c, json_error_t *error) {
     const char *saved_text;
     char *end;
     double doubleval;
 
     lex->token = TOKEN_INVALID;
 
-    if(c == '-')
+    if (c == '-')
         c = lex_get_save(lex, error);
 
-    if(c == '0') {
+    if (c == '0') {
         c = lex_get_save(lex, error);
-        if(l_isdigit(c)) {
+        if (l_isdigit(c)) {
             lex_unget_unsave(lex, c);
             goto out;
         }
-    }
-    else if(l_isdigit(c)) {
+    } else if (l_isdigit(c)) {
         do
             c = lex_get_save(lex, error);
-        while(l_isdigit(c));
-    }
-    else {
+        while (l_isdigit(c));
+    } else {
         lex_unget_unsave(lex, c);
         goto out;
     }
 
-    if(!(lex->flags & JSON_DECODE_INT_AS_REAL) &&
-       c != '.' && c != 'E' && c != 'e')
-    {
+    if (!(lex->flags & JSON_DECODE_INT_AS_REAL) && c != '.' && c != 'E' && c != 'e') {
         json_int_t intval;
 
         lex_unget_unsave(lex, c);
@@ -530,9 +502,10 @@ static int lex_scan_number(lex_t *lex, int c, json_error_t *error)
 
         errno = 0;
         intval = json_strtoint(saved_text, &end, 10);
-        if(errno == ERANGE) {
-            if(intval < 0)
-                error_set(error, lex, json_error_numeric_overflow, "too big negative integer");
+        if (errno == ERANGE) {
+            if (intval < 0)
+                error_set(error, lex, json_error_numeric_overflow,
+                          "too big negative integer");
             else
                 error_set(error, lex, json_error_numeric_overflow, "too big integer");
             goto out;
@@ -545,9 +518,9 @@ static int lex_scan_number(lex_t *lex, int c, json_error_t *error)
         return 0;
     }
 
-    if(c == '.') {
+    if (c == '.') {
         c = lex_get(lex, error);
-        if(!l_isdigit(c)) {
+        if (!l_isdigit(c)) {
             lex_unget(lex, c);
             goto out;
         }
@@ -555,27 +528,27 @@ static int lex_scan_number(lex_t *lex, int c, json_error_t *error)
 
         do
             c = lex_get_save(lex, error);
-        while(l_isdigit(c));
+        while (l_isdigit(c));
     }
 
-    if(c == 'E' || c == 'e') {
+    if (c == 'E' || c == 'e') {
         c = lex_get_save(lex, error);
-        if(c == '+' || c == '-')
+        if (c == '+' || c == '-')
             c = lex_get_save(lex, error);
 
-        if(!l_isdigit(c)) {
+        if (!l_isdigit(c)) {
             lex_unget_unsave(lex, c);
             goto out;
         }
 
         do
             c = lex_get_save(lex, error);
-        while(l_isdigit(c));
+        while (l_isdigit(c));
     }
 
     lex_unget_unsave(lex, c);
 
-    if(jsonp_strtod(&lex->saved_text, &doubleval)) {
+    if (jsonp_strtod(&lex->saved_text, &doubleval)) {
         error_set(error, lex, json_error_numeric_overflow, "real number overflow");
         goto out;
     }
@@ -588,58 +561,57 @@ out:
     return -1;
 }
 
-static int lex_scan(lex_t *lex, json_error_t *error)
-{
+static int lex_scan(lex_t *lex, json_error_t *error) {
     int c;
 
     strbuffer_clear(&lex->saved_text);
 
-    if(lex->token == TOKEN_STRING)
+    if (lex->token == TOKEN_STRING)
         lex_free_string(lex);
 
     do
         c = lex_get(lex, error);
-    while(c == ' ' || c == '\t' || c == '\n' || c == '\r');
+    while (c == ' ' || c == '\t' || c == '\n' || c == '\r');
 
-    if(c == STREAM_STATE_EOF) {
+    if (c == STREAM_STATE_EOF) {
         lex->token = TOKEN_EOF;
         goto out;
     }
 
-    if(c == STREAM_STATE_ERROR) {
+    if (c == STREAM_STATE_ERROR) {
         lex->token = TOKEN_INVALID;
         goto out;
     }
 
     lex_save(lex, c);
 
-    if(c == '{' || c == '}' || c == '[' || c == ']' || c == ':' || c == ',')
+    if (c == '{' || c == '}' || c == '[' || c == ']' || c == ':' || c == ',')
         lex->token = c;
 
-    else if(c == '"')
+    else if (c == '"')
         lex_scan_string(lex, error);
 
-    else if(l_isdigit(c) || c == '-') {
-        if(lex_scan_number(lex, c, error))
+    else if (l_isdigit(c) || c == '-') {
+        if (lex_scan_number(lex, c, error))
             goto out;
     }
 
-    else if(l_isalpha(c)) {
+    else if (l_isalpha(c)) {
         /* eat up the whole identifier for clearer error messages */
         const char *saved_text;
 
         do
             c = lex_get_save(lex, error);
-        while(l_isalpha(c));
+        while (l_isalpha(c));
         lex_unget_unsave(lex, c);
 
         saved_text = strbuffer_value(&lex->saved_text);
 
-        if(strcmp(saved_text, "true") == 0)
+        if (strcmp(saved_text, "true") == 0)
             lex->token = TOKEN_TRUE;
-        else if(strcmp(saved_text, "false") == 0)
+        else if (strcmp(saved_text, "false") == 0)
             lex->token = TOKEN_FALSE;
-        else if(strcmp(saved_text, "null") == 0)
+        else if (strcmp(saved_text, "null") == 0)
             lex->token = TOKEN_NULL;
         else
             lex->token = TOKEN_INVALID;
@@ -656,10 +628,9 @@ out:
     return lex->token;
 }
 
-static char *lex_steal_string(lex_t *lex, size_t *out_len)
-{
+static char *lex_steal_string(lex_t *lex, size_t *out_len) {
     char *result = NULL;
-    if(lex->token == TOKEN_STRING) {
+    if (lex->token == TOKEN_STRING) {
         result = lex->value.string.val;
         *out_len = lex->value.string.len;
         lex->value.string.val = NULL;
@@ -668,10 +639,9 @@ static char *lex_steal_string(lex_t *lex, size_t *out_len)
     return result;
 }
 
-static int lex_init(lex_t *lex, get_func get, size_t flags, void *data)
-{
+static int lex_init(lex_t *lex, get_func get, size_t flags, void *data) {
     stream_init(&lex->stream, get, data);
-    if(strbuffer_init(&lex->saved_text))
+    if (strbuffer_init(&lex->saved_text))
         return -1;
 
     lex->flags = flags;
@@ -679,49 +649,47 @@ static int lex_init(lex_t *lex, get_func get, size_t flags, void *data)
     return 0;
 }
 
-static void lex_close(lex_t *lex)
-{
-    if(lex->token == TOKEN_STRING)
+static void lex_close(lex_t *lex) {
+    if (lex->token == TOKEN_STRING)
         lex_free_string(lex);
     strbuffer_close(&lex->saved_text);
 }
 
-
 /*** parser ***/
 
 static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error);
 
-static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
-{
+static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error) {
     json_t *object = json_object();
-    if(!object)
+    if (!object)
         return NULL;
 
     lex_scan(lex, error);
-    if(lex->token == '}')
+    if (lex->token == '}')
         return object;
 
-    while(1) {
+    while (1) {
         char *key;
         size_t len;
         json_t *value;
 
-        if(lex->token != TOKEN_STRING) {
+        if (lex->token != TOKEN_STRING) {
             error_set(error, lex, json_error_invalid_syntax, "string or '}' expected");
             goto error;
         }
 
         key = lex_steal_string(lex, &len);
-        if(!key)
+        if (!key)
             return NULL;
         if (memchr(key, '\0', len)) {
             jsonp_free(key);
-            error_set(error, lex, json_error_null_byte_in_key, "NUL byte in object key not supported");
+            error_set(error, lex, json_error_null_byte_in_key,
+                      "NUL byte in object key not supported");
             goto error;
         }
 
-        if(flags & JSON_REJECT_DUPLICATES) {
-            if(json_object_get(object, key)) {
+        if (flags & JSON_REJECT_DUPLICATES) {
+            if (json_object_get(object, key)) {
                 jsonp_free(key);
                 error_set(error, lex, json_error_duplicate_key, "duplicate object key");
                 goto error;
@@ -729,7 +697,7 @@ static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
         }
 
         lex_scan(lex, error);
-        if(lex->token != ':') {
+        if (lex->token != ':') {
             jsonp_free(key);
             error_set(error, lex, json_error_invalid_syntax, "':' expected");
             goto error;
@@ -737,12 +705,12 @@ static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
 
         lex_scan(lex, error);
         value = parse_value(lex, flags, error);
-        if(!value) {
+        if (!value) {
             jsonp_free(key);
             goto error;
         }
 
-        if(json_object_set_new_nocheck(object, key, value)) {
+        if (json_object_set_new_nocheck(object, key, value)) {
             jsonp_free(key);
             goto error;
         }
@@ -750,13 +718,13 @@ static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
         jsonp_free(key);
 
         lex_scan(lex, error);
-        if(lex->token != ',')
+        if (lex->token != ',')
             break;
 
         lex_scan(lex, error);
     }
 
-    if(lex->token != '}') {
+    if (lex->token != '}') {
         error_set(error, lex, json_error_invalid_syntax, "'}' expected");
         goto error;
     }
@@ -768,33 +736,32 @@ error:
     return NULL;
 }
 
-static json_t *parse_array(lex_t *lex, size_t flags, json_error_t *error)
-{
+static json_t *parse_array(lex_t *lex, size_t flags, json_error_t *error) {
     json_t *array = json_array();
-    if(!array)
+    if (!array)
         return NULL;
 
     lex_scan(lex, error);
-    if(lex->token == ']')
+    if (lex->token == ']')
         return array;
 
-    while(lex->token) {
+    while (lex->token) {
         json_t *elem = parse_value(lex, flags, error);
-        if(!elem)
+        if (!elem)
             goto error;
 
-        if(json_array_append_new(array, elem)) {
+        if (json_array_append_new(array, elem)) {
             goto error;
         }
 
         lex_scan(lex, error);
-        if(lex->token != ',')
+        if (lex->token != ',')
             break;
 
         lex_scan(lex, error);
     }
 
-    if(lex->token != ']') {
+    if (lex->token != ']') {
         error_set(error, lex, json_error_invalid_syntax, "']' expected");
         goto error;
     }
@@ -806,24 +773,24 @@ error:
     return NULL;
 }
 
-static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error)
-{
+static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error) {
     json_t *json;
 
     lex->depth++;
-    if(lex->depth > JSON_PARSER_MAX_DEPTH) {
+    if (lex->depth > JSON_PARSER_MAX_DEPTH) {
         error_set(error, lex, json_error_stack_overflow, "maximum parsing depth reached");
         return NULL;
     }
 
-    switch(lex->token) {
+    switch (lex->token) {
         case TOKEN_STRING: {
             const char *value = lex->value.string.val;
             size_t len = lex->value.string.len;
 
-            if(!(flags & JSON_ALLOW_NUL)) {
-                if(memchr(value, '\0', len)) {
-                    error_set(error, lex, json_error_null_character, "\\u0000 is not allowed without JSON_ALLOW_NUL");
+            if (!(flags & JSON_ALLOW_NUL)) {
+                if (memchr(value, '\0', len)) {
+                    error_set(error, lex, json_error_null_character,
+                              "\\u0000 is not allowed without JSON_ALLOW_NUL");
                     return NULL;
                 }
             }
@@ -873,41 +840,41 @@ static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error)
             return NULL;
     }
 
-    if(!json)
+    if (!json)
         return NULL;
 
     lex->depth--;
     return json;
 }
 
-static json_t *parse_json(lex_t *lex, size_t flags, json_error_t *error)
-{
+static json_t *parse_json(lex_t *lex, size_t flags, json_error_t *error) {
     json_t *result;
 
     lex->depth = 0;
 
     lex_scan(lex, error);
-    if(!(flags & JSON_DECODE_ANY)) {
-        if(lex->token != '[' && lex->token != '{') {
+    if (!(flags & JSON_DECODE_ANY)) {
+        if (lex->token != '[' && lex->token != '{') {
             error_set(error, lex, json_error_invalid_syntax, "'[' or '{' expected");
             return NULL;
         }
     }
 
     result = parse_value(lex, flags, error);
-    if(!result)
+    if (!result)
         return NULL;
 
-    if(!(flags & JSON_DISABLE_EOF_CHECK)) {
+    if (!(flags & JSON_DISABLE_EOF_CHECK)) {
         lex_scan(lex, error);
-        if(lex->token != TOKEN_EOF) {
-            error_set(error, lex, json_error_end_of_input_expected, "end of file expected");
+        if (lex->token != TOKEN_EOF) {
+            error_set(error, lex, json_error_end_of_input_expected,
+                      "end of file expected");
             json_decref(result);
             return NULL;
         }
     }
 
-    if(error) {
+    if (error) {
         /* Save the position even though there was no error */
         error->position = (int)lex->stream.position;
     }
@@ -915,28 +882,24 @@ static json_t *parse_json(lex_t *lex, size_t flags, json_error_t *error)
     return result;
 }
 
-typedef struct
-{
+typedef struct {
     const char *data;
     size_t pos;
 } string_data_t;
 
-static int string_get(void *data)
-{
+static int string_get(void *data) {
     char c;
     string_data_t *stream = (string_data_t *)data;
     c = stream->data[stream->pos];
-    if(c == '\0')
+    if (c == '\0')
         return EOF;
-    else
-    {
+    else {
         stream->pos++;
         return (unsigned char)c;
     }
 }
 
-json_t *json_loads(const char *string, size_t flags, json_error_t *error)
-{
+json_t *json_loads(const char *string, size_t flags, json_error_t *error) {
     lex_t lex;
     json_t *result;
     string_data_t stream_data;
@@ -951,7 +914,7 @@ json_t *json_loads(const char *string, size_t flags, json_error_t *error)
     stream_data.data = string;
     stream_data.pos = 0;
 
-    if(lex_init(&lex, string_get, flags, (void *)&stream_data))
+    if (lex_init(&lex, string_get, flags, (void *)&stream_data))
         return NULL;
 
     result = parse_json(&lex, flags, error);
@@ -960,27 +923,24 @@ json_t *json_loads(const char *string, size_t flags, json_error_t *error)
     return result;
 }
 
-typedef struct
-{
+typedef struct {
     const char *data;
     size_t len;
     size_t pos;
 } buffer_data_t;
 
-static int buffer_get(void *data)
-{
+static int buffer_get(void *data) {
     char c;
     buffer_data_t *stream = data;
-    if(stream->pos >= stream->len)
-      return EOF;
+    if (stream->pos >= stream->len)
+        return EOF;
 
     c = stream->data[stream->pos];
     stream->pos++;
     return (unsigned char)c;
 }
 
-json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t *error)
-{
+json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t *error) {
     lex_t lex;
     json_t *result;
     buffer_data_t stream_data;
@@ -996,7 +956,7 @@ json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t
     stream_data.pos = 0;
     stream_data.len = buflen;
 
-    if(lex_init(&lex, buffer_get, flags, (void *)&stream_data))
+    if (lex_init(&lex, buffer_get, flags, (void *)&stream_data))
         return NULL;
 
     result = parse_json(&lex, flags, error);
@@ -1005,13 +965,12 @@ json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t
     return result;
 }
 
-json_t *json_loadf(FILE *input, size_t flags, json_error_t *error)
-{
+json_t *json_loadf(FILE *input, size_t flags, json_error_t *error) {
     lex_t lex;
     const char *source;
     json_t *result;
 
-    if(input == stdin)
+    if (input == stdin)
         source = "<stdin>";
     else
         source = "<stream>";
@@ -1023,7 +982,7 @@ json_t *json_loadf(FILE *input, size_t flags, json_error_t *error)
         return NULL;
     }
 
-    if(lex_init(&lex, (get_func)fgetc, flags, input))
+    if (lex_init(&lex, (get_func)fgetc, flags, input))
         return NULL;
 
     result = parse_json(&lex, flags, error);
@@ -1032,8 +991,7 @@ json_t *json_loadf(FILE *input, size_t flags, json_error_t *error)
     return result;
 }
 
-static int fd_get_func(int *fd)
-{
+static int fd_get_func(int *fd) {
 #ifdef HAVE_UNISTD_H
     uint8_t c;
     if (read(*fd, &c, 1) == 1)
@@ -1042,14 +1000,13 @@ static int fd_get_func(int *fd)
     return EOF;
 }
 
-json_t *json_loadfd(int input, size_t flags, json_error_t *error)
-{
+json_t *json_loadfd(int input, size_t flags, json_error_t *error) {
     lex_t lex;
     const char *source;
     json_t *result;
 
 #ifdef HAVE_UNISTD_H
-    if(input == STDIN_FILENO)
+    if (input == STDIN_FILENO)
         source = "<stdin>";
     else
 #endif
@@ -1062,7 +1019,7 @@ json_t *json_loadfd(int input, size_t flags, json_error_t *error)
         return NULL;
     }
 
-    if(lex_init(&lex, (get_func)fd_get_func, flags, &input))
+    if (lex_init(&lex, (get_func)fd_get_func, flags, &input))
         return NULL;
 
     result = parse_json(&lex, flags, error);
@@ -1071,8 +1028,7 @@ json_t *json_loadfd(int input, size_t flags, json_error_t *error)
     return result;
 }
 
-json_t *json_load_file(const char *path, size_t flags, json_error_t *error)
-{
+json_t *json_load_file(const char *path, size_t flags, json_error_t *error) {
     json_t *result;
     FILE *fp;
 
@@ -1084,10 +1040,9 @@ json_t *json_load_file(const char *path, size_t flags, json_error_t *error)
     }
 
     fp = fopen(path, "rb");
-    if(!fp)
-    {
-        error_set(error, NULL, json_error_cannot_open_file, "unable to open %s: %s",
-                  path, strerror(errno));
+    if (!fp) {
+        error_set(error, NULL, json_error_cannot_open_file, "unable to open %s: %s", path,
+                  strerror(errno));
         return NULL;
     }
 
@@ -1099,8 +1054,7 @@ json_t *json_load_file(const char *path, size_t flags, json_error_t *error)
 
 #define MAX_BUF_LEN 1024
 
-typedef struct
-{
+typedef struct {
     char data[MAX_BUF_LEN];
     size_t len;
     size_t pos;
@@ -1108,15 +1062,14 @@ typedef struct
     void *arg;
 } callback_data_t;
 
-static int callback_get(void *data)
-{
+static int callback_get(void *data) {
     char c;
     callback_data_t *stream = data;
 
-    if(stream->pos >= stream->len) {
+    if (stream->pos >= stream->len) {
         stream->pos = 0;
         stream->len = stream->callback(stream->data, MAX_BUF_LEN, stream->arg);
-        if(stream->len == 0 || stream->len == (size_t)-1)
+        if (stream->len == 0 || stream->len == (size_t)-1)
             return EOF;
     }
 
@@ -1125,8 +1078,8 @@ static int callback_get(void *data)
     return (unsigned char)c;
 }
 
-json_t *json_load_callback(json_load_callback_t callback, void *arg, size_t flags, json_error_t *error)
-{
+json_t *json_load_callback(json_load_callback_t callback, void *arg, size_t flags,
+                           json_error_t *error) {
     lex_t lex;
     json_t *result;
 
@@ -1143,7 +1096,7 @@ json_t *json_load_callback(json_load_callback_t callback, void *arg, size_t flag
         return NULL;
     }
 
-    if(lex_init(&lex, (get_func)callback_get, flags, &stream_data))
+    if (lex_init(&lex, (get_func)callback_get, flags, &stream_data))
         return NULL;
 
     result = parse_json(&lex, flags, error);
diff --git a/src/lookup3.h b/src/lookup3.h
index 7a67e03..7202b21 100644
--- a/src/lookup3.h
+++ b/src/lookup3.h
@@ -1,3 +1,4 @@
+// clang-format off
 /*
 -------------------------------------------------------------------------------
 lookup3.c, by Bob Jenkins, May 2006, Public Domain.
diff --git a/src/memory.c b/src/memory.c
index a2be5d2..2733035 100644
--- a/src/memory.c
+++ b/src/memory.c
@@ -20,33 +20,27 @@
 static json_malloc_t do_malloc = malloc;
 static json_free_t do_free = free;
 
-void *jsonp_malloc(size_t size)
-{
-    if(!size)
+void *jsonp_malloc(size_t size) {
+    if (!size)
         return NULL;
 
     return (*do_malloc)(size);
 }
 
-void jsonp_free(void *ptr)
-{
-    if(!ptr)
+void jsonp_free(void *ptr) {
+    if (!ptr)
         return;
 
     (*do_free)(ptr);
 }
 
-char *jsonp_strdup(const char *str)
-{
-    return jsonp_strndup(str, strlen(str));
-}
+char *jsonp_strdup(const char *str) { return jsonp_strndup(str, strlen(str)); }
 
-char *jsonp_strndup(const char *str, size_t len)
-{
+char *jsonp_strndup(const char *str, size_t len) {
     char *new_str;
 
     new_str = jsonp_malloc(len + 1);
-    if(!new_str)
+    if (!new_str)
         return NULL;
 
     memcpy(new_str, str, len);
@@ -54,14 +48,12 @@ char *jsonp_strndup(const char *str, size_t len)
     return new_str;
 }
 
-void json_set_alloc_funcs(json_malloc_t malloc_fn, json_free_t free_fn)
-{
+void json_set_alloc_funcs(json_malloc_t malloc_fn, json_free_t free_fn) {
     do_malloc = malloc_fn;
     do_free = free_fn;
 }
 
-void json_get_alloc_funcs(json_malloc_t *malloc_fn, json_free_t *free_fn)
-{
+void json_get_alloc_funcs(json_malloc_t *malloc_fn, json_free_t *free_fn) {
     if (malloc_fn)
         *malloc_fn = do_malloc;
     if (free_fn)
diff --git a/src/pack_unpack.c b/src/pack_unpack.c
index 3b99776..a89be58 100644
--- a/src/pack_unpack.c
+++ b/src/pack_unpack.c
@@ -6,10 +6,10 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
-#include <string.h>
 #include "jansson.h"
 #include "jansson_private.h"
 #include "utf.h"
+#include <string.h>
 
 typedef struct {
     int line;
@@ -34,24 +34,15 @@ typedef struct {
 
 #define token(scanner) ((scanner)->token.token)
 
-static const char * const type_names[] = {
-    "object",
-    "array",
-    "string",
-    "integer",
-    "real",
-    "true",
-    "false",
-    "null"
-};
+static const char *const type_names[] = {"object", "array", "string", "integer",
+                                         "real",   "true",  "false",  "null"};
 
 #define type_name(x) type_names[json_typeof(x)]
 
 static const char unpack_value_starters[] = "{[siIbfFOon";
 
-static void scanner_init(scanner_t *s, json_error_t *error,
-                         size_t flags, const char *fmt)
-{
+static void scanner_init(scanner_t *s, json_error_t *error, size_t flags,
+                         const char *fmt) {
     s->error = error;
     s->flags = flags;
     s->fmt = s->start = fmt;
@@ -64,12 +55,11 @@ static void scanner_init(scanner_t *s, json_error_t *error,
     s->has_error = 0;
 }
 
-static void next_token(scanner_t *s)
-{
+static void next_token(scanner_t *s) {
     const char *t;
     s->prev_token = s->token;
 
-    if(s->next_token.line) {
+    if (s->next_token.line) {
         s->token = s->next_token;
         s->next_token.line = 0;
         return;
@@ -83,12 +73,11 @@ static void next_token(scanner_t *s)
     s->pos++;
 
     /* skip space and ignored chars */
-    while(*t == ' ' || *t == '\t' || *t == '\n' || *t == ',' || *t == ':') {
-        if(*t == '\n') {
+    while (*t == ' ' || *t == '\t' || *t == '\n' || *t == ',' || *t == ':') {
+        if (*t == '\n') {
             s->line++;
             s->column = 1;
-        }
-        else
+        } else
             s->column++;
 
         s->pos++;
@@ -100,24 +89,23 @@ static void next_token(scanner_t *s)
     s->token.column = s->column;
     s->token.pos = s->pos;
 
-    if (*t) t++;
+    if (*t)
+        t++;
     s->fmt = t;
 }
 
-static void prev_token(scanner_t *s)
-{
+static void prev_token(scanner_t *s) {
     s->next_token = s->token;
     s->token = s->prev_token;
 }
 
 static void set_error(scanner_t *s, const char *source, enum json_error_code code,
-                      const char *fmt, ...)
-{
+                      const char *fmt, ...) {
     va_list ap;
     va_start(ap, fmt);
 
-    jsonp_error_vset(s->error, s->token.line, s->token.column, s->token.pos,
-                     code, fmt, ap);
+    jsonp_error_vset(s->error, s->token.line, s->token.column, s->token.pos, code, fmt,
+                     ap);
 
     jsonp_error_set_source(s->error, source);
 
@@ -126,12 +114,10 @@ static void set_error(scanner_t *s, const char *source, enum json_error_code cod
 
 static json_t *pack(scanner_t *s, va_list *ap);
 
-
 /* ours will be set to 1 if jsonp_free() must be called for the result
    afterwards */
-static char *read_string(scanner_t *s, va_list *ap,
-                         const char *purpose, size_t *out_len, int *ours, int optional)
-{
+static char *read_string(scanner_t *s, va_list *ap, const char *purpose, size_t *out_len,
+                         int *ours, int optional) {
     char t;
     strbuffer_t strbuff;
     const char *str;
@@ -142,11 +128,11 @@ static char *read_string(scanner_t *s, va_list *ap,
     prev_token(s);
 
     *ours = 0;
-    if(t != '#' && t != '%' && t != '+') {
+    if (t != '#' && t != '%' && t != '+') {
         /* Optimize the simple case */
         str = va_arg(*ap, const char *);
 
-        if(!str) {
+        if (!str) {
             if (!optional) {
                 set_error(s, "<args>", json_error_null_value, "NULL %s", purpose);
                 s->has_error = 1;
@@ -156,7 +142,7 @@ static char *read_string(scanner_t *s, va_list *ap,
 
         length = strlen(str);
 
-        if(!utf8_check_string(str, length)) {
+        if (!utf8_check_string(str, length)) {
             set_error(s, "<args>", json_error_invalid_utf8, "Invalid UTF-8 %s", purpose);
             s->has_error = 1;
             return NULL;
@@ -165,55 +151,54 @@ static char *read_string(scanner_t *s, va_list *ap,
         *out_len = length;
         return (char *)str;
     } else if (optional) {
-        set_error(s, "<format>", json_error_invalid_format, "Cannot use '%c' on optional strings", t);
+        set_error(s, "<format>", json_error_invalid_format,
+                  "Cannot use '%c' on optional strings", t);
         s->has_error = 1;
 
         return NULL;
     }
 
-    if(strbuffer_init(&strbuff)) {
+    if (strbuffer_init(&strbuff)) {
         set_error(s, "<internal>", json_error_out_of_memory, "Out of memory");
         s->has_error = 1;
     }
 
-    while(1) {
+    while (1) {
         str = va_arg(*ap, const char *);
-        if(!str) {
+        if (!str) {
             set_error(s, "<args>", json_error_null_value, "NULL %s", purpose);
             s->has_error = 1;
         }
 
         next_token(s);
 
-        if(token(s) == '#') {
+        if (token(s) == '#') {
             length = va_arg(*ap, int);
-        }
-        else if(token(s) == '%') {
+        } else if (token(s) == '%') {
             length = va_arg(*ap, size_t);
-        }
-        else {
+        } else {
             prev_token(s);
             length = s->has_error ? 0 : strlen(str);
         }
 
-        if(!s->has_error && strbuffer_append_bytes(&strbuff, str, length) == -1) {
+        if (!s->has_error && strbuffer_append_bytes(&strbuff, str, length) == -1) {
             set_error(s, "<internal>", json_error_out_of_memory, "Out of memory");
             s->has_error = 1;
         }
 
         next_token(s);
-        if(token(s) != '+') {
+        if (token(s) != '+') {
             prev_token(s);
             break;
         }
     }
 
-    if(s->has_error) {
+    if (s->has_error) {
         strbuffer_close(&strbuff);
         return NULL;
     }
 
-    if(!utf8_check_string(strbuff.value, strbuff.length)) {
+    if (!utf8_check_string(strbuff.value, strbuff.length)) {
         set_error(s, "<args>", json_error_invalid_utf8, "Invalid UTF-8 %s", purpose);
         strbuffer_close(&strbuff);
         s->has_error = 1;
@@ -225,25 +210,26 @@ static char *read_string(scanner_t *s, va_list *ap,
     return strbuffer_steal_value(&strbuff);
 }
 
-static json_t *pack_object(scanner_t *s, va_list *ap)
-{
+static json_t *pack_object(scanner_t *s, va_list *ap) {
     json_t *object = json_object();
     next_token(s);
 
-    while(token(s) != '}') {
+    while (token(s) != '}') {
         char *key;
         size_t len;
         int ours;
         json_t *value;
         char valueOptional;
 
-        if(!token(s)) {
-            set_error(s, "<format>", json_error_invalid_format, "Unexpected end of format string");
+        if (!token(s)) {
+            set_error(s, "<format>", json_error_invalid_format,
+                      "Unexpected end of format string");
             goto error;
         }
 
-        if(token(s) != 's') {
-            set_error(s, "<format>", json_error_invalid_format, "Expected format 's', got '%c'", token(s));
+        if (token(s) != 's') {
+            set_error(s, "<format>", json_error_invalid_format,
+                      "Expected format 's', got '%c'", token(s));
             goto error;
         }
 
@@ -256,11 +242,11 @@ static json_t *pack_object(scanner_t *s, va_list *ap)
         prev_token(s);
 
         value = pack(s, ap);
-        if(!value) {
-            if(ours)
+        if (!value) {
+            if (ours)
                 jsonp_free(key);
 
-            if(valueOptional != '*') {
+            if (valueOptional != '*') {
                 set_error(s, "<args>", json_error_null_value, "NULL object value");
                 s->has_error = 1;
             }
@@ -269,21 +255,22 @@ static json_t *pack_object(scanner_t *s, va_list *ap)
             continue;
         }
 
-        if(s->has_error)
+        if (s->has_error)
             json_decref(value);
 
-        if(!s->has_error && json_object_set_new_nocheck(object, key, value)) {
-            set_error(s, "<internal>", json_error_out_of_memory, "Unable to add key \"%s\"", key);
+        if (!s->has_error && json_object_set_new_nocheck(object, key, value)) {
+            set_error(s, "<internal>", json_error_out_of_memory,
+                      "Unable to add key \"%s\"", key);
             s->has_error = 1;
         }
 
-        if(ours)
+        if (ours)
             jsonp_free(key);
 
         next_token(s);
     }
 
-    if(!s->has_error)
+    if (!s->has_error)
         return object;
 
 error:
@@ -291,17 +278,17 @@ error:
     return NULL;
 }
 
-static json_t *pack_array(scanner_t *s, va_list *ap)
-{
+static json_t *pack_array(scanner_t *s, va_list *ap) {
     json_t *array = json_array();
     next_token(s);
 
-    while(token(s) != ']') {
+    while (token(s) != ']') {
         json_t *value;
         char valueOptional;
 
-        if(!token(s)) {
-            set_error(s, "<format>", json_error_invalid_format, "Unexpected end of format string");
+        if (!token(s)) {
+            set_error(s, "<format>", json_error_invalid_format,
+                      "Unexpected end of format string");
             /* Format string errors are unrecoverable. */
             goto error;
         }
@@ -311,8 +298,8 @@ static json_t *pack_array(scanner_t *s, va_list *ap)
         prev_token(s);
 
         value = pack(s, ap);
-        if(!value) {
-            if(valueOptional != '*') {
+        if (!value) {
+            if (valueOptional != '*') {
                 s->has_error = 1;
             }
 
@@ -320,18 +307,19 @@ static json_t *pack_array(scanner_t *s, va_list *ap)
             continue;
         }
 
-        if(s->has_error)
+        if (s->has_error)
             json_decref(value);
 
-        if(!s->has_error && json_array_append_new(array, value)) {
-            set_error(s, "<internal>", json_error_out_of_memory, "Unable to append to array");
+        if (!s->has_error && json_array_append_new(array, value)) {
+            set_error(s, "<internal>", json_error_out_of_memory,
+                      "Unable to append to array");
             s->has_error = 1;
         }
 
         next_token(s);
     }
 
-    if(!s->has_error)
+    if (!s->has_error)
         return array;
 
 error:
@@ -339,8 +327,7 @@ error:
     return NULL;
 }
 
-static json_t *pack_string(scanner_t *s, va_list *ap)
-{
+static json_t *pack_string(scanner_t *s, va_list *ap) {
     char *str;
     char t;
     size_t len;
@@ -369,8 +356,7 @@ static json_t *pack_string(scanner_t *s, va_list *ap)
     return json_stringn_nocheck(str, len);
 }
 
-static json_t *pack_object_inter(scanner_t *s, va_list *ap, int need_incref)
-{
+static json_t *pack_object_inter(scanner_t *s, va_list *ap, int need_incref) {
     json_t *json;
     char ntoken;
 
@@ -399,8 +385,7 @@ static json_t *pack_object_inter(scanner_t *s, va_list *ap, int need_incref)
     return NULL;
 }
 
-static json_t *pack_integer(scanner_t *s, json_int_t value)
-{
+static json_t *pack_integer(scanner_t *s, json_int_t value) {
     json_t *json = json_integer(value);
 
     if (!json) {
@@ -411,8 +396,7 @@ static json_t *pack_integer(scanner_t *s, json_int_t value)
     return json;
 }
 
-static json_t *pack_real(scanner_t *s, double value)
-{
+static json_t *pack_real(scanner_t *s, double value) {
     /* Allocate without setting value so we can identify OOM error. */
     json_t *json = json_real(0.0);
 
@@ -426,7 +410,8 @@ static json_t *pack_real(scanner_t *s, double value)
     if (json_real_set(json, value)) {
         json_decref(json);
 
-        set_error(s, "<args>", json_error_numeric_overflow, "Invalid floating point value");
+        set_error(s, "<args>", json_error_numeric_overflow,
+                  "Invalid floating point value");
         s->has_error = 1;
 
         return NULL;
@@ -435,9 +420,8 @@ static json_t *pack_real(scanner_t *s, double value)
     return json;
 }
 
-static json_t *pack(scanner_t *s, va_list *ap)
-{
-    switch(token(s)) {
+static json_t *pack(scanner_t *s, va_list *ap) {
+    switch (token(s)) {
         case '{':
             return pack_object(s, ap);
 
@@ -469,8 +453,8 @@ static json_t *pack(scanner_t *s, va_list *ap)
             return pack_object_inter(s, ap, 0);
 
         default:
-            set_error(s, "<format>", json_error_invalid_format, "Unexpected format character '%c'",
-                      token(s));
+            set_error(s, "<format>", json_error_invalid_format,
+                      "Unexpected format character '%c'", token(s));
             s->has_error = 1;
             return NULL;
     }
@@ -478,8 +462,7 @@ static json_t *pack(scanner_t *s, va_list *ap)
 
 static int unpack(scanner_t *s, json_t *root, va_list *ap);
 
-static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
-{
+static int unpack_object(scanner_t *s, json_t *root, va_list *ap) {
     int ret = -1;
     int strict = 0;
     int gotopt = 0;
@@ -491,81 +474,84 @@ static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
     */
     hashtable_t key_set;
 
-    if(hashtable_init(&key_set)) {
+    if (hashtable_init(&key_set)) {
         set_error(s, "<internal>", json_error_out_of_memory, "Out of memory");
         return -1;
     }
 
-    if(root && !json_is_object(root)) {
+    if (root && !json_is_object(root)) {
         set_error(s, "<validation>", json_error_wrong_type, "Expected object, got %s",
                   type_name(root));
         goto out;
     }
     next_token(s);
 
-    while(token(s) != '}') {
+    while (token(s) != '}') {
         const char *key;
         json_t *value;
         int opt = 0;
 
-        if(strict != 0) {
-            set_error(s, "<format>", json_error_invalid_format, "Expected '}' after '%c', got '%c'",
-                      (strict == 1 ? '!' : '*'), token(s));
+        if (strict != 0) {
+            set_error(s, "<format>", json_error_invalid_format,
+                      "Expected '}' after '%c', got '%c'", (strict == 1 ? '!' : '*'),
+                      token(s));
             goto out;
         }
 
-        if(!token(s)) {
-            set_error(s, "<format>", json_error_invalid_format, "Unexpected end of format string");
+        if (!token(s)) {
+            set_error(s, "<format>", json_error_invalid_format,
+                      "Unexpected end of format string");
             goto out;
         }
 
-        if(token(s) == '!' || token(s) == '*') {
+        if (token(s) == '!' || token(s) == '*') {
             strict = (token(s) == '!' ? 1 : -1);
             next_token(s);
             continue;
         }
 
-        if(token(s) != 's') {
-            set_error(s, "<format>", json_error_invalid_format, "Expected format 's', got '%c'", token(s));
+        if (token(s) != 's') {
+            set_error(s, "<format>", json_error_invalid_format,
+                      "Expected format 's', got '%c'", token(s));
             goto out;
         }
 
         key = va_arg(*ap, const char *);
-        if(!key) {
+        if (!key) {
             set_error(s, "<args>", json_error_null_value, "NULL object key");
             goto out;
         }
 
         next_token(s);
 
-        if(token(s) == '?') {
+        if (token(s) == '?') {
             opt = gotopt = 1;
             next_token(s);
         }
 
-        if(!root) {
+        if (!root) {
             /* skipping */
             value = NULL;
-        }
-        else {
+        } else {
             value = json_object_get(root, key);
-            if(!value && !opt) {
-                set_error(s, "<validation>", json_error_item_not_found, "Object item not found: %s", key);
+            if (!value && !opt) {
+                set_error(s, "<validation>", json_error_item_not_found,
+                          "Object item not found: %s", key);
                 goto out;
             }
         }
 
-        if(unpack(s, value, ap))
+        if (unpack(s, value, ap))
             goto out;
 
         hashtable_set(&key_set, key, json_null());
         next_token(s);
     }
 
-    if(strict == 0 && (s->flags & JSON_STRICT))
+    if (strict == 0 && (s->flags & JSON_STRICT))
         strict = 1;
 
-    if(root && strict == 1) {
+    if (root && strict == 1) {
         /* We need to check that all non optional items have been parsed */
         const char *key;
         /* keys_res is 1 for uninitialized, 0 for success, -1 for error. */
@@ -576,7 +562,7 @@ static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
 
         if (gotopt || json_object_size(root) != key_set.size) {
             json_object_foreach(root, key, value) {
-                if(!hashtable_get(&key_set, key)) {
+                if (!hashtable_get(&key_set, key)) {
                     unpacked++;
 
                     /* Save unrecognized keys for the error message */
@@ -587,14 +573,14 @@ static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
                     }
 
                     if (!keys_res)
-                        keys_res = strbuffer_append_bytes(&unrecognized_keys, key, strlen(key));
+                        keys_res =
+                            strbuffer_append_bytes(&unrecognized_keys, key, strlen(key));
                 }
             }
         }
         if (unpacked) {
             set_error(s, "<validation>", json_error_end_of_input_expected,
-                      "%li object item(s) left unpacked: %s",
-                      unpacked,
+                      "%li object item(s) left unpacked: %s", unpacked,
                       keys_res ? "<unknown>" : strbuffer_value(&unrecognized_keys));
             strbuffer_close(&unrecognized_keys);
             goto out;
@@ -608,80 +594,79 @@ out:
     return ret;
 }
 
-static int unpack_array(scanner_t *s, json_t *root, va_list *ap)
-{
+static int unpack_array(scanner_t *s, json_t *root, va_list *ap) {
     size_t i = 0;
     int strict = 0;
 
-    if(root && !json_is_array(root)) {
-        set_error(s, "<validation>", json_error_wrong_type, "Expected array, got %s", type_name(root));
+    if (root && !json_is_array(root)) {
+        set_error(s, "<validation>", json_error_wrong_type, "Expected array, got %s",
+                  type_name(root));
         return -1;
     }
     next_token(s);
 
-    while(token(s) != ']') {
+    while (token(s) != ']') {
         json_t *value;
 
-        if(strict != 0) {
-            set_error(s, "<format>", json_error_invalid_format, "Expected ']' after '%c', got '%c'",
-                      (strict == 1 ? '!' : '*'),
+        if (strict != 0) {
+            set_error(s, "<format>", json_error_invalid_format,
+                      "Expected ']' after '%c', got '%c'", (strict == 1 ? '!' : '*'),
                       token(s));
             return -1;
         }
 
-        if(!token(s)) {
-            set_error(s, "<format>", json_error_invalid_format, "Unexpected end of format string");
+        if (!token(s)) {
+            set_error(s, "<format>", json_error_invalid_format,
+                      "Unexpected end of format string");
             return -1;
         }
 
-        if(token(s) == '!' || token(s) == '*') {
+        if (token(s) == '!' || token(s) == '*') {
             strict = (token(s) == '!' ? 1 : -1);
             next_token(s);
             continue;
         }
 
-        if(!strchr(unpack_value_starters, token(s))) {
-            set_error(s, "<format>", json_error_invalid_format, "Unexpected format character '%c'",
-                      token(s));
+        if (!strchr(unpack_value_starters, token(s))) {
+            set_error(s, "<format>", json_error_invalid_format,
+                      "Unexpected format character '%c'", token(s));
             return -1;
         }
 
-        if(!root) {
+        if (!root) {
             /* skipping */
             value = NULL;
-        }
-        else {
+        } else {
             value = json_array_get(root, i);
-            if(!value) {
-                set_error(s, "<validation>", json_error_index_out_of_range, "Array index %lu out of range",
-                          (unsigned long)i);
+            if (!value) {
+                set_error(s, "<validation>", json_error_index_out_of_range,
+                          "Array index %lu out of range", (unsigned long)i);
                 return -1;
             }
         }
 
-        if(unpack(s, value, ap))
+        if (unpack(s, value, ap))
             return -1;
 
         next_token(s);
         i++;
     }
 
-    if(strict == 0 && (s->flags & JSON_STRICT))
+    if (strict == 0 && (s->flags & JSON_STRICT))
         strict = 1;
 
-    if(root && strict == 1 && i != json_array_size(root)) {
+    if (root && strict == 1 && i != json_array_size(root)) {
         long diff = (long)json_array_size(root) - (long)i;
-        set_error(s, "<validation>", json_error_end_of_input_expected, "%li array item(s) left unpacked", diff);
+        set_error(s, "<validation>", json_error_end_of_input_expected,
+                  "%li array item(s) left unpacked", diff);
         return -1;
     }
 
     return 0;
 }
 
-static int unpack(scanner_t *s, json_t *root, va_list *ap)
-{
-    switch(token(s))
-    {
+static int unpack(scanner_t *s, json_t *root, va_list *ap) {
+    switch (token(s)) {
         case '{':
             return unpack_object(s, root, ap);
 
@@ -689,126 +674,126 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)
             return unpack_array(s, root, ap);
 
         case 's':
-            if(root && !json_is_string(root)) {
-                set_error(s, "<validation>", json_error_wrong_type, "Expected string, got %s",
-                          type_name(root));
+            if (root && !json_is_string(root)) {
+                set_error(s, "<validation>", json_error_wrong_type,
+                          "Expected string, got %s", type_name(root));
                 return -1;
             }
 
-            if(!(s->flags & JSON_VALIDATE_ONLY)) {
+            if (!(s->flags & JSON_VALIDATE_ONLY)) {
                 const char **str_target;
                 size_t *len_target = NULL;
 
                 str_target = va_arg(*ap, const char **);
-                if(!str_target) {
+                if (!str_target) {
                     set_error(s, "<args>", json_error_null_value, "NULL string argument");
                     return -1;
                 }
 
                 next_token(s);
 
-                if(token(s) == '%') {
+                if (token(s) == '%') {
                     len_target = va_arg(*ap, size_t *);
-                    if(!len_target) {
-                        set_error(s, "<args>", json_error_null_value, "NULL string length argument");
+                    if (!len_target) {
+                        set_error(s, "<args>", json_error_null_value,
+                                  "NULL string length argument");
                         return -1;
                     }
-                }
-                else
+                } else
                     prev_token(s);
 
-                if(root) {
+                if (root) {
                     *str_target = json_string_value(root);
-                    if(len_target)
+                    if (len_target)
                         *len_target = json_string_length(root);
                 }
             }
             return 0;
 
         case 'i':
-            if(root && !json_is_integer(root)) {
-                set_error(s, "<validation>", json_error_wrong_type, "Expected integer, got %s",
-                          type_name(root));
+            if (root && !json_is_integer(root)) {
+                set_error(s, "<validation>", json_error_wrong_type,
+                          "Expected integer, got %s", type_name(root));
                 return -1;
             }
 
-            if(!(s->flags & JSON_VALIDATE_ONLY)) {
-                int *target = va_arg(*ap, int*);
-                if(root)
+            if (!(s->flags & JSON_VALIDATE_ONLY)) {
+                int *target = va_arg(*ap, int *);
+                if (root)
                     *target = (int)json_integer_value(root);
             }
 
             return 0;
 
         case 'I':
-            if(root && !json_is_integer(root)) {
-                set_error(s, "<validation>", json_error_wrong_type, "Expected integer, got %s",
-                          type_name(root));
+            if (root && !json_is_integer(root)) {
+                set_error(s, "<validation>", json_error_wrong_type,
+                          "Expected integer, got %s", type_name(root));
                 return -1;
             }
 
-            if(!(s->flags & JSON_VALIDATE_ONLY)) {
-                json_int_t *target = va_arg(*ap, json_int_t*);
-                if(root)
+            if (!(s->flags & JSON_VALIDATE_ONLY)) {
+                json_int_t *target = va_arg(*ap, json_int_t *);
+                if (root)
                     *target = json_integer_value(root);
             }
 
             return 0;
 
         case 'b':
-            if(root && !json_is_boolean(root)) {
-                set_error(s, "<validation>", json_error_wrong_type, "Expected true or false, got %s",
-                          type_name(root));
+            if (root && !json_is_boolean(root)) {
+                set_error(s, "<validation>", json_error_wrong_type,
+                          "Expected true or false, got %s", type_name(root));
                 return -1;
             }
 
-            if(!(s->flags & JSON_VALIDATE_ONLY)) {
-                int *target = va_arg(*ap, int*);
-                if(root)
+            if (!(s->flags & JSON_VALIDATE_ONLY)) {
+                int *target = va_arg(*ap, int *);
+                if (root)
                     *target = json_is_true(root);
             }
 
             return 0;
 
         case 'f':
-            if(root && !json_is_real(root)) {
-                set_error(s, "<validation>", json_error_wrong_type, "Expected real, got %s",
-                          type_name(root));
+            if (root && !json_is_real(root)) {
+                set_error(s, "<validation>", json_error_wrong_type,
+                          "Expected real, got %s", type_name(root));
                 return -1;
             }
 
-            if(!(s->flags & JSON_VALIDATE_ONLY)) {
-                double *target = va_arg(*ap, double*);
-                if(root)
+            if (!(s->flags & JSON_VALIDATE_ONLY)) {
+                double *target = va_arg(*ap, double *);
+                if (root)
                     *target = json_real_value(root);
             }
 
             return 0;
 
         case 'F':
-            if(root && !json_is_number(root)) {
-                set_error(s, "<validation>", json_error_wrong_type, "Expected real or integer, got %s",
-                          type_name(root));
+            if (root && !json_is_number(root)) {
+                set_error(s, "<validation>", json_error_wrong_type,
+                          "Expected real or integer, got %s", type_name(root));
                 return -1;
             }
 
-            if(!(s->flags & JSON_VALIDATE_ONLY)) {
-                double *target = va_arg(*ap, double*);
-                if(root)
+            if (!(s->flags & JSON_VALIDATE_ONLY)) {
+                double *target = va_arg(*ap, double *);
+                if (root)
                     *target = json_number_value(root);
             }
 
             return 0;
 
         case 'O':
-            if(root && !(s->flags & JSON_VALIDATE_ONLY))
+            if (root && !(s->flags & JSON_VALIDATE_ONLY))
                 json_incref(root);
             /* Fall through */
 
         case 'o':
-            if(!(s->flags & JSON_VALIDATE_ONLY)) {
-                json_t **target = va_arg(*ap, json_t**);
-                if(root)
+            if (!(s->flags & JSON_VALIDATE_ONLY)) {
+                json_t **target = va_arg(*ap, json_t **);
+                if (root)
                     *target = root;
             }
 
@@ -816,30 +801,29 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)
 
         case 'n':
             /* Never assign, just validate */
-            if(root && !json_is_null(root)) {
-                set_error(s, "<validation>", json_error_wrong_type, "Expected null, got %s",
-                          type_name(root));
+            if (root && !json_is_null(root)) {
+                set_error(s, "<validation>", json_error_wrong_type,
+                          "Expected null, got %s", type_name(root));
                 return -1;
             }
             return 0;
 
         default:
-            set_error(s, "<format>", json_error_invalid_format, "Unexpected format character '%c'",
-                      token(s));
+            set_error(s, "<format>", json_error_invalid_format,
+                      "Unexpected format character '%c'", token(s));
             return -1;
     }
 }
 
-json_t *json_vpack_ex(json_error_t *error, size_t flags,
-                      const char *fmt, va_list ap)
-{
+json_t *json_vpack_ex(json_error_t *error, size_t flags, const char *fmt, va_list ap) {
     scanner_t s;
     va_list ap_copy;
     json_t *value;
 
-    if(!fmt || !*fmt) {
+    if (!fmt || !*fmt) {
         jsonp_error_init(error, "<format>");
-        jsonp_error_set(error, -1, -1, 0, json_error_invalid_argument, "NULL or empty format string");
+        jsonp_error_set(error, -1, -1, 0, json_error_invalid_argument,
+                        "NULL or empty format string");
         return NULL;
     }
     jsonp_error_init(error, NULL);
@@ -852,21 +836,21 @@ json_t *json_vpack_ex(json_error_t *error, size_t flags,
     va_end(ap_copy);
 
     /* This will cover all situations where s.has_error is true */
-    if(!value)
+    if (!value)
         return NULL;
 
     next_token(&s);
-    if(token(&s)) {
+    if (token(&s)) {
         json_decref(value);
-        set_error(&s, "<format>", json_error_invalid_format, "Garbage after format string");
+        set_error(&s, "<format>", json_error_invalid_format,
+                  "Garbage after format string");
         return NULL;
     }
 
     return value;
 }
 
-json_t *json_pack_ex(json_error_t *error, size_t flags, const char *fmt, ...)
-{
+json_t *json_pack_ex(json_error_t *error, size_t flags, const char *fmt, ...) {
     json_t *value;
     va_list ap;
 
@@ -877,8 +861,7 @@ json_t *json_pack_ex(json_error_t *error, size_t flags, const char *fmt, ...)
     return value;
 }
 
-json_t *json_pack(const char *fmt, ...)
-{
+json_t *json_pack(const char *fmt, ...) {
     json_t *value;
     va_list ap;
 
@@ -889,21 +872,21 @@ json_t *json_pack(const char *fmt, ...)
     return value;
 }
 
-int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags,
-                    const char *fmt, va_list ap)
-{
+int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt,
+                    va_list ap) {
     scanner_t s;
     va_list ap_copy;
 
-    if(!root) {
+    if (!root) {
         jsonp_error_init(error, "<root>");
         jsonp_error_set(error, -1, -1, 0, json_error_null_value, "NULL root value");
         return -1;
     }
 
-    if(!fmt || !*fmt) {
+    if (!fmt || !*fmt) {
         jsonp_error_init(error, "<format>");
-        jsonp_error_set(error, -1, -1, 0, json_error_invalid_argument, "NULL or empty format string");
+        jsonp_error_set(error, -1, -1, 0, json_error_invalid_argument,
+                        "NULL or empty format string");
         return -1;
     }
     jsonp_error_init(error, NULL);
@@ -912,23 +895,24 @@ int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags,
     next_token(&s);
 
     va_copy(ap_copy, ap);
-    if(unpack(&s, root, &ap_copy)) {
+    if (unpack(&s, root, &ap_copy)) {
         va_end(ap_copy);
         return -1;
     }
     va_end(ap_copy);
 
     next_token(&s);
-    if(token(&s)) {
-        set_error(&s, "<format>", json_error_invalid_format, "Garbage after format string");
+    if (token(&s)) {
+        set_error(&s, "<format>", json_error_invalid_format,
+                  "Garbage after format string");
         return -1;
     }
 
     return 0;
 }
 
-int json_unpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, ...)
-{
+int json_unpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt,
+                   ...) {
     int ret;
     va_list ap;
 
@@ -939,8 +923,7 @@ int json_unpack_ex(json_t *root, json_error_t *error, size_t flags, const char *
     return ret;
 }
 
-int json_unpack(json_t *root, const char *fmt, ...)
-{
+int json_unpack(json_t *root, const char *fmt, ...) {
     int ret;
     va_list ap;
 
diff --git a/src/strbuffer.c b/src/strbuffer.c
index 5e8c003..d9bcd43 100644
--- a/src/strbuffer.c
+++ b/src/strbuffer.c
@@ -9,22 +9,21 @@
 #define _GNU_SOURCE
 #endif
 
+#include "strbuffer.h"
+#include "jansson_private.h"
 #include <stdlib.h>
 #include <string.h>
-#include "jansson_private.h"
-#include "strbuffer.h"
 
-#define STRBUFFER_MIN_SIZE  16
-#define STRBUFFER_FACTOR    2
-#define STRBUFFER_SIZE_MAX  ((size_t)-1)
+#define STRBUFFER_MIN_SIZE 16
+#define STRBUFFER_FACTOR   2
+#define STRBUFFER_SIZE_MAX ((size_t)-1)
 
-int strbuffer_init(strbuffer_t *strbuff)
-{
+int strbuffer_init(strbuffer_t *strbuff) {
     strbuff->size = STRBUFFER_MIN_SIZE;
     strbuff->length = 0;
 
     strbuff->value = jsonp_malloc(strbuff->size);
-    if(!strbuff->value)
+    if (!strbuff->value)
         return -1;
 
     /* initialize to empty */
@@ -32,9 +31,8 @@ int strbuffer_init(strbuffer_t *strbuff)
     return 0;
 }
 
-void strbuffer_close(strbuffer_t *strbuff)
-{
-    if(strbuff->value)
+void strbuffer_close(strbuffer_t *strbuff) {
+    if (strbuff->value)
         jsonp_free(strbuff->value);
 
     strbuff->size = 0;
@@ -42,47 +40,38 @@ void strbuffer_close(strbuffer_t *strbuff)
     strbuff->value = NULL;
 }
 
-void strbuffer_clear(strbuffer_t *strbuff)
-{
+void strbuffer_clear(strbuffer_t *strbuff) {
     strbuff->length = 0;
     strbuff->value[0] = '\0';
 }
 
-const char *strbuffer_value(const strbuffer_t *strbuff)
-{
-    return strbuff->value;
-}
+const char *strbuffer_value(const strbuffer_t *strbuff) { return strbuff->value; }
 
-char *strbuffer_steal_value(strbuffer_t *strbuff)
-{
+char *strbuffer_steal_value(strbuffer_t *strbuff) {
     char *result = strbuff->value;
     strbuff->value = NULL;
     return result;
 }
 
-int strbuffer_append_byte(strbuffer_t *strbuff, char byte)
-{
+int strbuffer_append_byte(strbuffer_t *strbuff, char byte) {
     return strbuffer_append_bytes(strbuff, &byte, 1);
 }
 
-int strbuffer_append_bytes(strbuffer_t *strbuff, const char *data, size_t size)
-{
-    if(size >= strbuff->size - strbuff->length)
-    {
+int strbuffer_append_bytes(strbuffer_t *strbuff, const char *data, size_t size) {
+    if (size >= strbuff->size - strbuff->length) {
         size_t new_size;
         char *new_value;
 
         /* avoid integer overflow */
-        if (strbuff->size > STRBUFFER_SIZE_MAX / STRBUFFER_FACTOR
-            || size > STRBUFFER_SIZE_MAX - 1
-            || strbuff->length > STRBUFFER_SIZE_MAX - 1 - size)
+        if (strbuff->size > STRBUFFER_SIZE_MAX / STRBUFFER_FACTOR ||
+            size > STRBUFFER_SIZE_MAX - 1 ||
+            strbuff->length > STRBUFFER_SIZE_MAX - 1 - size)
             return -1;
 
-        new_size = max(strbuff->size * STRBUFFER_FACTOR,
-                       strbuff->length + size + 1);
+        new_size = max(strbuff->size * STRBUFFER_FACTOR, strbuff->length + size + 1);
 
         new_value = jsonp_malloc(new_size);
-        if(!new_value)
+        if (!new_value)
             return -1;
 
         memcpy(new_value, strbuff->value, strbuff->length);
@@ -99,13 +88,11 @@ int strbuffer_append_bytes(strbuffer_t *strbuff, const char *data, size_t size)
     return 0;
 }
 
-char strbuffer_pop(strbuffer_t *strbuff)
-{
-    if(strbuff->length > 0) {
+char strbuffer_pop(strbuffer_t *strbuff) {
+    if (strbuff->length > 0) {
         char c = strbuff->value[--strbuff->length];
         strbuff->value[strbuff->length] = '\0';
         return c;
-    }
-    else
+    } else
         return '\0';
 }
diff --git a/src/strbuffer.h b/src/strbuffer.h
index 75c02a2..70f2646 100644
--- a/src/strbuffer.h
+++ b/src/strbuffer.h
@@ -8,12 +8,13 @@
 #ifndef STRBUFFER_H
 #define STRBUFFER_H
 
+#include "jansson.h"
 #include <stdlib.h>
 
 typedef struct {
     char *value;
-    size_t length;   /* bytes used */
-    size_t size;     /* bytes allocated */
+    size_t length; /* bytes used */
+    size_t size;   /* bytes allocated */
 } strbuffer_t;
 
 int strbuffer_init(strbuffer_t *strbuff) JANSSON_ATTRS((warn_unused_result));
diff --git a/src/strconv.c b/src/strconv.c
index c3563b9..c6f4fd1 100644
--- a/src/strconv.c
+++ b/src/strconv.c
@@ -1,10 +1,10 @@
+#include "jansson_private.h"
+#include "strbuffer.h"
 #include <assert.h>
 #include <errno.h>
+#include <math.h>
 #include <stdio.h>
 #include <string.h>
-#include <math.h>
-#include "jansson_private.h"
-#include "strbuffer.h"
 
 /* need jansson_private_config.h to get the correct snprintf */
 #ifdef HAVE_CONFIG_H
@@ -24,41 +24,38 @@
     this way. Multi-threaded programs should use uselocale() instead.
 */
 
-static void to_locale(strbuffer_t *strbuffer)
-{
+static void to_locale(strbuffer_t *strbuffer) {
     const char *point;
     char *pos;
 
     point = localeconv()->decimal_point;
-    if(*point == '.') {
+    if (*point == '.') {
         /* No conversion needed */
         return;
     }
 
     pos = strchr(strbuffer->value, '.');
-    if(pos)
+    if (pos)
         *pos = *point;
 }
 
-static void from_locale(char *buffer)
-{
+static void from_locale(char *buffer) {
     const char *point;
     char *pos;
 
     point = localeconv()->decimal_point;
-    if(*point == '.') {
+    if (*point == '.') {
         /* No conversion needed */
         return;
     }
 
     pos = strchr(buffer, *point);
-    if(pos)
+    if (pos)
         *pos = '.';
 }
 #endif
 
-int jsonp_strtod(strbuffer_t *strbuffer, double *out)
-{
+int jsonp_strtod(strbuffer_t *strbuffer, double *out) {
     double value;
     char *end;
 
@@ -70,7 +67,7 @@ int jsonp_strtod(strbuffer_t *strbuffer, double *out)
     value = strtod(strbuffer->value, &end);
     assert(end == strbuffer->value + strbuffer->length);
 
-    if((value == HUGE_VAL || value == -HUGE_VAL) && errno == ERANGE) {
+    if ((value == HUGE_VAL || value == -HUGE_VAL) && errno == ERANGE) {
         /* Overflow */
         return -1;
     }
@@ -79,8 +76,7 @@ int jsonp_strtod(strbuffer_t *strbuffer, double *out)
     return 0;
 }
 
-int jsonp_dtostr(char *buffer, size_t size, double value, int precision)
-{
+int jsonp_dtostr(char *buffer, size_t size, double value, int precision) {
     int ret;
     char *start, *end;
     size_t length;
@@ -89,11 +85,11 @@ int jsonp_dtostr(char *buffer, size_t size, double value, int precision)
         precision = 17;
 
     ret = snprintf(buffer, size, "%.*g", precision, value);
-    if(ret < 0)
+    if (ret < 0)
         return -1;
 
     length = (size_t)ret;
-    if(length >= size)
+    if (length >= size)
         return -1;
 
 #if JSON_HAVE_LOCALECONV
@@ -102,10 +98,8 @@ int jsonp_dtostr(char *buffer, size_t size, double value, int precision)
 
     /* Make sure there's a dot or 'e' in the output. Otherwise
        a real is converted to an integer when decoding */
-    if(strchr(buffer, '.') == NULL &&
-       strchr(buffer, 'e') == NULL)
-    {
-        if(length + 3 >= size) {
+    if (strchr(buffer, '.') == NULL && strchr(buffer, 'e') == NULL) {
+        if (length + 3 >= size) {
             /* No space to append ".0" */
             return -1;
         }
@@ -118,17 +112,17 @@ int jsonp_dtostr(char *buffer, size_t size, double value, int precision)
     /* Remove leading '+' from positive exponent. Also remove leading
        zeros from exponents (added by some printf() implementations) */
     start = strchr(buffer, 'e');
-    if(start) {
+    if (start) {
         start++;
         end = start + 1;
 
-        if(*start == '-')
+        if (*start == '-')
             start++;
 
-        while(*end == '0')
+        while (*end == '0')
             end++;
 
-        if(end != start) {
+        if (end != start) {
             memmove(start, end, length - (size_t)(end - buffer));
             length -= (size_t)(end - start);
         }
diff --git a/src/utf.c b/src/utf.c
index be966cb..28b2f7d 100644
--- a/src/utf.c
+++ b/src/utf.c
@@ -5,107 +5,85 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
-#include <string.h>
 #include "utf.h"
+#include <string.h>
 
-int utf8_encode(int32_t codepoint, char *buffer, size_t *size)
-{
-    if(codepoint < 0)
+int utf8_encode(int32_t codepoint, char *buffer, size_t *size) {
+    if (codepoint < 0)
         return -1;
-    else if(codepoint < 0x80)
-    {
+    else if (codepoint < 0x80) {
         buffer[0] = (char)codepoint;
         *size = 1;
-    }
-    else if(codepoint < 0x800)
-    {
+    } else if (codepoint < 0x800) {
         buffer[0] = 0xC0 + ((codepoint & 0x7C0) >> 6);
         buffer[1] = 0x80 + ((codepoint & 0x03F));
         *size = 2;
-    }
-    else if(codepoint < 0x10000)
-    {
+    } else if (codepoint < 0x10000) {
         buffer[0] = 0xE0 + ((codepoint & 0xF000) >> 12);
         buffer[1] = 0x80 + ((codepoint & 0x0FC0) >> 6);
         buffer[2] = 0x80 + ((codepoint & 0x003F));
         *size = 3;
-    }
-    else if(codepoint <= 0x10FFFF)
-    {
+    } else if (codepoint <= 0x10FFFF) {
         buffer[0] = 0xF0 + ((codepoint & 0x1C0000) >> 18);
         buffer[1] = 0x80 + ((codepoint & 0x03F000) >> 12);
         buffer[2] = 0x80 + ((codepoint & 0x000FC0) >> 6);
         buffer[3] = 0x80 + ((codepoint & 0x00003F));
         *size = 4;
-    }
-    else
+    } else
         return -1;
 
     return 0;
 }
 
-size_t utf8_check_first(char byte)
-{
+size_t utf8_check_first(char byte) {
     unsigned char u = (unsigned char)byte;
 
-    if(u < 0x80)
+    if (u < 0x80)
         return 1;
 
-    if(0x80 <= u && u <= 0xBF) {
+    if (0x80 <= u && u <= 0xBF) {
         /* second, third or fourth byte of a multi-byte
            sequence, i.e. a "continuation byte" */
         return 0;
-    }
-    else if(u == 0xC0 || u == 0xC1) {
+    } else if (u == 0xC0 || u == 0xC1) {
         /* overlong encoding of an ASCII byte */
         return 0;
-    }
-    else if(0xC2 <= u && u <= 0xDF) {
+    } else if (0xC2 <= u && u <= 0xDF) {
         /* 2-byte sequence */
         return 2;
     }
 
-    else if(0xE0 <= u && u <= 0xEF) {
+    else if (0xE0 <= u && u <= 0xEF) {
         /* 3-byte sequence */
         return 3;
-    }
-    else if(0xF0 <= u && u <= 0xF4) {
+    } else if (0xF0 <= u && u <= 0xF4) {
         /* 4-byte sequence */
         return 4;
-    }
-    else { /* u >= 0xF5 */
+    } else { /* u >= 0xF5 */
         /* Restricted (start of 4-, 5- or 6-byte sequence) or invalid
            UTF-8 */
         return 0;
     }
 }
 
-size_t utf8_check_full(const char *buffer, size_t size, int32_t *codepoint)
-{
+size_t utf8_check_full(const char *buffer, size_t size, int32_t *codepoint) {
     size_t i;
     int32_t value = 0;
     unsigned char u = (unsigned char)buffer[0];
 
-    if(size == 2)
-    {
+    if (size == 2) {
         value = u & 0x1F;
-    }
-    else if(size == 3)
-    {
+    } else if (size == 3) {
         value = u & 0xF;
-    }
-    else if(size == 4)
-    {
+    } else if (size == 4) {
         value = u & 0x7;
-    }
-    else
+    } else
         return 0;
 
-    for(i = 1; i < size; i++)
-    {
+    for (i = 1; i < size; i++) {
         u = (unsigned char)buffer[i];
 
-        if(u < 0x80 || u > 0xBF) {
+        if (u < 0x80 || u > 0xBF) {
             /* not a continuation byte */
             return 0;
         }
@@ -113,70 +91,64 @@ size_t utf8_check_full(const char *buffer, size_t size, int32_t *codepoint)
         value = (value << 6) + (u & 0x3F);
     }
 
-    if(value > 0x10FFFF) {
+    if (value > 0x10FFFF) {
         /* not in Unicode range */
         return 0;
     }
 
-    else if(0xD800 <= value && value <= 0xDFFF) {
+    else if (0xD800 <= value && value <= 0xDFFF) {
         /* invalid code point (UTF-16 surrogate halves) */
         return 0;
     }
 
-    else if((size == 2 && value < 0x80) ||
-            (size == 3 && value < 0x800) ||
-            (size == 4 && value < 0x10000)) {
+    else if ((size == 2 && value < 0x80) || (size == 3 && value < 0x800) ||
+             (size == 4 && value < 0x10000)) {
         /* overlong encoding */
         return 0;
     }
 
-    if(codepoint)
+    if (codepoint)
         *codepoint = value;
 
     return 1;
 }
 
-const char *utf8_iterate(const char *buffer, size_t bufsize, int32_t *codepoint)
-{
+const char *utf8_iterate(const char *buffer, size_t bufsize, int32_t *codepoint) {
     size_t count;
     int32_t value;
 
-    if(!bufsize)
+    if (!bufsize)
         return buffer;
 
     count = utf8_check_first(buffer[0]);
-    if(count <= 0)
+    if (count <= 0)
         return NULL;
 
-    if(count == 1)
+    if (count == 1)
         value = (unsigned char)buffer[0];
-    else
-    {
-        if(count > bufsize || !utf8_check_full(buffer, count, &value))
+    else {
+        if (count > bufsize || !utf8_check_full(buffer, count, &value))
             return NULL;
     }
 
-    if(codepoint)
+    if (codepoint)
         *codepoint = value;
 
     return buffer + count;
 }
 
-int utf8_check_string(const char *string, size_t length)
-{
+int utf8_check_string(const char *string, size_t length) {
     size_t i;
 
-    for(i = 0; i < length; i++)
-    {
+    for (i = 0; i < length; i++) {
         size_t count = utf8_check_first(string[i]);
-        if(count == 0)
+        if (count == 0)
             return 0;
-        else if(count > 1)
-        {
-            if(count > length - i)
+        else if (count > 1) {
+            if (count > length - i)
                 return 0;
 
-            if(!utf8_check_full(&string[i], count, NULL))
+            if (!utf8_check_full(&string[i], count, NULL))
                 return 0;
 
             i += count - 1;
diff --git a/src/utf.h b/src/utf.h
index e182df7..5db99df 100644
--- a/src/utf.h
+++ b/src/utf.h
@@ -12,6 +12,7 @@
 #include <jansson_private_config.h>
 #endif
 
+#include <stddef.h>
 #ifdef HAVE_STDINT_H
 #include <stdint.h>
 #endif
diff --git a/src/value.c b/src/value.c
index e09a485..a1a4705 100644
--- a/src/value.c
+++ b/src/value.c
@@ -13,17 +13,17 @@
 #include <jansson_private_config.h>
 #endif
 
+#include <math.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
-#include <math.h>
 
 #ifdef HAVE_STDINT_H
 #include <stdint.h>
 #endif
 
-#include "jansson.h"
 #include "hashtable.h"
+#include "jansson.h"
 #include "jansson_private.h"
 #include "utf.h"
 
@@ -39,14 +39,13 @@ static JSON_INLINE int isinf(double x) { return !isnan(x) && isnan(x - x); }
 
 json_t *do_deep_copy(const json_t *json, hashtable_t *parents);
 
-static JSON_INLINE void json_init(json_t *json, json_type type)
-{
+static JSON_INLINE void json_init(json_t *json, json_type type) {
     json->type = type;
     json->refcount = 1;
 }
 
-int jsonp_loop_check(hashtable_t *parents, const json_t *json, char *key, size_t key_size)
-{
+int jsonp_loop_check(hashtable_t *parents, const json_t *json, char *key,
+                     size_t key_size) {
     snprintf(key, key_size, "%p", json);
     if (hashtable_get(parents, key))
         return -1;
@@ -58,10 +57,9 @@ int jsonp_loop_check(hashtable_t *parents, const json_t *json, char *key, size_t
 
 extern volatile uint32_t hashtable_seed;
 
-json_t *json_object(void)
-{
+json_t *json_object(void) {
     json_object_t *object = jsonp_malloc(sizeof(json_object_t));
-    if(!object)
+    if (!object)
         return NULL;
 
     if (!hashtable_seed) {
@@ -71,8 +69,7 @@ json_t *json_object(void)
 
     json_init(&object->json, JSON_OBJECT);
 
-    if(hashtable_init(&object->hashtable))
-    {
+    if (hashtable_init(&object->hashtable)) {
         jsonp_free(object);
         return NULL;
     }
@@ -80,50 +77,44 @@ json_t *json_object(void)
     return &object->json;
 }
 
-static void json_delete_object(json_object_t *object)
-{
+static void json_delete_object(json_object_t *object) {
     hashtable_close(&object->hashtable);
     jsonp_free(object);
 }
 
-size_t json_object_size(const json_t *json)
-{
+size_t json_object_size(const json_t *json) {
     json_object_t *object;
 
-    if(!json_is_object(json))
+    if (!json_is_object(json))
         return 0;
 
     object = json_to_object(json);
     return object->hashtable.size;
 }
 
-json_t *json_object_get(const json_t *json, const char *key)
-{
+json_t *json_object_get(const json_t *json, const char *key) {
     json_object_t *object;
 
-    if(!key || !json_is_object(json))
+    if (!key || !json_is_object(json))
         return NULL;
 
     object = json_to_object(json);
     return hashtable_get(&object->hashtable, key);
 }
 
-int json_object_set_new_nocheck(json_t *json, const char *key, json_t *value)
-{
+int json_object_set_new_nocheck(json_t *json, const char *key, json_t *value) {
     json_object_t *object;
 
-    if(!value)
+    if (!value)
         return -1;
 
-    if(!key || !json_is_object(json) || json == value)
-    {
+    if (!key || !json_is_object(json) || json == value) {
         json_decref(value);
         return -1;
     }
     object = json_to_object(json);
 
-    if(hashtable_set(&object->hashtable, key, value))
-    {
+    if (hashtable_set(&object->hashtable, key, value)) {
         json_decref(value);
         return -1;
     }
@@ -131,10 +122,8 @@ int json_object_set_new_nocheck(json_t *json, const char *key, json_t *value)
     return 0;
 }
 
-int json_object_set_new(json_t *json, const char *key, json_t *value)
-{
-    if(!key || !utf8_check_string(key, strlen(key)))
-    {
+int json_object_set_new(json_t *json, const char *key, json_t *value) {
+    if (!key || !utf8_check_string(key, strlen(key))) {
         json_decref(value);
         return -1;
     }
@@ -142,22 +131,20 @@ int json_object_set_new(json_t *json, const char *key, json_t *value)
     return json_object_set_new_nocheck(json, key, value);
 }
 
-int json_object_del(json_t *json, const char *key)
-{
+int json_object_del(json_t *json, const char *key) {
     json_object_t *object;
 
-    if(!key || !json_is_object(json))
+    if (!key || !json_is_object(json))
         return -1;
 
     object = json_to_object(json);
     return hashtable_del(&object->hashtable, key);
 }
 
-int json_object_clear(json_t *json)
-{
+int json_object_clear(json_t *json) {
     json_object_t *object;
 
-    if(!json_is_object(json))
+    if (!json_is_object(json))
         return -1;
 
     object = json_to_object(json);
@@ -166,82 +153,73 @@ int json_object_clear(json_t *json)
     return 0;
 }
 
-int json_object_update(json_t *object, json_t *other)
-{
+int json_object_update(json_t *object, json_t *other) {
     const char *key;
     json_t *value;
 
-    if(!json_is_object(object) || !json_is_object(other))
+    if (!json_is_object(object) || !json_is_object(other))
         return -1;
 
     json_object_foreach(other, key, value) {
-        if(json_object_set_nocheck(object, key, value))
+        if (json_object_set_nocheck(object, key, value))
             return -1;
     }
 
     return 0;
 }
 
-int json_object_update_existing(json_t *object, json_t *other)
-{
+int json_object_update_existing(json_t *object, json_t *other) {
     const char *key;
     json_t *value;
 
-    if(!json_is_object(object) || !json_is_object(other))
+    if (!json_is_object(object) || !json_is_object(other))
         return -1;
 
     json_object_foreach(other, key, value) {
-        if(json_object_get(object, key))
+        if (json_object_get(object, key))
             json_object_set_nocheck(object, key, value);
     }
 
     return 0;
 }
 
-int json_object_update_missing(json_t *object, json_t *other)
-{
+int json_object_update_missing(json_t *object, json_t *other) {
     const char *key;
     json_t *value;
 
-    if(!json_is_object(object) || !json_is_object(other))
+    if (!json_is_object(object) || !json_is_object(other))
         return -1;
 
     json_object_foreach(other, key, value) {
-        if(!json_object_get(object, key))
+        if (!json_object_get(object, key))
             json_object_set_nocheck(object, key, value);
     }
 
     return 0;
 }
 
-int do_object_update_recursive(json_t *object, json_t *other, hashtable_t *parents)
-{
+int do_object_update_recursive(json_t *object, json_t *other, hashtable_t *parents) {
     const char *key;
     json_t *value;
     char loop_key[LOOP_KEY_LEN];
     int res = 0;
 
-    if(!json_is_object(object) || !json_is_object(other))
+    if (!json_is_object(object) || !json_is_object(other))
         return -1;
 
-    if(jsonp_loop_check(parents, other, loop_key, sizeof(loop_key)))
+    if (jsonp_loop_check(parents, other, loop_key, sizeof(loop_key)))
         return -1;
 
     json_object_foreach(other, key, value) {
         json_t *v = json_object_get(object, key);
 
-        if(json_is_object(v) && json_is_object(value))
-        {
-            if(do_object_update_recursive(v, value, parents))
-            {
+        if (json_is_object(v) && json_is_object(value)) {
+            if (do_object_update_recursive(v, value, parents)) {
                 res = -1;
                 break;
             }
-        }
-        else
-        {
-            if(json_object_set_nocheck(object, key, value))
-            {
+        } else {
+            if (json_object_set_nocheck(object, key, value)) {
                 res = -1;
                 break;
             }
@@ -253,8 +231,7 @@ int do_object_update_recursive(json_t *object, json_t *other, hashtable_t *paren
     return res;
 }
 
-int json_object_update_recursive(json_t *object, json_t *other)
-{
+int json_object_update_recursive(json_t *object, json_t *other) {
     int res;
     hashtable_t parents_set;
 
@@ -266,59 +243,52 @@ int json_object_update_recursive(json_t *object, json_t *other)
     return res;
 }
 
-void *json_object_iter(json_t *json)
-{
+void *json_object_iter(json_t *json) {
     json_object_t *object;
 
-    if(!json_is_object(json))
+    if (!json_is_object(json))
         return NULL;
 
     object = json_to_object(json);
     return hashtable_iter(&object->hashtable);
 }
 
-void *json_object_iter_at(json_t *json, const char *key)
-{
+void *json_object_iter_at(json_t *json, const char *key) {
     json_object_t *object;
 
-    if(!key || !json_is_object(json))
+    if (!key || !json_is_object(json))
         return NULL;
 
     object = json_to_object(json);
     return hashtable_iter_at(&object->hashtable, key);
 }
 
-void *json_object_iter_next(json_t *json, void *iter)
-{
+void *json_object_iter_next(json_t *json, void *iter) {
     json_object_t *object;
 
-    if(!json_is_object(json) || iter == NULL)
+    if (!json_is_object(json) || iter == NULL)
         return NULL;
 
     object = json_to_object(json);
     return hashtable_iter_next(&object->hashtable, iter);
 }
 
-const char *json_object_iter_key(void *iter)
-{
-    if(!iter)
+const char *json_object_iter_key(void *iter) {
+    if (!iter)
         return NULL;
 
     return hashtable_iter_key(iter);
 }
 
-json_t *json_object_iter_value(void *iter)
-{
-    if(!iter)
+json_t *json_object_iter_value(void *iter) {
+    if (!iter)
         return NULL;
 
     return (json_t *)hashtable_iter_value(iter);
 }
 
-int json_object_iter_set_new(json_t *json, void *iter, json_t *value)
-{
-    if(!json_is_object(json) || !iter || !value)
-    {
+int json_object_iter_set_new(json_t *json, void *iter, json_t *value) {
+    if (!json_is_object(json) || !iter || !value) {
         json_decref(value);
         return -1;
     }
@@ -327,51 +297,46 @@ int json_object_iter_set_new(json_t *json, void *iter, json_t *value)
     return 0;
 }
 
-void *json_object_key_to_iter(const char *key)
-{
-    if(!key)
+void *json_object_key_to_iter(const char *key) {
+    if (!key)
         return NULL;
 
     return hashtable_key_to_iter(key);
 }
 
-static int json_object_equal(const json_t *object1, const json_t *object2)
-{
+static int json_object_equal(const json_t *object1, const json_t *object2) {
     const char *key;
     const json_t *value1, *value2;
 
-    if(json_object_size(object1) != json_object_size(object2))
+    if (json_object_size(object1) != json_object_size(object2))
         return 0;
 
     json_object_foreach((json_t *)object1, key, value1) {
         value2 = json_object_get(object2, key);
 
-        if(!json_equal(value1, value2))
+        if (!json_equal(value1, value2))
             return 0;
     }
 
     return 1;
 }
 
-static json_t *json_object_copy(json_t *object)
-{
+static json_t *json_object_copy(json_t *object) {
     json_t *result;
 
     const char *key;
     json_t *value;
 
     result = json_object();
-    if(!result)
+    if (!result)
         return NULL;
 
-    json_object_foreach(object, key, value)
-        json_object_set_nocheck(result, key, value);
+    json_object_foreach(object, key, value) json_object_set_nocheck(result, key, value);
 
     return result;
 }
 
-static json_t *json_object_deep_copy(const json_t *object, hashtable_t *parents)
-{
+static json_t *json_object_deep_copy(const json_t *object, hashtable_t *parents) {
     json_t *result;
     void *iter;
     char loop_key[LOOP_KEY_LEN];
@@ -380,20 +345,19 @@ static json_t *json_object_deep_copy(const json_t *object, hashtable_t *parents)
         return NULL;
 
     result = json_object();
-    if(!result)
+    if (!result)
         goto out;
 
     /* Cannot use json_object_foreach because object has to be cast
        non-const */
     iter = json_object_iter((json_t *)object);
-    while(iter) {
+    while (iter) {
         const char *key;
         const json_t *value;
         key = json_object_iter_key(iter);
         value = json_object_iter_value(iter);
 
-        if (json_object_set_new_nocheck(result, key, do_deep_copy(value, parents)))
-        {
+        if (json_object_set_new_nocheck(result, key, do_deep_copy(value, parents))) {
             json_decref(result);
             result = NULL;
             break;
@@ -407,13 +371,11 @@ out:
     return result;
 }
 
-
 /*** array ***/
 
-json_t *json_array(void)
-{
+json_t *json_array(void) {
     json_array_t *array = jsonp_malloc(sizeof(json_array_t));
-    if(!array)
+    if (!array)
         return NULL;
     json_init(&array->json, JSON_ARRAY);
 
@@ -421,7 +383,7 @@ json_t *json_array(void)
     array->size = 8;
 
     array->table = jsonp_malloc(array->size * sizeof(json_t *));
-    if(!array->table) {
+    if (!array->table) {
         jsonp_free(array);
         return NULL;
     }
@@ -429,54 +391,48 @@ json_t *json_array(void)
     return &array->json;
 }
 
-static void json_delete_array(json_array_t *array)
-{
+static void json_delete_array(json_array_t *array) {
     size_t i;
 
-    for(i = 0; i < array->entries; i++)
+    for (i = 0; i < array->entries; i++)
         json_decref(array->table[i]);
 
     jsonp_free(array->table);
     jsonp_free(array);
 }
 
-size_t json_array_size(const json_t *json)
-{
-    if(!json_is_array(json))
+size_t json_array_size(const json_t *json) {
+    if (!json_is_array(json))
         return 0;
 
     return json_to_array(json)->entries;
 }
 
-json_t *json_array_get(const json_t *json, size_t index)
-{
+json_t *json_array_get(const json_t *json, size_t index) {
     json_array_t *array;
-    if(!json_is_array(json))
+    if (!json_is_array(json))
         return NULL;
     array = json_to_array(json);
 
-    if(index >= array->entries)
+    if (index >= array->entries)
         return NULL;
 
     return array->table[index];
 }
 
-int json_array_set_new(json_t *json, size_t index, json_t *value)
-{
+int json_array_set_new(json_t *json, size_t index, json_t *value) {
     json_array_t *array;
 
-    if(!value)
+    if (!value)
         return -1;
 
-    if(!json_is_array(json) || json == value)
-    {
+    if (!json_is_array(json) || json == value) {
         json_decref(value);
         return -1;
     }
     array = json_to_array(json);
 
-    if(index >= array->entries)
-    {
+    if (index >= array->entries) {
         json_decref(value);
         return -1;
     }
@@ -487,40 +443,33 @@ int json_array_set_new(json_t *json, size_t index, json_t *value)
     return 0;
 }
 
-static void array_move(json_array_t *array, size_t dest,
-                       size_t src, size_t count)
-{
+static void array_move(json_array_t *array, size_t dest, size_t src, size_t count) {
     memmove(&array->table[dest], &array->table[src], count * sizeof(json_t *));
 }
 
-static void array_copy(json_t **dest, size_t dpos,
-                       json_t **src, size_t spos,
-                       size_t count)
-{
+static void array_copy(json_t **dest, size_t dpos, json_t **src, size_t spos,
+                       size_t count) {
     memcpy(&dest[dpos], &src[spos], count * sizeof(json_t *));
 }
 
-static json_t **json_array_grow(json_array_t *array,
-                                size_t amount,
-                                int copy)
-{
+static json_t **json_array_grow(json_array_t *array, size_t amount, int copy) {
     size_t new_size;
     json_t **old_table, **new_table;
 
-    if(array->entries + amount <= array->size)
+    if (array->entries + amount <= array->size)
         return array->table;
 
     old_table = array->table;
 
     new_size = max(array->size + amount, array->size * 2);
     new_table = jsonp_malloc(new_size * sizeof(json_t *));
-    if(!new_table)
+    if (!new_table)
         return NULL;
 
     array->size = new_size;
     array->table = new_table;
 
-    if(copy) {
+    if (copy) {
         array_copy(array->table, 0, old_table, 0, array->entries);
         jsonp_free(old_table);
         return array->table;
@@ -529,21 +478,19 @@ static json_t **json_array_grow(json_array_t *array,
     return old_table;
 }
 
-int json_array_append_new(json_t *json, json_t *value)
-{
+int json_array_append_new(json_t *json, json_t *value) {
     json_array_t *array;
 
-    if(!value)
+    if (!value)
         return -1;
 
-    if(!json_is_array(json) || json == value)
-    {
+    if (!json_is_array(json) || json == value) {
         json_decref(value);
         return -1;
     }
     array = json_to_array(json);
 
-    if(!json_array_grow(array, 1, 1)) {
+    if (!json_array_grow(array, 1, 1)) {
         json_decref(value);
         return -1;
     }
@@ -554,38 +501,35 @@ int json_array_append_new(json_t *json, json_t *value)
     return 0;
 }
 
-int json_array_insert_new(json_t *json, size_t index, json_t *value)
-{
+int json_array_insert_new(json_t *json, size_t index, json_t *value) {
     json_array_t *array;
     json_t **old_table;
 
-    if(!value)
+    if (!value)
         return -1;
 
-    if(!json_is_array(json) || json == value) {
+    if (!json_is_array(json) || json == value) {
         json_decref(value);
         return -1;
     }
     array = json_to_array(json);
 
-    if(index > array->entries) {
+    if (index > array->entries) {
         json_decref(value);
         return -1;
     }
 
     old_table = json_array_grow(array, 1, 0);
-    if(!old_table) {
+    if (!old_table) {
         json_decref(value);
         return -1;
     }
 
-    if(old_table != array->table) {
+    if (old_table != array->table) {
         array_copy(array->table, 0, old_table, 0, index);
-        array_copy(array->table, index + 1, old_table, index,
-                   array->entries - index);
+        array_copy(array->table, index + 1, old_table, index, array->entries - index);
         jsonp_free(old_table);
-    }
-    else
+    } else
         array_move(array, index + 1, index, array->entries - index);
 
     array->table[index] = value;
@@ -594,21 +538,20 @@ int json_array_insert_new(json_t *json, size_t index, json_t *value)
     return 0;
 }
 
-int json_array_remove(json_t *json, size_t index)
-{
+int json_array_remove(json_t *json, size_t index) {
     json_array_t *array;
 
-    if(!json_is_array(json))
+    if (!json_is_array(json))
         return -1;
     array = json_to_array(json);
 
-    if(index >= array->entries)
+    if (index >= array->entries)
         return -1;
 
     json_decref(array->table[index]);
 
     /* If we're removing the last element, nothing has to be moved */
-    if(index < array->entries - 1)
+    if (index < array->entries - 1)
         array_move(array, index, index + 1, array->entries - index - 1);
 
     array->entries--;
@@ -616,36 +559,34 @@ int json_array_remove(json_t *json, size_t index)
     return 0;
 }
 
-int json_array_clear(json_t *json)
-{
+int json_array_clear(json_t *json) {
     json_array_t *array;
     size_t i;
 
-    if(!json_is_array(json))
+    if (!json_is_array(json))
         return -1;
     array = json_to_array(json);
 
-    for(i = 0; i < array->entries; i++)
+    for (i = 0; i < array->entries; i++)
         json_decref(array->table[i]);
 
     array->entries = 0;
     return 0;
 }
 
-int json_array_extend(json_t *json, json_t *other_json)
-{
+int json_array_extend(json_t *json, json_t *other_json) {
     json_array_t *array, *other;
     size_t i;
 
-    if(!json_is_array(json) || !json_is_array(other_json))
+    if (!json_is_array(json) || !json_is_array(other_json))
         return -1;
     array = json_to_array(json);
     other = json_to_array(other_json);
 
-    if(!json_array_grow(array, other->entries, 1))
+    if (!json_array_grow(array, other->entries, 1))
         return -1;
 
-    for(i = 0; i < other->entries; i++)
+    for (i = 0; i < other->entries; i++)
         json_incref(other->table[i]);
 
     array_copy(array->table, array->entries, other->table, 0, other->entries);
@@ -654,45 +595,41 @@ int json_array_extend(json_t *json, json_t *other_json)
     return 0;
 }
 
-static int json_array_equal(const json_t *array1, const json_t *array2)
-{
+static int json_array_equal(const json_t *array1, const json_t *array2) {
     size_t i, size;
 
     size = json_array_size(array1);
-    if(size != json_array_size(array2))
+    if (size != json_array_size(array2))
         return 0;
 
-    for(i = 0; i < size; i++)
-    {
+    for (i = 0; i < size; i++) {
         json_t *value1, *value2;
 
         value1 = json_array_get(array1, i);
         value2 = json_array_get(array2, i);
 
-        if(!json_equal(value1, value2))
+        if (!json_equal(value1, value2))
             return 0;
     }
 
     return 1;
 }
 
-static json_t *json_array_copy(json_t *array)
-{
+static json_t *json_array_copy(json_t *array) {
     json_t *result;
     size_t i;
 
     result = json_array();
-    if(!result)
+    if (!result)
         return NULL;
 
-    for(i = 0; i < json_array_size(array); i++)
+    for (i = 0; i < json_array_size(array); i++)
         json_array_append(result, json_array_get(array, i));
 
     return result;
 }
 
-static json_t *json_array_deep_copy(const json_t *array, hashtable_t *parents)
-{
+static json_t *json_array_deep_copy(const json_t *array, hashtable_t *parents) {
     json_t *result;
     size_t i;
     char loop_key[LOOP_KEY_LEN];
@@ -701,13 +638,12 @@ static json_t *json_array_deep_copy(const json_t *array, hashtable_t *parents)
         return NULL;
 
     result = json_array();
-    if(!result)
+    if (!result)
         goto out;
 
-    for(i = 0; i < json_array_size(array); i++)
-    {
-        if (json_array_append_new(result, do_deep_copy(json_array_get(array, i), parents)))
-        {
+    for (i = 0; i < json_array_size(array); i++) {
+        if (json_array_append_new(result,
+                                  do_deep_copy(json_array_get(array, i), parents))) {
             json_decref(result);
             result = NULL;
             break;
@@ -722,24 +658,23 @@ out:
 
 /*** string ***/
 
-static json_t *string_create(const char *value, size_t len, int own)
-{
+static json_t *string_create(const char *value, size_t len, int own) {
     char *v;
     json_string_t *string;
 
-    if(!value)
+    if (!value)
         return NULL;
 
-    if(own)
+    if (own)
         v = (char *)value;
     else {
         v = jsonp_strndup(value, len);
-        if(!v)
+        if (!v)
             return NULL;
     }
 
     string = jsonp_malloc(sizeof(json_string_t));
-    if(!string) {
+    if (!string) {
         jsonp_free(v);
         return NULL;
     }
@@ -750,75 +685,66 @@ static json_t *string_create(const char *value, size_t len, int own)
     return &string->json;
 }
 
-json_t *json_string_nocheck(const char *value)
-{
-    if(!value)
+json_t *json_string_nocheck(const char *value) {
+    if (!value)
         return NULL;
 
     return string_create(value, strlen(value), 0);
 }
 
-json_t *json_stringn_nocheck(const char *value, size_t len)
-{
+json_t *json_stringn_nocheck(const char *value, size_t len) {
     return string_create(value, len, 0);
 }
 
 /* this is private; "steal" is not a public API concept */
-json_t *jsonp_stringn_nocheck_own(const char *value, size_t len)
-{
+json_t *jsonp_stringn_nocheck_own(const char *value, size_t len) {
     return string_create(value, len, 1);
 }
 
-json_t *json_string(const char *value)
-{
-    if(!value)
+json_t *json_string(const char *value) {
+    if (!value)
         return NULL;
 
     return json_stringn(value, strlen(value));
 }
 
-json_t *json_stringn(const char *value, size_t len)
-{
-    if(!value || !utf8_check_string(value, len))
+json_t *json_stringn(const char *value, size_t len) {
+    if (!value || !utf8_check_string(value, len))
         return NULL;
 
     return json_stringn_nocheck(value, len);
 }
 
-const char *json_string_value(const json_t *json)
-{
-    if(!json_is_string(json))
+const char *json_string_value(const json_t *json) {
+    if (!json_is_string(json))
         return NULL;
 
     return json_to_string(json)->value;
 }
 
-size_t json_string_length(const json_t *json)
-{
-    if(!json_is_string(json))
+size_t json_string_length(const json_t *json) {
+    if (!json_is_string(json))
         return 0;
 
     return json_to_string(json)->length;
 }
 
-int json_string_set_nocheck(json_t *json, const char *value)
-{
-    if(!value)
+int json_string_set_nocheck(json_t *json, const char *value) {
+    if (!value)
         return -1;
 
     return json_string_setn_nocheck(json, value, strlen(value));
 }
 
-int json_string_setn_nocheck(json_t *json, const char *value, size_t len)
-{
+int json_string_setn_nocheck(json_t *json, const char *value, size_t len) {
     char *dup;
     json_string_t *string;
 
-    if(!json_is_string(json) || !value)
+    if (!json_is_string(json) || !value)
         return -1;
 
     dup = jsonp_strndup(value, len);
-    if(!dup)
+    if (!dup)
         return -1;
 
     string = json_to_string(json);
@@ -829,30 +755,26 @@ int json_string_setn_nocheck(json_t *json, const char *value, size_t len)
     return 0;
 }
 
-int json_string_set(json_t *json, const char *value)
-{
-    if(!value)
+int json_string_set(json_t *json, const char *value) {
+    if (!value)
         return -1;
 
     return json_string_setn(json, value, strlen(value));
 }
 
-int json_string_setn(json_t *json, const char *value, size_t len)
-{
-    if(!value || !utf8_check_string(value, len))
+int json_string_setn(json_t *json, const char *value, size_t len) {
+    if (!value || !utf8_check_string(value, len))
         return -1;
 
     return json_string_setn_nocheck(json, value, len);
 }
 
-static void json_delete_string(json_string_t *string)
-{
+static void json_delete_string(json_string_t *string) {
     jsonp_free(string->value);
     jsonp_free(string);
 }
 
-static int json_string_equal(const json_t *string1, const json_t *string2)
-{
+static int json_string_equal(const json_t *string1, const json_t *string2) {
     json_string_t *s1, *s2;
 
     s1 = json_to_string(string1);
@@ -860,8 +782,7 @@ static int json_string_equal(const json_t *string1, const json_t *string2)
     return s1->length == s2->length && !memcmp(s1->value, s2->value, s1->length);
 }
 
-static json_t *json_string_copy(const json_t *string)
-{
+static json_t *json_string_copy(const json_t *string) {
     json_string_t *s;
 
     s = json_to_string(string);
@@ -909,13 +830,11 @@ json_t *json_sprintf(const char *fmt, ...) {
     return result;
 }
 
-
 /*** integer ***/
 
-json_t *json_integer(json_int_t value)
-{
+json_t *json_integer(json_int_t value) {
     json_integer_t *integer = jsonp_malloc(sizeof(json_integer_t));
-    if(!integer)
+    if (!integer)
         return NULL;
     json_init(&integer->json, JSON_INTEGER);
 
@@ -923,17 +842,15 @@ json_t *json_integer(json_int_t value)
     return &integer->json;
 }
 
-json_int_t json_integer_value(const json_t *json)
-{
-    if(!json_is_integer(json))
+json_int_t json_integer_value(const json_t *json) {
+    if (!json_is_integer(json))
         return 0;
 
     return json_to_integer(json)->value;
 }
 
-int json_integer_set(json_t *json, json_int_t value)
-{
-    if(!json_is_integer(json))
+int json_integer_set(json_t *json, json_int_t value) {
+    if (!json_is_integer(json))
         return -1;
 
     json_to_integer(json)->value = value;
@@ -941,33 +858,26 @@ int json_integer_set(json_t *json, json_int_t value)
     return 0;
 }
 
-static void json_delete_integer(json_integer_t *integer)
-{
-    jsonp_free(integer);
-}
+static void json_delete_integer(json_integer_t *integer) { jsonp_free(integer); }
 
-static int json_integer_equal(const json_t *integer1, const json_t *integer2)
-{
+static int json_integer_equal(const json_t *integer1, const json_t *integer2) {
     return json_integer_value(integer1) == json_integer_value(integer2);
 }
 
-static json_t *json_integer_copy(const json_t *integer)
-{
+static json_t *json_integer_copy(const json_t *integer) {
     return json_integer(json_integer_value(integer));
 }
 
-
 /*** real ***/
 
-json_t *json_real(double value)
-{
+json_t *json_real(double value) {
     json_real_t *real;
 
-    if(isnan(value) || isinf(value))
+    if (isnan(value) || isinf(value))
         return NULL;
 
     real = jsonp_malloc(sizeof(json_real_t));
-    if(!real)
+    if (!real)
         return NULL;
     json_init(&real->json, JSON_REAL);
 
@@ -975,17 +885,15 @@ json_t *json_real(double value)
     return &real->json;
 }
 
-double json_real_value(const json_t *json)
-{
-    if(!json_is_real(json))
+double json_real_value(const json_t *json) {
+    if (!json_is_real(json))
         return 0;
 
     return json_to_real(json)->value;
 }
 
-int json_real_set(json_t *json, double value)
-{
-    if(!json_is_real(json) || isnan(value) || isinf(value))
+int json_real_set(json_t *json, double value) {
+    if (!json_is_real(json) || isnan(value) || isinf(value))
         return -1;
 
     json_to_real(json)->value = value;
@@ -993,66 +901,51 @@ int json_real_set(json_t *json, double value)
     return 0;
 }
 
-static void json_delete_real(json_real_t *real)
-{
-    jsonp_free(real);
-}
+static void json_delete_real(json_real_t *real) { jsonp_free(real); }
 
-static int json_real_equal(const json_t *real1, const json_t *real2)
-{
+static int json_real_equal(const json_t *real1, const json_t *real2) {
     return json_real_value(real1) == json_real_value(real2);
 }
 
-static json_t *json_real_copy(const json_t *real)
-{
+static json_t *json_real_copy(const json_t *real) {
     return json_real(json_real_value(real));
 }
 
-
 /*** number ***/
 
-double json_number_value(const json_t *json)
-{
-    if(json_is_integer(json))
+double json_number_value(const json_t *json) {
+    if (json_is_integer(json))
         return (double)json_integer_value(json);
-    else if(json_is_real(json))
+    else if (json_is_real(json))
         return json_real_value(json);
     else
         return 0.0;
 }
 
-
 /*** simple values ***/
 
-json_t *json_true(void)
-{
+json_t *json_true(void) {
     static json_t the_true = {JSON_TRUE, (size_t)-1};
     return &the_true;
 }
 
-
-json_t *json_false(void)
-{
+json_t *json_false(void) {
     static json_t the_false = {JSON_FALSE, (size_t)-1};
     return &the_false;
 }
 
-
-json_t *json_null(void)
-{
+json_t *json_null(void) {
     static json_t the_null = {JSON_NULL, (size_t)-1};
     return &the_null;
 }
 
-
 /*** deletion ***/
 
-void json_delete(json_t *json)
-{
+void json_delete(json_t *json) {
     if (!json)
         return;
 
-    switch(json_typeof(json)) {
+    switch (json_typeof(json)) {
         case JSON_OBJECT:
             json_delete_object(json_to_object(json));
             break;
@@ -1075,22 +968,20 @@ void json_delete(json_t *json)
     /* json_delete is not called for true, false or null */
 }
 
-
 /*** equality ***/
 
-int json_equal(const json_t *json1, const json_t *json2)
-{
-    if(!json1 || !json2)
+int json_equal(const json_t *json1, const json_t *json2) {
+    if (!json1 || !json2)
         return 0;
 
-    if(json_typeof(json1) != json_typeof(json2))
+    if (json_typeof(json1) != json_typeof(json2))
         return 0;
 
     /* this covers true, false and null as they are singletons */
-    if(json1 == json2)
+    if (json1 == json2)
         return 1;
 
-    switch(json_typeof(json1)) {
+    switch (json_typeof(json1)) {
         case JSON_OBJECT:
             return json_object_equal(json1, json2);
         case JSON_ARRAY:
@@ -1106,15 +997,13 @@ int json_equal(const json_t *json1, const json_t *json2)
     }
 }
 
-
 /*** copying ***/
 
-json_t *json_copy(json_t *json)
-{
-    if(!json)
+json_t *json_copy(json_t *json) {
+    if (!json)
         return NULL;
 
-    switch(json_typeof(json)) {
+    switch (json_typeof(json)) {
         case JSON_OBJECT:
             return json_object_copy(json);
         case JSON_ARRAY:
@@ -1134,8 +1023,7 @@ json_t *json_copy(json_t *json)
     }
 }
 
-json_t *json_deep_copy(const json_t *json)
-{
+json_t *json_deep_copy(const json_t *json) {
     json_t *res;
     hashtable_t parents_set;
 
@@ -1147,12 +1035,11 @@ json_t *json_deep_copy(const json_t *json)
     return res;
 }
 
-json_t *do_deep_copy(const json_t *json, hashtable_t *parents)
-{
-    if(!json)
+json_t *do_deep_copy(const json_t *json, hashtable_t *parents) {
+    if (!json)
         return NULL;
 
-    switch(json_typeof(json)) {
+    switch (json_typeof(json)) {
         case JSON_OBJECT:
             return json_object_deep_copy(json, parents);
         case JSON_ARRAY:
diff --git a/src/version.c b/src/version.c
index 11435dd..f1026af 100644
--- a/src/version.c
+++ b/src/version.c
@@ -11,13 +11,9 @@
 
 #include "jansson.h"
 
-const char *jansson_version_str(void)
-{
-    return JANSSON_VERSION;
-}
+const char *jansson_version_str(void) { return JANSSON_VERSION; }
 
-int jansson_version_cmp(int major, int minor, int micro)
-{
+int jansson_version_cmp(int major, int minor, int micro) {
     int diff;
 
     if ((diff = JANSSON_MAJOR_VERSION - major)) {
diff --git a/test/.gitignore b/test/.gitignore
index d643dc8..6a33dea 100644
--- a/test/.gitignore
+++ b/test/.gitignore
@@ -18,7 +18,3 @@ suites/api/test_simple
 suites/api/test_sprintf
 suites/api/test_unpack
 suites/api/test_version
-run-suites.log
-run-suites.trs
-test-suite.log
-
diff --git a/test/bin/json_process.c b/test/bin/json_process.c
index 0b9ece8..f7f46d0 100644
--- a/test/bin/json_process.c
+++ b/test/bin/json_process.c
@@ -9,26 +9,25 @@
 #include <jansson_private_config.h>
 #endif
 
+#include <ctype.h>
+#include <jansson.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
-#include <jansson.h>
 
 #ifdef HAVE_LOCALE_H
 #include <locale.h>
- #endif
+#endif
 
 #if _WIN32
-#include <io.h>  /* for _setmode() */
-#include <fcntl.h>  /* for _O_BINARY */
+#include <fcntl.h> /* for _O_BINARY */
+#include <io.h>    /* for _setmode() */
 
 static const char dir_sep = '\\';
 #else
 static const char dir_sep = '/';
 #endif
 
-
 struct config {
     int indent;
     int compact;
@@ -47,8 +46,7 @@ struct config {
 /* Return a pointer to the first non-whitespace character of str.
    Modifies str so that all trailing whitespace characters are
    replaced by '\0'. */
-static const char *strip(char *str)
-{
+static const char *strip(char *str) {
     size_t length;
     char *result = str;
     while (*result && l_isspace(*result))
@@ -64,9 +62,7 @@ static const char *strip(char *str)
     return result;
 }
 
-
-static char *loadfile(FILE *file)
-{
+static char *loadfile(FILE *file) {
     long fsize, ret;
     char *buf;
 
@@ -74,7 +70,7 @@ static char *loadfile(FILE *file)
     fsize = ftell(file);
     fseek(file, 0, SEEK_SET);
 
-    buf = malloc(fsize+1);
+    buf = malloc(fsize + 1);
     ret = fread(buf, 1, fsize, file);
     if (ret != fsize)
         exit(1);
@@ -83,9 +79,7 @@ static char *loadfile(FILE *file)
     return buf;
 }
 
-
-static void read_conf(FILE *conffile)
-{
+static void read_conf(FILE *conffile) {
     char *buffer, *line, *val;
 
     buffer = loadfile(conffile);
@@ -124,9 +118,7 @@ static void read_conf(FILE *conffile)
     free(buffer);
 }
 
-
-static int cmpfile(const char *str, const char *path, const char *fname)
-{
+static int cmpfile(const char *str, const char *path, const char *fname) {
     char filename[1024], *buffer;
     int ret;
     FILE *file;
@@ -156,8 +148,7 @@ static int cmpfile(const char *str, const char *path, const char *fname)
     return ret;
 }
 
-int use_conf(char *test_path)
-{
+int use_conf(char *test_path) {
     int ret;
     size_t flags = 0;
     char filename[1024], errstr[1024];
@@ -200,8 +191,7 @@ int use_conf(char *test_path)
         flags |= JSON_SORT_KEYS;
 
     if (conf.precision < 0 || conf.precision > 31) {
-        fprintf(stderr, "invalid value for JSON_REAL_PRECISION: %d\n",
-                conf.precision);
+        fprintf(stderr, "invalid value for JSON_REAL_PRECISION: %d\n", conf.precision);
         fclose(infile);
         return 2;
     }
@@ -216,15 +206,13 @@ int use_conf(char *test_path)
         buffer = loadfile(infile);
         json = json_loads(strip(buffer), 0, &error);
         free(buffer);
-    }
-    else
+    } else
         json = json_loadf(infile, 0, &error);
 
     fclose(infile);
 
     if (!json) {
-        sprintf(errstr, "%d %d %d\n%s\n",
-                error.line, error.column, error.position,
+        sprintf(errstr, "%d %d %d\n%s\n", error.line, error.column, error.position,
                 error.text);
 
         ret = cmpfile(errstr, test_path, "error");
@@ -239,80 +227,77 @@ int use_conf(char *test_path)
     return ret;
 }
 
-static int getenv_int(const char *name)
-{
+static int getenv_int(const char *name) {
     char *value, *end;
     long result;
 
     value = getenv(name);
-    if(!value)
+    if (!value)
         return 0;
 
     result = strtol(value, &end, 10);
-    if(*end != '\0')
+    if (*end != '\0')
         return 0;
 
     return (int)result;
 }
 
-int use_env()
-{
+int use_env() {
     int indent, precision;
     size_t flags = 0;
     json_t *json;
     json_error_t error;
 
-    #ifdef _WIN32
+#ifdef _WIN32
     /* On Windows, set stdout and stderr to binary mode to avoid
        outputting DOS line terminators */
     _setmode(_fileno(stdout), _O_BINARY);
     _setmode(_fileno(stderr), _O_BINARY);
-    #endif
+#endif
 
     indent = getenv_int("JSON_INDENT");
-    if(indent < 0 || indent > 31) {
+    if (indent < 0 || indent > 31) {
         fprintf(stderr, "invalid value for JSON_INDENT: %d\n", indent);
         return 2;
     }
-    if(indent > 0)
+    if (indent > 0)
         flags |= JSON_INDENT(indent);
 
-    if(getenv_int("JSON_COMPACT") > 0)
+    if (getenv_int("JSON_COMPACT") > 0)
         flags |= JSON_COMPACT;
 
-    if(getenv_int("JSON_ENSURE_ASCII"))
+    if (getenv_int("JSON_ENSURE_ASCII"))
         flags |= JSON_ENSURE_ASCII;
 
-    if(getenv_int("JSON_PRESERVE_ORDER"))
+    if (getenv_int("JSON_PRESERVE_ORDER"))
         flags |= JSON_PRESERVE_ORDER;
 
-    if(getenv_int("JSON_SORT_KEYS"))
+    if (getenv_int("JSON_SORT_KEYS"))
         flags |= JSON_SORT_KEYS;
 
     precision = getenv_int("JSON_REAL_PRECISION");
-    if(precision < 0 || precision > 31) {
-        fprintf(stderr, "invalid value for JSON_REAL_PRECISION: %d\n",
-                precision);
+    if (precision < 0 || precision > 31) {
+        fprintf(stderr, "invalid value for JSON_REAL_PRECISION: %d\n", precision);
         return 2;
     }
 
-    if(getenv("HASHSEED"))
+    if (getenv("HASHSEED"))
         json_object_seed(getenv_int("HASHSEED"));
 
-    if(precision > 0)
+    if (precision > 0)
         flags |= JSON_REAL_PRECISION(precision);
 
-    if(getenv_int("STRIP")) {
+    if (getenv_int("STRIP")) {
         /* Load to memory, strip leading and trailing whitespace */
         size_t size = 0, used = 0;
         char *buffer = NULL, *buf_ck = NULL;
 
-        while(1) {
+        while (1) {
             size_t count;
 
             size = (size == 0 ? 128 : size * 2);
             buf_ck = realloc(buffer, size);
-            if(!buf_ck) {
+            if (!buf_ck) {
                 fprintf(stderr, "Unable to allocate %d bytes\n", (int)size);
                 free(buffer);
                 return 1;
@@ -320,7 +305,7 @@ int use_env()
             buffer = buf_ck;
 
             count = fread(buffer + used, 1, size - used, stdin);
-            if(count < size - used) {
+            if (count < size - used) {
                 buffer[used + count] = '\0';
                 break;
             }
@@ -329,14 +314,12 @@ int use_env()
 
         json = json_loads(strip(buffer), 0, &error);
         free(buffer);
-    }
-    else
+    } else
         json = json_loadf(stdin, 0, &error);
 
-    if(!json) {
-        fprintf(stderr, "%d %d %d\n%s\n",
-            error.line, error.column,
-            error.position, error.text);
+    if (!json) {
+        fprintf(stderr, "%d %d %d\n%s\n", error.line, error.column, error.position,
+                error.text);
         return 1;
     }
 
@@ -346,14 +329,13 @@ int use_env()
     return 0;
 }
 
-int main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
     int i;
     char *test_path = NULL;
 
-    #ifdef HAVE_SETLOCALE
+#ifdef HAVE_SETLOCALE
     setlocale(LC_ALL, "");
-    #endif
+#endif
 
     if (argc < 2) {
         goto usage;
@@ -370,8 +352,7 @@ int main(int argc, char *argv[])
 
     if (conf.use_env)
         return use_env();
-    else
-    {
+    else {
         if (!test_path)
             goto usage;
 
diff --git a/test/suites/api/test_array.c b/test/suites/api/test_array.c
index a1a0934..e5d9d1a 100644
--- a/test/suites/api/test_array.c
+++ b/test/suites/api/test_array.c
@@ -5,11 +5,10 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
-#include <jansson.h>
 #include "util.h"
+#include <jansson.h>
 
-static void test_misc(void)
-{
+static void test_misc(void) {
     json_t *array, *five, *seven, *value;
     size_t i;
 
@@ -17,96 +16,96 @@ static void test_misc(void)
     five = json_integer(5);
     seven = json_integer(7);
 
-    if(!array)
+    if (!array)
         fail("unable to create array");
-    if(!five || !seven)
+    if (!five || !seven)
         fail("unable to create integer");
 
-    if(json_array_size(array) != 0)
+    if (json_array_size(array) != 0)
         fail("empty array has nonzero size");
 
-    if(!json_array_append(array, NULL))
+    if (!json_array_append(array, NULL))
         fail("able to append NULL");
 
-    if(json_array_append(array, five))
+    if (json_array_append(array, five))
         fail("unable to append");
 
-    if(json_array_size(array) != 1)
+    if (json_array_size(array) != 1)
         fail("wrong array size");
 
     value = json_array_get(array, 0);
-    if(!value)
+    if (!value)
         fail("unable to get item");
-    if(value != five)
+    if (value != five)
         fail("got wrong value");
 
-    if(json_array_append(array, seven))
+    if (json_array_append(array, seven))
         fail("unable to append value");
 
-    if(json_array_size(array) != 2)
+    if (json_array_size(array) != 2)
         fail("wrong array size");
 
     value = json_array_get(array, 1);
-    if(!value)
+    if (!value)
         fail("unable to get item");
-    if(value != seven)
+    if (value != seven)
         fail("got wrong value");
 
-    if(json_array_set(array, 0, seven))
+    if (json_array_set(array, 0, seven))
         fail("unable to set value");
 
-    if(!json_array_set(array, 0, NULL))
+    if (!json_array_set(array, 0, NULL))
         fail("able to set NULL");
 
-    if(json_array_size(array) != 2)
+    if (json_array_size(array) != 2)
         fail("wrong array size");
 
     value = json_array_get(array, 0);
-    if(!value)
+    if (!value)
         fail("unable to get item");
-    if(value != seven)
+    if (value != seven)
         fail("got wrong value");
 
-    if(json_array_get(array, 2) != NULL)
+    if (json_array_get(array, 2) != NULL)
         fail("able to get value out of bounds");
 
-    if(!json_array_set(array, 2, seven))
+    if (!json_array_set(array, 2, seven))
         fail("able to set value out of bounds");
 
-    for(i = 2; i < 30; i++) {
-        if(json_array_append(array, seven))
+    for (i = 2; i < 30; i++) {
+        if (json_array_append(array, seven))
             fail("unable to append value");
 
-        if(json_array_size(array) != i + 1)
+        if (json_array_size(array) != i + 1)
             fail("wrong array size");
     }
 
-    for(i = 0; i < 30; i++) {
+    for (i = 0; i < 30; i++) {
         value = json_array_get(array, i);
-        if(!value)
+        if (!value)
             fail("unable to get item");
-        if(value != seven)
+        if (value != seven)
             fail("got wrong value");
     }
 
-    if(json_array_set_new(array, 15, json_integer(123)))
+    if (json_array_set_new(array, 15, json_integer(123)))
         fail("unable to set new value");
 
     value = json_array_get(array, 15);
-    if(!json_is_integer(value) || json_integer_value(value) != 123)
+    if (!json_is_integer(value) || json_integer_value(value) != 123)
         fail("json_array_set_new works incorrectly");
 
-    if(!json_array_set_new(array, 15, NULL))
+    if (!json_array_set_new(array, 15, NULL))
         fail("able to set_new NULL value");
 
-    if(json_array_append_new(array, json_integer(321)))
+    if (json_array_append_new(array, json_integer(321)))
         fail("unable to append new value");
 
     value = json_array_get(array, json_array_size(array) - 1);
-    if(!json_is_integer(value) || json_integer_value(value) != 321)
+    if (!json_is_integer(value) || json_integer_value(value) != 321)
         fail("json_array_append_new works incorrectly");
 
-    if(!json_array_append_new(array, NULL))
+    if (!json_array_append_new(array, NULL))
         fail("able to append_new NULL value");
 
     json_decref(five);
@@ -114,8 +113,7 @@ static void test_misc(void)
     json_decref(array);
 }
 
-static void test_insert(void)
-{
+static void test_insert(void) {
     json_t *array, *five, *seven, *eleven, *value;
     int i;
 
@@ -124,77 +122,71 @@ static void test_insert(void)
     seven = json_integer(7);
     eleven = json_integer(11);
 
-    if(!array)
+    if (!array)
         fail("unable to create array");
-    if(!five || !seven || !eleven)
+    if (!five || !seven || !eleven)
         fail("unable to create integer");
 
-
-    if(!json_array_insert(array, 1, five))
+    if (!json_array_insert(array, 1, five))
         fail("able to insert value out of bounds");
 
-
-    if(json_array_insert(array, 0, five))
+    if (json_array_insert(array, 0, five))
         fail("unable to insert value in an empty array");
 
-    if(json_array_get(array, 0) != five)
+    if (json_array_get(array, 0) != five)
         fail("json_array_insert works incorrectly");
 
-    if(json_array_size(array) != 1)
+    if (json_array_size(array) != 1)
         fail("array size is invalid after insertion");
 
-
-    if(json_array_insert(array, 1, seven))
+    if (json_array_insert(array, 1, seven))
         fail("unable to insert value at the end of an array");
 
-    if(json_array_get(array, 0) != five)
+    if (json_array_get(array, 0) != five)
         fail("json_array_insert works incorrectly");
 
-    if(json_array_get(array, 1) != seven)
+    if (json_array_get(array, 1) != seven)
         fail("json_array_insert works incorrectly");
 
-    if(json_array_size(array) != 2)
+    if (json_array_size(array) != 2)
         fail("array size is invalid after insertion");
 
-
-    if(json_array_insert(array, 1, eleven))
+    if (json_array_insert(array, 1, eleven))
         fail("unable to insert value in the middle of an array");
 
-    if(json_array_get(array, 0) != five)
+    if (json_array_get(array, 0) != five)
         fail("json_array_insert works incorrectly");
 
-    if(json_array_get(array, 1) != eleven)
+    if (json_array_get(array, 1) != eleven)
         fail("json_array_insert works incorrectly");
 
-    if(json_array_get(array, 2) != seven)
+    if (json_array_get(array, 2) != seven)
         fail("json_array_insert works incorrectly");
 
-    if(json_array_size(array) != 3)
+    if (json_array_size(array) != 3)
         fail("array size is invalid after insertion");
 
-
-    if(json_array_insert_new(array, 2, json_integer(123)))
+    if (json_array_insert_new(array, 2, json_integer(123)))
         fail("unable to insert value in the middle of an array");
 
     value = json_array_get(array, 2);
-    if(!json_is_integer(value) || json_integer_value(value) != 123)
+    if (!json_is_integer(value) || json_integer_value(value) != 123)
         fail("json_array_insert_new works incorrectly");
 
-    if(json_array_size(array) != 4)
+    if (json_array_size(array) != 4)
         fail("array size is invalid after insertion");
 
-
-    for(i = 0; i < 20; i++) {
-        if(json_array_insert(array, 0, seven))
+    for (i = 0; i < 20; i++) {
+        if (json_array_insert(array, 0, seven))
             fail("unable to insert value at the beginning of an array");
     }
 
-    for(i = 0; i < 20; i++) {
-        if(json_array_get(array, i) != seven)
+    for (i = 0; i < 20; i++) {
+        if (json_array_get(array, i) != seven)
             fail("json_aray_insert works incorrectly");
     }
 
-    if(json_array_size(array) != 24)
+    if (json_array_size(array) != 24)
         fail("array size is invalid after loop insertion");
 
     json_decref(five);
@@ -203,8 +195,7 @@ static void test_insert(void)
     json_decref(array);
 }
 
-static void test_remove(void)
-{
+static void test_remove(void) {
     json_t *array, *five, *seven;
     int i;
 
@@ -212,56 +203,50 @@ static void test_remove(void)
     five = json_integer(5);
     seven = json_integer(7);
 
-    if(!array)
+    if (!array)
         fail("unable to create array");
-    if(!five)
+    if (!five)
         fail("unable to create integer");
-    if(!seven)
+    if (!seven)
         fail("unable to create integer");
 
-
-    if(!json_array_remove(array, 0))
+    if (!json_array_remove(array, 0))
         fail("able to remove an unexisting index");
 
-
-    if(json_array_append(array, five))
+    if (json_array_append(array, five))
         fail("unable to append");
 
-    if(!json_array_remove(array, 1))
+    if (!json_array_remove(array, 1))
         fail("able to remove an unexisting index");
 
-    if(json_array_remove(array, 0))
+    if (json_array_remove(array, 0))
         fail("unable to remove");
 
-    if(json_array_size(array) != 0)
+    if (json_array_size(array) != 0)
         fail("array size is invalid after removing");
 
-
-    if(json_array_append(array, five) ||
-       json_array_append(array, seven) ||
-       json_array_append(array, five) ||
-       json_array_append(array, seven))
+    if (json_array_append(array, five) || json_array_append(array, seven) ||
+        json_array_append(array, five) || json_array_append(array, seven))
         fail("unable to append");
 
-    if(json_array_remove(array, 2))
+    if (json_array_remove(array, 2))
         fail("unable to remove");
 
-    if(json_array_size(array) != 3)
+    if (json_array_size(array) != 3)
         fail("array size is invalid after removing");
 
-    if(json_array_get(array, 0) != five ||
-       json_array_get(array, 1) != seven ||
-       json_array_get(array, 2) != seven)
+    if (json_array_get(array, 0) != five || json_array_get(array, 1) != seven ||
+        json_array_get(array, 2) != seven)
         fail("remove works incorrectly");
 
     json_decref(array);
 
     array = json_array();
-    for(i = 0; i < 4; i++) {
+    for (i = 0; i < 4; i++) {
         json_array_append(array, five);
         json_array_append(array, seven);
     }
-    if(json_array_size(array) != 8)
+    if (json_array_size(array) != 8)
         fail("unable to append 8 items to array");
 
     /* Remove an element from a "full" array. */
@@ -272,8 +257,7 @@ static void test_remove(void)
     json_decref(array);
 }
 
-static void test_clear(void)
-{
+static void test_clear(void) {
     json_t *array, *five, *seven;
     int i;
 
@@ -281,27 +265,27 @@ static void test_clear(void)
     five = json_integer(5);
     seven = json_integer(7);
 
-    if(!array)
+    if (!array)
         fail("unable to create array");
-    if(!five || !seven)
+    if (!five || !seven)
         fail("unable to create integer");
 
-    for(i = 0; i < 10; i++) {
-        if(json_array_append(array, five))
+    for (i = 0; i < 10; i++) {
+        if (json_array_append(array, five))
             fail("unable to append");
     }
-    for(i = 0; i < 10; i++) {
-        if(json_array_append(array, seven))
+    for (i = 0; i < 10; i++) {
+        if (json_array_append(array, seven))
             fail("unable to append");
     }
 
-    if(json_array_size(array) != 20)
+    if (json_array_size(array) != 20)
         fail("array size is invalid after appending");
 
-    if(json_array_clear(array))
+    if (json_array_clear(array))
         fail("unable to clear");
 
-    if(json_array_size(array) != 0)
+    if (json_array_size(array) != 0)
         fail("array size is invalid after clearing");
 
     json_decref(five);
@@ -309,8 +293,7 @@ static void test_clear(void)
     json_decref(array);
 }
 
-static void test_extend(void)
-{
+static void test_extend(void) {
     json_t *array1, *array2, *five, *seven;
     int i;
 
@@ -319,32 +302,32 @@ static void test_extend(void)
     five = json_integer(5);
     seven = json_integer(7);
 
-    if(!array1 || !array2)
+    if (!array1 || !array2)
         fail("unable to create array");
-    if(!five || !seven)
+    if (!five || !seven)
         fail("unable to create integer");
 
-    for(i = 0; i < 10; i++) {
-        if(json_array_append(array1, five))
+    for (i = 0; i < 10; i++) {
+        if (json_array_append(array1, five))
             fail("unable to append");
     }
-    for(i = 0; i < 10; i++) {
-        if(json_array_append(array2, seven))
+    for (i = 0; i < 10; i++) {
+        if (json_array_append(array2, seven))
             fail("unable to append");
     }
 
-    if(json_array_size(array1) != 10 || json_array_size(array2) != 10)
+    if (json_array_size(array1) != 10 || json_array_size(array2) != 10)
         fail("array size is invalid after appending");
 
-    if(json_array_extend(array1, array2))
+    if (json_array_extend(array1, array2))
         fail("unable to extend");
 
-    for(i = 0; i < 10; i++) {
-        if(json_array_get(array1, i) != five)
+    for (i = 0; i < 10; i++) {
+        if (json_array_get(array1, i) != five)
             fail("invalid array contents after extending");
     }
-    for(i = 10; i < 20; i++) {
-        if(json_array_get(array1, i) != seven)
+    for (i = 10; i < 20; i++) {
+        if (json_array_get(array1, i) != seven)
             fail("invalid array contents after extending");
     }
 
@@ -354,44 +337,41 @@ static void test_extend(void)
     json_decref(array2);
 }
 
-static void test_circular()
-{
+static void test_circular() {
     json_t *array1, *array2;
 
     /* the simple cases are checked */
 
     array1 = json_array();
-    if(!array1)
+    if (!array1)
         fail("unable to create array");
 
-    if(json_array_append(array1, array1) == 0)
+    if (json_array_append(array1, array1) == 0)
         fail("able to append self");
 
-    if(json_array_insert(array1, 0, array1) == 0)
+    if (json_array_insert(array1, 0, array1) == 0)
         fail("able to insert self");
 
-    if(json_array_append_new(array1, json_true()))
+    if (json_array_append_new(array1, json_true()))
         fail("failed to append true");
 
-    if(json_array_set(array1, 0, array1) == 0)
+    if (json_array_set(array1, 0, array1) == 0)
         fail("able to set self");
 
     json_decref(array1);
 
-
     /* create circular references */
 
     array1 = json_array();
     array2 = json_array();
-    if(!array1 || !array2)
+    if (!array1 || !array2)
         fail("unable to create array");
 
-    if(json_array_append(array1, array2) ||
-       json_array_append(array2, array1))
+    if (json_array_append(array1, array2) || json_array_append(array2, array1))
         fail("unable to append");
 
     /* circularity is detected when dumping */
-    if(json_dumps(array1, 0) != NULL)
+    if (json_dumps(array1, 0) != NULL)
         fail("able to dump circulars");
 
     /* decref twice to deal with the circular references */
@@ -400,100 +380,99 @@ static void test_circular()
     json_decref(array1);
 }
 
-static void test_array_foreach()
-{
+static void test_array_foreach() {
     size_t index;
     json_t *array1, *array2, *value;
 
     array1 = json_pack("[sisisi]", "foo", 1, "bar", 2, "baz", 3);
     array2 = json_array();
 
-    json_array_foreach(array1, index, value) {
-        json_array_append(array2, value);
-    }
-    
-    if(!json_equal(array1, array2))
+    json_array_foreach(array1, index, value) { json_array_append(array2, value); }
+
+    if (!json_equal(array1, array2))
         fail("json_array_foreach failed to iterate all elements");
 
     json_decref(array1);
     json_decref(array2);
 }
 
-static void test_bad_args(void)
-{
+static void test_bad_args(void) {
     json_t *arr = json_array();
     json_t *num = json_integer(1);
 
-    if(!arr || !num)
+    if (!arr || !num)
         fail("failed to create required objects");
 
-    if(json_array_size(NULL) != 0)
+    if (json_array_size(NULL) != 0)
         fail("NULL array has nonzero size");
-    if(json_array_size(num) != 0)
+    if (json_array_size(num) != 0)
         fail("non-array has nonzero array size");
 
-    if(json_array_get(NULL, 0))
+    if (json_array_get(NULL, 0))
         fail("json_array_get did not return NULL for non-array");
-    if(json_array_get(num, 0))
+    if (json_array_get(num, 0))
         fail("json_array_get did not return NULL for non-array");
 
-    if(!json_array_set_new(NULL, 0, json_incref(num)))
+    if (!json_array_set_new(NULL, 0, json_incref(num)))
         fail("json_array_set_new did not return error for non-array");
-    if(!json_array_set_new(num, 0, json_incref(num)))
+    if (!json_array_set_new(num, 0, json_incref(num)))
         fail("json_array_set_new did not return error for non-array");
-    if(!json_array_set_new(arr, 0, NULL))
+    if (!json_array_set_new(arr, 0, NULL))
         fail("json_array_set_new did not return error for NULL value");
-    if(!json_array_set_new(arr, 0, json_incref(arr)))
+    if (!json_array_set_new(arr, 0, json_incref(arr)))
         fail("json_array_set_new did not return error for value == array");
 
-    if(!json_array_remove(NULL, 0))
+    if (!json_array_remove(NULL, 0))
         fail("json_array_remove did not return error for non-array");
-    if(!json_array_remove(num, 0))
+    if (!json_array_remove(num, 0))
         fail("json_array_remove did not return error for non-array");
 
-    if(!json_array_clear(NULL))
+    if (!json_array_clear(NULL))
         fail("json_array_clear did not return error for non-array");
-    if(!json_array_clear(num))
+    if (!json_array_clear(num))
         fail("json_array_clear did not return error for non-array");
 
-    if(!json_array_append_new(NULL, json_incref(num)))
+    if (!json_array_append_new(NULL, json_incref(num)))
         fail("json_array_append_new did not return error for non-array");
-    if(!json_array_append_new(num, json_incref(num)))
+    if (!json_array_append_new(num, json_incref(num)))
         fail("json_array_append_new did not return error for non-array");
-    if(!json_array_append_new(arr, NULL))
+    if (!json_array_append_new(arr, NULL))
         fail("json_array_append_new did not return error for NULL value");
-    if(!json_array_append_new(arr, json_incref(arr)))
+    if (!json_array_append_new(arr, json_incref(arr)))
         fail("json_array_append_new did not return error for value == array");
 
-    if(!json_array_insert_new(NULL, 0, json_incref(num)))
+    if (!json_array_insert_new(NULL, 0, json_incref(num)))
         fail("json_array_insert_new did not return error for non-array");
-    if(!json_array_insert_new(num, 0, json_incref(num)))
+    if (!json_array_insert_new(num, 0, json_incref(num)))
         fail("json_array_insert_new did not return error for non-array");
-    if(!json_array_insert_new(arr, 0, NULL))
+    if (!json_array_insert_new(arr, 0, NULL))
         fail("json_array_insert_new did not return error for NULL value");
-    if(!json_array_insert_new(arr, 0, json_incref(arr)))
+    if (!json_array_insert_new(arr, 0, json_incref(arr)))
         fail("json_array_insert_new did not return error for value == array");
 
-    if(!json_array_extend(NULL, arr))
-        fail("json_array_extend did not return error for first argument non-array");
-    if(!json_array_extend(num, arr))
-        fail("json_array_extend did not return error for first argument non-array");
-    if(!json_array_extend(arr, NULL))
-        fail("json_array_extend did not return error for second argument non-array");
-    if(!json_array_extend(arr, num))
-        fail("json_array_extend did not return error for second argument non-array");
-
-    if(num->refcount != 1)
+    if (!json_array_extend(NULL, arr))
+        fail("json_array_extend did not return error for first argument "
+             "non-array");
+    if (!json_array_extend(num, arr))
+        fail("json_array_extend did not return error for first argument "
+             "non-array");
+    if (!json_array_extend(arr, NULL))
+        fail("json_array_extend did not return error for second argument "
+             "non-array");
+    if (!json_array_extend(arr, num))
+        fail("json_array_extend did not return error for second argument "
+             "non-array");
+
+    if (num->refcount != 1)
         fail("unexpected reference count on num");
-    if(arr->refcount != 1)
+    if (arr->refcount != 1)
         fail("unexpected reference count on arr");
 
     json_decref(num);
     json_decref(arr);
 }
 
-static void run_tests()
-{
+static void run_tests() {
     test_misc();
     test_insert();
     test_remove();
diff --git a/test/suites/api/test_chaos.c b/test/suites/api/test_chaos.c
index 82776a6..8687243 100644
--- a/test/suites/api/test_chaos.c
+++ b/test/suites/api/test_chaos.c
@@ -2,17 +2,16 @@
 #define _GNU_SOURCE
 #endif
 
+#include "util.h"
+#include <jansson.h>
 #include <stdio.h>
 #include <string.h>
-#include <jansson.h>
-#include "util.h"
 
 static int chaos_pos = 0;
 static int chaos_fail = 0;
 #define CHAOS_MAX_FAILURE 100
 
-void *chaos_malloc(size_t size)
-{
+void *chaos_malloc(size_t size) {
     if (chaos_pos == chaos_fail)
         return NULL;
 
@@ -21,30 +20,25 @@ void *chaos_malloc(size_t size)
     return malloc(size);
 }
 
-void chaos_free(void *obj)
-{
-    free(obj);
-}
+void chaos_free(void *obj) { free(obj); }
 
 /* Test all potential allocation failures. */
-#define chaos_loop(condition, code, cleanup) \
-    { \
-        chaos_pos = chaos_fail = 0; \
-        while (condition) { \
-            if (chaos_fail > CHAOS_MAX_FAILURE) \
-                fail("too many chaos failures"); \
-            code \
-            chaos_pos = 0; \
-            chaos_fail++; \
-        } \
-        cleanup \
+#define chaos_loop(condition, code, cleanup)                                             \
+    {                                                                                    \
+        chaos_pos = chaos_fail = 0;                                                      \
+        while (condition) {                                                              \
+            if (chaos_fail > CHAOS_MAX_FAILURE)                                          \
+                fail("too many chaos failures");                                         \
+            code chaos_pos = 0;                                                          \
+            chaos_fail++;                                                                \
+        }                                                                                \
+        cleanup                                                                          \
     }
 
-#define chaos_loop_new_value(json, initcall) \
+#define chaos_loop_new_value(json, initcall)                                             \
     chaos_loop(!json, json = initcall;, json_decref(json); json = NULL;)
 
-int test_unpack()
-{
+int test_unpack() {
     int ret = -1;
     int v1;
     int v2;
@@ -74,8 +68,7 @@ out:
     return ret;
 }
 
-int dump_chaos_callback(const char *buffer, size_t size, void *data)
-{
+int dump_chaos_callback(const char *buffer, size_t size, void *data) {
     json_t *obj = json_object();
 
     (void)buffer;
@@ -90,8 +83,7 @@ int dump_chaos_callback(const char *buffer, size_t size, void *data)
     return 0;
 }
 
-static void test_chaos()
-{
+static void test_chaos() {
     json_malloc_t orig_malloc;
     json_free_t orig_free;
     json_t *json = NULL;
@@ -102,9 +94,7 @@ static void test_chaos()
     json_t *intnum = json_integer(1);
     json_t *dblnum = json_real(0.5);
     char *dumptxt = NULL;
-    json_t *dumpobj = json_pack("{s:[iiis], s:s}",
-        "key1", 1, 2, 3, "txt",
-        "key2", "v2");
+    json_t *dumpobj = json_pack("{s:[iiis], s:s}", "key1", 1, 2, 3, "txt", "key2", "v2");
     int keyno;
 
     if (!obj || !arr1 || !arr2 || !txt || !intnum || !dblnum || !dumpobj)
@@ -119,16 +109,20 @@ static void test_chaos()
     chaos_loop_new_value(json, json_pack("[s*,s*]", "v1", "v2"));
     chaos_loop_new_value(json, json_pack("o", json_incref(txt)));
     chaos_loop_new_value(json, json_pack("O", txt));
-    chaos_loop_new_value(json, json_pack("s++", "a",
-        "long string to force realloc",
-        "another long string to force yet another reallocation of the string because "
-        "that's what we are testing."));
+    chaos_loop_new_value(json, json_pack("s++", "a", "long string to force realloc",
+                                         "another long string to force yet another "
+                                         "reallocation of the string because "
+                                         "that's what we are testing."));
 
-    chaos_loop(test_unpack(),,);
+    chaos_loop(test_unpack(), , );
 
-    chaos_loop(json_dump_callback(dumpobj, dump_chaos_callback, NULL, JSON_INDENT(1)),,);
-    chaos_loop(json_dump_callback(dumpobj, dump_chaos_callback, NULL, JSON_INDENT(1) | JSON_SORT_KEYS),,);
-    chaos_loop(!dumptxt, dumptxt = json_dumps(dumpobj, JSON_COMPACT);, free(dumptxt); dumptxt = NULL;);
+    chaos_loop(json_dump_callback(dumpobj, dump_chaos_callback, NULL, JSON_INDENT(1)),
+               , );
+    chaos_loop(json_dump_callback(dumpobj, dump_chaos_callback, NULL,
+                                  JSON_INDENT(1) | JSON_SORT_KEYS),
+               , );
+    chaos_loop(!dumptxt, dumptxt = json_dumps(dumpobj, JSON_COMPACT);, free(dumptxt);
+               dumptxt = NULL;);
 
     chaos_loop_new_value(json, json_copy(obj));
     chaos_loop_new_value(json, json_deep_copy(obj));
@@ -152,14 +146,14 @@ static void test_chaos()
         char testkey[10];
 
         snprintf(testkey, sizeof(testkey), "test%d", keyno);
-        chaos_loop(json_object_set_new_nocheck(obj, testkey, json_object()),,);
+        chaos_loop(json_object_set_new_nocheck(obj, testkey, json_object()), , );
 #endif
-        chaos_loop(json_array_append_new(arr1, json_null()),,);
-        chaos_loop(json_array_insert_new(arr2, 0, json_null()),,);
+        chaos_loop(json_array_append_new(arr1, json_null()), , );
+        chaos_loop(json_array_insert_new(arr2, 0, json_null()), , );
     }
 
-    chaos_loop(json_array_extend(arr1, arr2),,);
-    chaos_loop(json_string_set_nocheck(txt, "test"),,);
+    chaos_loop(json_array_extend(arr1, arr2), , );
+    chaos_loop(json_string_set_nocheck(txt, "test"), , );
 
     json_set_alloc_funcs(orig_malloc, orig_free);
     json_decref(obj);
@@ -171,7 +165,4 @@ static void test_chaos()
     json_decref(dumpobj);
 }
 
-static void run_tests()
-{
-    test_chaos();
-}
+static void run_tests() { test_chaos(); }
diff --git a/test/suites/api/test_copy.c b/test/suites/api/test_copy.c
index ef7ab36..656d98d 100644
--- a/test/suites/api/test_copy.c
+++ b/test/suites/api/test_copy.c
@@ -5,21 +5,20 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
-#include <string.h>
-#include <jansson.h>
 #include "util.h"
+#include <jansson.h>
+#include <string.h>
 
-static void test_copy_simple(void)
-{
+static void test_copy_simple(void) {
     json_t *value, *copy;
 
-    if(json_copy(NULL))
+    if (json_copy(NULL))
         fail("copying NULL doesn't return NULL");
 
     /* true */
     value = json_true();
     copy = json_copy(value);
-    if(value != copy)
+    if (value != copy)
         fail("copying true failed");
     json_decref(value);
     json_decref(copy);
@@ -27,7 +26,7 @@ static void test_copy_simple(void)
     /* false */
     value = json_false();
     copy = json_copy(value);
-    if(value != copy)
+    if (value != copy)
         fail("copying false failed");
     json_decref(value);
     json_decref(copy);
@@ -35,71 +34,70 @@ static void test_copy_simple(void)
     /* null */
     value = json_null();
     copy = json_copy(value);
-    if(value != copy)
+    if (value != copy)
         fail("copying null failed");
     json_decref(value);
     json_decref(copy);
 
     /* string */
     value = json_string("foo");
-    if(!value)
+    if (!value)
         fail("unable to create a string");
     copy = json_copy(value);
-    if(!copy)
+    if (!copy)
         fail("unable to copy a string");
-    if(copy == value)
+    if (copy == value)
         fail("copying a string doesn't copy");
-    if(!json_equal(copy, value))
+    if (!json_equal(copy, value))
         fail("copying a string produces an inequal copy");
-    if(value->refcount != 1 || copy->refcount != 1)
+    if (value->refcount != 1 || copy->refcount != 1)
         fail("invalid refcounts");
     json_decref(value);
     json_decref(copy);
 
     /* integer */
     value = json_integer(543);
-    if(!value)
+    if (!value)
         fail("unable to create an integer");
     copy = json_copy(value);
-    if(!copy)
+    if (!copy)
         fail("unable to copy an integer");
-    if(copy == value)
+    if (copy == value)
         fail("copying an integer doesn't copy");
-    if(!json_equal(copy, value))
+    if (!json_equal(copy, value))
         fail("copying an integer produces an inequal copy");
-    if(value->refcount != 1 || copy->refcount != 1)
+    if (value->refcount != 1 || copy->refcount != 1)
         fail("invalid refcounts");
     json_decref(value);
     json_decref(copy);
 
     /* real */
     value = json_real(123e9);
-    if(!value)
+    if (!value)
         fail("unable to create a real");
     copy = json_copy(value);
-    if(!copy)
+    if (!copy)
         fail("unable to copy a real");
-    if(copy == value)
+    if (copy == value)
         fail("copying a real doesn't copy");
-    if(!json_equal(copy, value))
+    if (!json_equal(copy, value))
         fail("copying a real produces an inequal copy");
-    if(value->refcount != 1 || copy->refcount != 1)
+    if (value->refcount != 1 || copy->refcount != 1)
         fail("invalid refcounts");
     json_decref(value);
     json_decref(copy);
 }
 
-static void test_deep_copy_simple(void)
-{
+static void test_deep_copy_simple(void) {
     json_t *value, *copy;
 
-    if(json_deep_copy(NULL))
+    if (json_deep_copy(NULL))
         fail("deep copying NULL doesn't return NULL");
 
     /* true */
     value = json_true();
     copy = json_deep_copy(value);
-    if(value != copy)
+    if (value != copy)
         fail("deep copying true failed");
     json_decref(value);
     json_decref(copy);
@@ -107,7 +105,7 @@ static void test_deep_copy_simple(void)
     /* false */
     value = json_false();
     copy = json_deep_copy(value);
-    if(value != copy)
+    if (value != copy)
         fail("deep copying false failed");
     json_decref(value);
     json_decref(copy);
@@ -115,82 +113,80 @@ static void test_deep_copy_simple(void)
     /* null */
     value = json_null();
     copy = json_deep_copy(value);
-    if(value != copy)
+    if (value != copy)
         fail("deep copying null failed");
     json_decref(value);
     json_decref(copy);
 
     /* string */
     value = json_string("foo");
-    if(!value)
+    if (!value)
         fail("unable to create a string");
     copy = json_deep_copy(value);
-    if(!copy)
+    if (!copy)
         fail("unable to deep copy a string");
-    if(copy == value)
+    if (copy == value)
         fail("deep copying a string doesn't copy");
-    if(!json_equal(copy, value))
+    if (!json_equal(copy, value))
         fail("deep copying a string produces an inequal copy");
-    if(value->refcount != 1 || copy->refcount != 1)
+    if (value->refcount != 1 || copy->refcount != 1)
         fail("invalid refcounts");
     json_decref(value);
     json_decref(copy);
 
     /* integer */
     value = json_integer(543);
-    if(!value)
+    if (!value)
         fail("unable to create an integer");
     copy = json_deep_copy(value);
-    if(!copy)
+    if (!copy)
         fail("unable to deep copy an integer");
-    if(copy == value)
+    if (copy == value)
         fail("deep copying an integer doesn't copy");
-    if(!json_equal(copy, value))
+    if (!json_equal(copy, value))
         fail("deep copying an integer produces an inequal copy");
-    if(value->refcount != 1 || copy->refcount != 1)
+    if (value->refcount != 1 || copy->refcount != 1)
         fail("invalid refcounts");
     json_decref(value);
     json_decref(copy);
 
     /* real */
     value = json_real(123e9);
-    if(!value)
+    if (!value)
         fail("unable to create a real");
     copy = json_deep_copy(value);
-    if(!copy)
+    if (!copy)
         fail("unable to deep copy a real");
-    if(copy == value)
+    if (copy == value)
         fail("deep copying a real doesn't copy");
-    if(!json_equal(copy, value))
+    if (!json_equal(copy, value))
         fail("deep copying a real produces an inequal copy");
-    if(value->refcount != 1 || copy->refcount != 1)
+    if (value->refcount != 1 || copy->refcount != 1)
         fail("invalid refcounts");
     json_decref(value);
     json_decref(copy);
 }
 
-static void test_copy_array(void)
-{
+static void test_copy_array(void) {
     const char *json_array_text = "[1, \"foo\", 3.141592, {\"foo\": \"bar\"}]";
 
     json_t *array, *copy;
     size_t i;
 
     array = json_loads(json_array_text, 0, NULL);
-    if(!array)
+    if (!array)
         fail("unable to parse an array");
 
     copy = json_copy(array);
-    if(!copy)
+    if (!copy)
         fail("unable to copy an array");
-    if(copy == array)
+    if (copy == array)
         fail("copying an array doesn't copy");
-    if(!json_equal(copy, array))
+    if (!json_equal(copy, array))
         fail("copying an array produces an inequal copy");
 
-    for(i = 0; i < json_array_size(copy); i++)
-    {
-        if(json_array_get(array, i) != json_array_get(copy, i))
+    for (i = 0; i < json_array_size(copy); i++) {
+        if (json_array_get(array, i) != json_array_get(copy, i))
             fail("copying an array modifies its elements");
     }
 
@@ -198,28 +194,26 @@ static void test_copy_array(void)
     json_decref(copy);
 }
 
-static void test_deep_copy_array(void)
-{
+static void test_deep_copy_array(void) {
     const char *json_array_text = "[1, \"foo\", 3.141592, {\"foo\": \"bar\"}]";
 
     json_t *array, *copy;
     size_t i;
 
     array = json_loads(json_array_text, 0, NULL);
-    if(!array)
+    if (!array)
         fail("unable to parse an array");
 
     copy = json_deep_copy(array);
-    if(!copy)
+    if (!copy)
         fail("unable to deep copy an array");
-    if(copy == array)
+    if (copy == array)
         fail("deep copying an array doesn't copy");
-    if(!json_equal(copy, array))
+    if (!json_equal(copy, array))
         fail("deep copying an array produces an inequal copy");
 
-    for(i = 0; i < json_array_size(copy); i++)
-    {
-        if(json_array_get(array, i) == json_array_get(copy, i))
+    for (i = 0; i < json_array_size(copy); i++) {
+        if (json_array_get(array, i) == json_array_get(copy, i))
             fail("deep copying an array doesn't copy its elements");
     }
 
@@ -227,8 +221,7 @@ static void test_deep_copy_array(void)
     json_decref(copy);
 }
 
-static void test_copy_object(void)
-{
+static void test_copy_object(void) {
     const char *json_object_text =
         "{\"foo\": \"bar\", \"a\": 1, \"b\": 3.141592, \"c\": [1,2,3,4]}";
 
@@ -239,21 +232,20 @@ static void test_copy_object(void)
     void *iter;
 
     object = json_loads(json_object_text, 0, NULL);
-    if(!object)
+    if (!object)
         fail("unable to parse an object");
 
     copy = json_copy(object);
-    if(!copy)
+    if (!copy)
         fail("unable to copy an object");
-    if(copy == object)
+    if (copy == object)
         fail("copying an object doesn't copy");
-    if(!json_equal(copy, object))
+    if (!json_equal(copy, object))
         fail("copying an object produces an inequal copy");
 
     i = 0;
     iter = json_object_iter(object);
-    while(iter)
-    {
+    while (iter) {
         const char *key;
         json_t *value1, *value2;
 
@@ -261,7 +253,7 @@ static void test_copy_object(void)
         value1 = json_object_iter_value(iter);
         value2 = json_object_get(copy, key);
 
-        if(value1 != value2)
+        if (value1 != value2)
             fail("copying an object modifies its items");
 
         if (strcmp(key, keys[i]) != 0)
@@ -275,8 +267,7 @@ static void test_copy_object(void)
     json_decref(copy);
 }
 
-static void test_deep_copy_object(void)
-{
+static void test_deep_copy_object(void) {
     const char *json_object_text =
         "{\"foo\": \"bar\", \"a\": 1, \"b\": 3.141592, \"c\": [1,2,3,4]}";
 
@@ -287,21 +278,20 @@ static void test_deep_copy_object(void)
     void *iter;
 
     object = json_loads(json_object_text, 0, NULL);
-    if(!object)
+    if (!object)
         fail("unable to parse an object");
 
     copy = json_deep_copy(object);
-    if(!copy)
+    if (!copy)
         fail("unable to deep copy an object");
-    if(copy == object)
+    if (copy == object)
         fail("deep copying an object doesn't copy");
-    if(!json_equal(copy, object))
+    if (!json_equal(copy, object))
         fail("deep copying an object produces an inequal copy");
 
     i = 0;
     iter = json_object_iter(object);
-    while(iter)
-    {
+    while (iter) {
         const char *key;
         json_t *value1, *value2;
 
@@ -309,7 +299,7 @@ static void test_deep_copy_object(void)
         value1 = json_object_iter_value(iter);
         value2 = json_object_get(copy, key);
 
-        if(value1 == value2)
+        if (value1 == value2)
             fail("deep copying an object doesn't copy its items");
 
         if (strcmp(key, keys[i]) != 0)
@@ -323,15 +313,14 @@ static void test_deep_copy_object(void)
     json_decref(copy);
 }
 
-static void test_deep_copy_circular_references(void)
-{
-     /* Construct a JSON object/array with a circular reference:
+static void test_deep_copy_circular_references(void) {
+    /* Construct a JSON object/array with a circular reference:
 
-       object: {"a": {"b": {"c": <circular reference to $.a>}}}
-       array: [[[<circular reference to the $[0] array>]]]
+      object: {"a": {"b": {"c": <circular reference to $.a>}}}
+      array: [[[<circular reference to the $[0] array>]]]
 
-       Deep copy it, remove the circular reference and deep copy again.
-    */
+      Deep copy it, remove the circular reference and deep copy again.
+   */
 
     json_t *json;
     json_t *copy;
@@ -343,13 +332,13 @@ static void test_deep_copy_circular_references(void)
                     json_object_get(json, "a"));
 
     copy = json_deep_copy(json);
-    if(copy)
+    if (copy)
         fail("json_deep_copy copied a circular reference!");
 
     json_object_del(json_object_get(json_object_get(json, "a"), "b"), "c");
 
     copy = json_deep_copy(json);
-    if(!copy)
+    if (!copy)
         fail("json_deep_copy failed!");
 
     json_decref(copy);
@@ -362,21 +351,20 @@ static void test_deep_copy_circular_references(void)
                       json_array_get(json, 0));
 
     copy = json_deep_copy(json);
-    if(copy)
+    if (copy)
         fail("json_deep_copy copied a circular reference!");
 
     json_array_remove(json_array_get(json_array_get(json, 0), 0), 0);
 
     copy = json_deep_copy(json);
-    if(!copy)
+    if (!copy)
         fail("json_deep_copy failed!");
 
     json_decref(copy);
     json_decref(json);
 }
 
-static void run_tests()
-{
+static void run_tests() {
     test_copy_simple();
     test_deep_copy_simple();
     test_copy_array();
diff --git a/test/suites/api/test_dump.c b/test/suites/api/test_dump.c
index c97a105..e8cb519 100644
--- a/test/suites/api/test_dump.c
+++ b/test/suites/api/test_dump.c
@@ -18,39 +18,35 @@
 #define pipe(fds) _pipe(fds, 1024, _O_BINARY)
 #endif
 
-static int encode_null_callback(const char *buffer, size_t size, void *data)
-{
+static int encode_null_callback(const char *buffer, size_t size, void *data) {
     (void)buffer;
     (void)size;
     (void)data;
     return 0;
 }
 
-static void encode_null()
-{
-    if(json_dumps(NULL, JSON_ENCODE_ANY) != NULL)
+static void encode_null() {
+    if (json_dumps(NULL, JSON_ENCODE_ANY) != NULL)
         fail("json_dumps didn't fail for NULL");
 
-    if(json_dumpb(NULL, NULL, 0, JSON_ENCODE_ANY) != 0)
+    if (json_dumpb(NULL, NULL, 0, JSON_ENCODE_ANY) != 0)
         fail("json_dumpb didn't fail for NULL");
 
-    if(json_dumpf(NULL, stderr, JSON_ENCODE_ANY) != -1)
+    if (json_dumpf(NULL, stderr, JSON_ENCODE_ANY) != -1)
         fail("json_dumpf didn't fail for NULL");
 
 #ifdef HAVE_UNISTD_H
-    if(json_dumpfd(NULL, STDERR_FILENO, JSON_ENCODE_ANY) != -1)
+    if (json_dumpfd(NULL, STDERR_FILENO, JSON_ENCODE_ANY) != -1)
         fail("json_dumpfd didn't fail for NULL");
 #endif
 
     /* Don't test json_dump_file to avoid creating a file */
 
-    if(json_dump_callback(NULL, encode_null_callback, NULL, JSON_ENCODE_ANY) != -1)
+    if (json_dump_callback(NULL, encode_null_callback, NULL, JSON_ENCODE_ANY) != -1)
         fail("json_dump_callback didn't fail for NULL");
 }
 
-
-static void encode_twice()
-{
+static void encode_twice() {
     /* Encode an empty object/array, add an item, encode again */
 
     json_t *json;
@@ -58,35 +54,34 @@ static void encode_twice()
 
     json = json_object();
     result = json_dumps(json, 0);
-    if(!result || strcmp(result, "{}"))
-      fail("json_dumps failed");
+    if (!result || strcmp(result, "{}"))
+        fail("json_dumps failed");
     free(result);
 
     json_object_set_new(json, "foo", json_integer(5));
     result = json_dumps(json, 0);
-    if(!result || strcmp(result, "{\"foo\": 5}"))
-      fail("json_dumps failed");
+    if (!result || strcmp(result, "{\"foo\": 5}"))
+        fail("json_dumps failed");
     free(result);
 
     json_decref(json);
 
     json = json_array();
     result = json_dumps(json, 0);
-    if(!result || strcmp(result, "[]"))
-      fail("json_dumps failed");
+    if (!result || strcmp(result, "[]"))
+        fail("json_dumps failed");
     free(result);
 
     json_array_append_new(json, json_integer(5));
     result = json_dumps(json, 0);
-    if(!result || strcmp(result, "[5]"))
-      fail("json_dumps failed");
+    if (!result || strcmp(result, "[5]"))
+        fail("json_dumps failed");
     free(result);
 
     json_decref(json);
 }
 
-static void circular_references()
-{
+static void circular_references() {
     /* Construct a JSON object/array with a circular reference:
 
        object: {"a": {"b": {"c": <circular reference to $.a>}}}
@@ -104,13 +99,13 @@ static void circular_references()
     json_object_set(json_object_get(json_object_get(json, "a"), "b"), "c",
                     json_object_get(json, "a"));
 
-    if(json_dumps(json, 0))
+    if (json_dumps(json, 0))
         fail("json_dumps encoded a circular reference!");
 
     json_object_del(json_object_get(json_object_get(json, "a"), "b"), "c");
 
     result = json_dumps(json, 0);
-    if(!result || strcmp(result, "{\"a\": {\"b\": {}}}"))
+    if (!result || strcmp(result, "{\"a\": {\"b\": {}}}"))
         fail("json_dumps failed!");
     free(result);
 
@@ -122,21 +117,20 @@ static void circular_references()
     json_array_append(json_array_get(json_array_get(json, 0), 0),
                       json_array_get(json, 0));
 
-    if(json_dumps(json, 0))
+    if (json_dumps(json, 0))
         fail("json_dumps encoded a circular reference!");
 
     json_array_remove(json_array_get(json_array_get(json, 0), 0), 0);
 
     result = json_dumps(json, 0);
-    if(!result || strcmp(result, "[[[]]]"))
+    if (!result || strcmp(result, "[[[]]]"))
         fail("json_dumps failed!");
     free(result);
 
     json_decref(json);
 }
 
-static void encode_other_than_array_or_object()
-{
+static void encode_other_than_array_or_object() {
     /* Encoding anything other than array or object should only
      * succeed if the JSON_ENCODE_ANY flag is used */
 
@@ -144,40 +138,37 @@ static void encode_other_than_array_or_object()
     char *result;
 
     json = json_string("foo");
-    if(json_dumps(json, 0) != NULL)
+    if (json_dumps(json, 0) != NULL)
         fail("json_dumps encoded a string!");
-    if(json_dumpf(json, NULL, 0) == 0)
+    if (json_dumpf(json, NULL, 0) == 0)
         fail("json_dumpf encoded a string!");
-    if(json_dumpfd(json, -1, 0) == 0)
+    if (json_dumpfd(json, -1, 0) == 0)
         fail("json_dumpfd encoded a string!");
 
     result = json_dumps(json, JSON_ENCODE_ANY);
-    if(!result || strcmp(result, "\"foo\"") != 0)
+    if (!result || strcmp(result, "\"foo\"") != 0)
         fail("json_dumps failed to encode a string with JSON_ENCODE_ANY");
 
     free(result);
     json_decref(json);
 
     json = json_integer(42);
-    if(json_dumps(json, 0) != NULL)
+    if (json_dumps(json, 0) != NULL)
         fail("json_dumps encoded an integer!");
-    if(json_dumpf(json, NULL, 0) == 0)
+    if (json_dumpf(json, NULL, 0) == 0)
         fail("json_dumpf encoded an integer!");
-    if(json_dumpfd(json, -1, 0) == 0)
+    if (json_dumpfd(json, -1, 0) == 0)
         fail("json_dumpfd encoded an integer!");
 
     result = json_dumps(json, JSON_ENCODE_ANY);
-    if(!result || strcmp(result, "42") != 0)
+    if (!result || strcmp(result, "42") != 0)
         fail("json_dumps failed to encode an integer with JSON_ENCODE_ANY");
 
     free(result);
     json_decref(json);
-
-
 }
 
-static void escape_slashes()
-{
+static void escape_slashes() {
     /* Test dump escaping slashes */
 
     json_t *json;
@@ -187,35 +178,34 @@ static void escape_slashes()
     json_object_set_new(json, "url", json_string("https://github.com/akheron/jansson"));
 
     result = json_dumps(json, 0);
-    if(!result || strcmp(result, "{\"url\": \"https://github.com/akheron/jansson\"}"))
+    if (!result || strcmp(result, "{\"url\": \"https://github.com/akheron/jansson\"}"))
         fail("json_dumps failed to not escape slashes");
 
     free(result);
 
     result = json_dumps(json, JSON_ESCAPE_SLASH);
-    if(!result || strcmp(result, "{\"url\": \"https:\\/\\/github.com\\/akheron\\/jansson\"}"))
+    if (!result ||
+        strcmp(result, "{\"url\": \"https:\\/\\/github.com\\/akheron\\/jansson\"}"))
         fail("json_dumps failed to escape slashes");
 
     free(result);
     json_decref(json);
 }
 
-static void encode_nul_byte()
-{
+static void encode_nul_byte() {
     json_t *json;
     char *result;
 
     json = json_stringn("nul byte \0 in string", 20);
     result = json_dumps(json, JSON_ENCODE_ANY);
-    if(!result || memcmp(result, "\"nul byte \\u0000 in string\"", 27))
+    if (!result || memcmp(result, "\"nul byte \\u0000 in string\"", 27))
         fail("json_dumps failed to dump an embedded NUL byte");
 
     free(result);
     json_decref(json);
 }
 
-static void dump_file()
-{
+static void dump_file() {
     json_t *json;
     int result;
 
@@ -232,8 +222,7 @@ static void dump_file()
     remove("json_dump_file.json");
 }
 
-static void dumpb()
-{
+static void dumpb() {
     char buf[2];
     json_t *obj;
     size_t size;
@@ -241,31 +230,30 @@ static void dumpb()
     obj = json_object();
 
     size = json_dumpb(obj, buf, sizeof(buf), 0);
-    if(size != 2 || strncmp(buf, "{}", 2))
-      fail("json_dumpb failed");
+    if (size != 2 || strncmp(buf, "{}", 2))
+        fail("json_dumpb failed");
 
     json_decref(obj);
     obj = json_pack("{s:s}", "foo", "bar");
 
     size = json_dumpb(obj, buf, sizeof(buf), JSON_COMPACT);
-    if(size != 13)
-      fail("json_dumpb size check failed");
+    if (size != 13)
+        fail("json_dumpb size check failed");
 
     json_decref(obj);
 }
 
-static void dumpfd()
-{
+static void dumpfd() {
 #ifdef HAVE_UNISTD_H
     int fds[2] = {-1, -1};
     json_t *a, *b;
 
-    if(pipe(fds))
+    if (pipe(fds))
         fail("pipe() failed");
 
     a = json_pack("{s:s}", "foo", "bar");
 
-    if(json_dumpfd(a, fds[1], 0))
+    if (json_dumpfd(a, fds[1], 0))
         fail("json_dumpfd() failed");
     close(fds[1]);
 
@@ -282,19 +270,13 @@ static void dumpfd()
 #endif
 }
 
-static void embed()
-{
-    static const char *plains[] = {
-        "{\"bar\":[],\"foo\":{}}",
-        "[[],{}]",
-        "{}",
-        "[]",
-        NULL
-    };
+static void embed() {
+    static const char *plains[] = {"{\"bar\":[],\"foo\":{}}", "[[],{}]", "{}", "[]",
+                                   NULL};
 
     size_t i;
 
-    for(i = 0; plains[i]; i++) {
+    for (i = 0; plains[i]; i++) {
         const char *plain = plains[i];
         json_t *parse = NULL;
         char *embed = NULL;
@@ -304,19 +286,18 @@ static void embed()
         psize = strlen(plain) - 2;
         embed = calloc(1, psize);
         parse = json_loads(plain, 0, NULL);
-        esize = json_dumpb(parse, embed, psize,
-                           JSON_COMPACT | JSON_SORT_KEYS | JSON_EMBED);
+        esize =
+            json_dumpb(parse, embed, psize, JSON_COMPACT | JSON_SORT_KEYS | JSON_EMBED);
         json_decref(parse);
-        if(esize != psize)
+        if (esize != psize)
             fail("json_dumpb(JSON_EMBED) returned an invalid size");
-        if(strncmp(plain + 1, embed, esize) != 0)
+        if (strncmp(plain + 1, embed, esize) != 0)
             fail("json_dumps(JSON_EMBED) returned an invalid value");
         free(embed);
     }
 }
 
-static void run_tests()
-{
+static void run_tests() {
     encode_null();
     encode_twice();
     circular_references();
diff --git a/test/suites/api/test_dump_callback.c b/test/suites/api/test_dump_callback.c
index 1ceb968..80ea008 100644
--- a/test/suites/api/test_dump_callback.c
+++ b/test/suites/api/test_dump_callback.c
@@ -5,10 +5,10 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
+#include "util.h"
 #include <jansson.h>
-#include <string.h>
 #include <stdlib.h>
-#include "util.h"
+#include <string.h>
 
 struct my_sink {
     char *buf;
@@ -26,15 +26,14 @@ static int my_writer(const char *buffer, size_t len, void *data) {
     return 0;
 }
 
-static void run_tests()
-{
+static void run_tests() {
     struct my_sink s;
     json_t *json;
     const char str[] = "[\"A\", {\"B\": \"C\", \"e\": false}, 1, null, \"foo\"]";
     char *dumped_to_string;
 
     json = json_loads(str, 0, NULL);
-    if(!json) {
+    if (!json) {
         fail("json_loads failed");
     }
 
@@ -64,7 +63,8 @@ static void run_tests()
         json_decref(json);
         free(dumped_to_string);
         free(s.buf);
-        fail("json_dump_callback and json_dumps did not produce identical output");
+        fail("json_dump_callback and json_dumps did not produce identical "
+             "output");
     }
 
     s.off = 1;
@@ -72,7 +72,8 @@ static void run_tests()
         json_decref(json);
         free(dumped_to_string);
         free(s.buf);
-        fail("json_dump_callback succeeded on a short buffer when it should have failed");
+        fail("json_dump_callback succeeded on a short buffer when it should "
+             "have failed");
     }
 
     json_decref(json);
diff --git a/test/suites/api/test_equal.c b/test/suites/api/test_equal.c
index ed1023f..d068b7b 100644
--- a/test/suites/api/test_equal.c
+++ b/test/suites/api/test_equal.c
@@ -5,38 +5,37 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
-#include <jansson.h>
 #include "util.h"
+#include <jansson.h>
 
-static void test_equal_simple()
-{
+static void test_equal_simple() {
     json_t *value1, *value2;
 
-    if(json_equal(NULL, NULL))
+    if (json_equal(NULL, NULL))
         fail("json_equal fails for two NULLs");
 
     value1 = json_true();
-    if(json_equal(value1, NULL) || json_equal(NULL, value1))
+    if (json_equal(value1, NULL) || json_equal(NULL, value1))
         fail("json_equal fails for NULL");
 
     /* this covers true, false and null as they are singletons */
-    if(!json_equal(value1, value1))
+    if (!json_equal(value1, value1))
         fail("identical objects are not equal");
     json_decref(value1);
 
     /* integer */
     value1 = json_integer(1);
     value2 = json_integer(1);
-    if(!value1 || !value2)
+    if (!value1 || !value2)
         fail("unable to create integers");
-    if(!json_equal(value1, value2))
+    if (!json_equal(value1, value2))
         fail("json_equal fails for two equal integers");
     json_decref(value2);
 
     value2 = json_integer(2);
-    if(!value2)
+    if (!value2)
         fail("unable to create an integer");
-    if(json_equal(value1, value2))
+    if (json_equal(value1, value2))
         fail("json_equal fails for two inequal integers");
 
     json_decref(value1);
@@ -45,16 +44,16 @@ static void test_equal_simple()
     /* real */
     value1 = json_real(1.2);
     value2 = json_real(1.2);
-    if(!value1 || !value2)
+    if (!value1 || !value2)
         fail("unable to create reals");
-    if(!json_equal(value1, value2))
+    if (!json_equal(value1, value2))
         fail("json_equal fails for two equal reals");
     json_decref(value2);
 
     value2 = json_real(3.141592);
-    if(!value2)
+    if (!value2)
         fail("unable to create an real");
-    if(json_equal(value1, value2))
+    if (json_equal(value1, value2))
         fail("json_equal fails for two inequal reals");
 
     json_decref(value1);
@@ -63,39 +62,38 @@ static void test_equal_simple()
     /* string */
     value1 = json_string("foo");
     value2 = json_string("foo");
-    if(!value1 || !value2)
+    if (!value1 || !value2)
         fail("unable to create strings");
-    if(!json_equal(value1, value2))
+    if (!json_equal(value1, value2))
         fail("json_equal fails for two equal strings");
     json_decref(value2);
 
     value2 = json_string("bar");
-    if(!value2)
+    if (!value2)
         fail("unable to create an string");
-    if(json_equal(value1, value2))
+    if (json_equal(value1, value2))
         fail("json_equal fails for two inequal strings");
     json_decref(value2);
 
     value2 = json_string("bar2");
-    if(!value2)
+    if (!value2)
         fail("unable to create an string");
-    if(json_equal(value1, value2))
+    if (json_equal(value1, value2))
         fail("json_equal fails for two inequal length strings");
 
     json_decref(value1);
     json_decref(value2);
 }
 
-static void test_equal_array()
-{
+static void test_equal_array() {
     json_t *array1, *array2;
 
     array1 = json_array();
     array2 = json_array();
-    if(!array1 || !array2)
+    if (!array1 || !array2)
         fail("unable to create arrays");
 
-    if(!json_equal(array1, array2))
+    if (!json_equal(array1, array2))
         fail("json_equal fails for two empty arrays");
 
     json_array_append_new(array1, json_integer(1));
@@ -104,31 +102,30 @@ static void test_equal_array()
     json_array_append_new(array2, json_string("foo"));
     json_array_append_new(array1, json_integer(2));
     json_array_append_new(array2, json_integer(2));
-    if(!json_equal(array1, array2))
+    if (!json_equal(array1, array2))
         fail("json_equal fails for two equal arrays");
 
     json_array_remove(array2, 2);
-    if(json_equal(array1, array2))
+    if (json_equal(array1, array2))
         fail("json_equal fails for two inequal arrays");
 
     json_array_append_new(array2, json_integer(3));
-    if(json_equal(array1, array2))
+    if (json_equal(array1, array2))
         fail("json_equal fails for two inequal arrays");
 
     json_decref(array1);
     json_decref(array2);
 }
 
-static void test_equal_object()
-{
+static void test_equal_object() {
     json_t *object1, *object2;
 
     object1 = json_object();
     object2 = json_object();
-    if(!object1 || !object2)
+    if (!object1 || !object2)
         fail("unable to create objects");
 
-    if(!json_equal(object1, object2))
+    if (!json_equal(object1, object2))
         fail("json_equal fails for two empty objects");
 
     json_object_set_new(object1, "a", json_integer(1));
@@ -137,59 +134,59 @@ static void test_equal_object()
     json_object_set_new(object2, "b", json_string("foo"));
     json_object_set_new(object1, "c", json_integer(2));
     json_object_set_new(object2, "c", json_integer(2));
-    if(!json_equal(object1, object2))
+    if (!json_equal(object1, object2))
         fail("json_equal fails for two equal objects");
 
     json_object_del(object2, "c");
-    if(json_equal(object1, object2))
+    if (json_equal(object1, object2))
         fail("json_equal fails for two inequal objects");
 
     json_object_set_new(object2, "c", json_integer(3));
-    if(json_equal(object1, object2))
+    if (json_equal(object1, object2))
         fail("json_equal fails for two inequal objects");
 
     json_object_del(object2, "c");
     json_object_set_new(object2, "d", json_integer(2));
-    if(json_equal(object1, object2))
+    if (json_equal(object1, object2))
         fail("json_equal fails for two inequal objects");
 
     json_decref(object1);
     json_decref(object2);
 }
 
-static void test_equal_complex()
-{
+static void test_equal_complex() {
     json_t *value1, *value2, *value3;
 
-    const char *complex_json =
-"{"
-"    \"integer\": 1, "
-"    \"real\": 3.141592, "
-"    \"string\": \"foobar\", "
-"    \"true\": true, "
-"    \"object\": {"
-"        \"array-in-object\": [1,true,\"foo\",{}],"
-"        \"object-in-object\": {\"foo\": \"bar\"}"
-"    },"
-"    \"array\": [\"foo\", false, null, 1.234]"
-"}";
+    const char *complex_json = "{"
+                               "    \"integer\": 1, "
+                               "    \"real\": 3.141592, "
+                               "    \"string\": \"foobar\", "
+                               "    \"true\": true, "
+                               "    \"object\": {"
+                               "        \"array-in-object\": [1,true,\"foo\",{}],"
+                               "        \"object-in-object\": {\"foo\": \"bar\"}"
+                               "    },"
+                               "    \"array\": [\"foo\", false, null, 1.234]"
+                               "}";
 
     value1 = json_loads(complex_json, 0, NULL);
     value2 = json_loads(complex_json, 0, NULL);
     value3 = json_loads(complex_json, 0, NULL);
-    if(!value1 || !value2)
+    if (!value1 || !value2)
         fail("unable to parse JSON");
-    if(!json_equal(value1, value2))
+    if (!json_equal(value1, value2))
         fail("json_equal fails for two equal objects");
 
-    json_array_set_new(json_object_get(json_object_get(value2, "object"), 
-            "array-in-object"), 1, json_false());
-    if(json_equal(value1, value2))
+    json_array_set_new(
+        json_object_get(json_object_get(value2, "object"), "array-in-object"), 1,
+        json_false());
+    if (json_equal(value1, value2))
         fail("json_equal fails for two inequal objects");
 
-    json_object_set_new(json_object_get(json_object_get(value3, "object"), 
-            "object-in-object"), "foo", json_string("baz"));
-    if(json_equal(value1, value3))
+    json_object_set_new(
+        json_object_get(json_object_get(value3, "object"), "object-in-object"), "foo",
+        json_string("baz"));
+    if (json_equal(value1, value3))
         fail("json_equal fails for two inequal objects");
 
     json_decref(value1);
@@ -197,8 +194,7 @@ static void test_equal_complex()
     json_decref(value3);
 }
 
-static void run_tests()
-{
+static void run_tests() {
     test_equal_simple();
     test_equal_array();
     test_equal_object();
diff --git a/test/suites/api/test_load.c b/test/suites/api/test_load.c
index a3bdc57..1c64b0c 100644
--- a/test/suites/api/test_load.c
+++ b/test/suites/api/test_load.c
@@ -5,34 +5,33 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
+#include "util.h"
 #include <jansson.h>
 #include <string.h>
-#include "util.h"
 
-static void file_not_found()
-{
+static void file_not_found() {
     json_t *json;
     json_error_t error;
     char *pos;
 
     json = json_load_file("/path/to/nonexistent/file.json", 0, &error);
-    if(json)
+    if (json)
         fail("json_load_file returned non-NULL for a nonexistent file");
-    if(error.line != -1)
+    if (error.line != -1)
         fail("json_load_file returned an invalid line number");
 
     /* The error message is locale specific, only check the beginning
        of the error message. */
 
     pos = strchr(error.text, ':');
-    if(!pos)
+    if (!pos)
         fail("json_load_file returne an invalid error message");
 
     *pos = '\0';
 
-    if(strcmp(error.text, "unable to open /path/to/nonexistent/file.json") != 0)
+    if (strcmp(error.text, "unable to open /path/to/nonexistent/file.json") != 0)
         fail("json_load_file returned an invalid error message");
-    if(json_error_code(&error) != json_error_cannot_open_file)
+    if (json_error_code(&error) != json_error_cannot_open_file)
         fail("json_load_file returned an invalid error code");
 }
 
@@ -40,47 +39,48 @@ static void very_long_file_name() {
     json_t *json;
     json_error_t error;
 
-    json = json_load_file("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 0, &error);
-    if(json)
+    json = json_load_file("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                          "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                          0, &error);
+    if (json)
         fail("json_load_file returned non-NULL for a nonexistent file");
-    if(error.line != -1)
+    if (error.line != -1)
         fail("json_load_file returned an invalid line number");
 
     if (strncmp(error.source, "...aaa", 6) != 0)
         fail("error source was set incorrectly");
-    if(json_error_code(&error) != json_error_cannot_open_file)
+    if (json_error_code(&error) != json_error_cannot_open_file)
         fail("error code was set incorrectly");
 }
 
-static void reject_duplicates()
-{
+static void reject_duplicates() {
     json_error_t error;
 
-    if(json_loads("{\"foo\": 1, \"foo\": 2}", JSON_REJECT_DUPLICATES, &error))
+    if (json_loads("{\"foo\": 1, \"foo\": 2}", JSON_REJECT_DUPLICATES, &error))
         fail("json_loads did not detect a duplicate key");
-    check_error(json_error_duplicate_key, "duplicate object key near '\"foo\"'", "<string>", 1, 16, 16);
+    check_error(json_error_duplicate_key, "duplicate object key near '\"foo\"'",
+                "<string>", 1, 16, 16);
 }
 
-static void disable_eof_check()
-{
+static void disable_eof_check() {
     json_error_t error;
     json_t *json;
 
     const char *text = "{\"foo\": 1} garbage";
 
-    if(json_loads(text, 0, &error))
+    if (json_loads(text, 0, &error))
         fail("json_loads did not detect garbage after JSON text");
-    check_error(json_error_end_of_input_expected, "end of file expected near 'garbage'", "<string>", 1, 18, 18);
+    check_error(json_error_end_of_input_expected, "end of file expected near 'garbage'",
+                "<string>", 1, 18, 18);
 
     json = json_loads(text, JSON_DISABLE_EOF_CHECK, &error);
-    if(!json)
+    if (!json)
         fail("json_loads failed with JSON_DISABLE_EOF_CHECK");
 
     json_decref(json);
 }
 
-static void decode_any()
-{
+static void decode_any() {
     json_t *json;
     json_error_t error;
 
@@ -105,8 +105,7 @@ static void decode_any()
     json_decref(json);
 }
 
-static void decode_int_as_real()
-{
+static void decode_int_as_real() {
     json_t *json;
     json_error_t error;
 
@@ -127,8 +126,7 @@ static void decode_int_as_real()
     imprecise = "9007199254740993";
     expected = 9007199254740992ll;
 
-    json = json_loads(imprecise, JSON_DECODE_INT_AS_REAL | JSON_DECODE_ANY,
-                      &error);
+    json = json_loads(imprecise, JSON_DECODE_INT_AS_REAL | JSON_DECODE_ANY, &error);
     if (!json || !json_is_real(json) || expected != (json_int_t)json_real_value(json))
         fail("json_load decode int as real failed - expected imprecision");
     json_decref(json);
@@ -145,31 +143,28 @@ static void decode_int_as_real()
         json_error_code(&error) != json_error_numeric_overflow)
         fail("json_load decode int as real failed - expected overflow");
     json_decref(json);
-
 }
 
-static void allow_nul()
-{
+static void allow_nul() {
     const char *text = "\"nul byte \\u0000 in string\"";
     const char *expected = "nul byte \0 in string";
     size_t len = 20;
     json_t *json;
 
     json = json_loads(text, JSON_ALLOW_NUL | JSON_DECODE_ANY, NULL);
-    if(!json || !json_is_string(json))
+    if (!json || !json_is_string(json))
         fail("unable to decode embedded NUL byte");
 
-    if(json_string_length(json) != len)
+    if (json_string_length(json) != len)
         fail("decoder returned wrong string length");
 
-    if(memcmp(json_string_value(json), expected, len + 1))
+    if (memcmp(json_string_value(json), expected, len + 1))
         fail("decoder returned wrong string content");
 
     json_decref(json);
 }
 
-static void load_wrong_args()
-{
+static void load_wrong_args() {
     json_t *json;
     json_error_t error;
 
@@ -194,45 +189,42 @@ static void load_wrong_args()
         fail("json_load_file should return NULL if the first argument is NULL");
 }
 
-static void position()
-{
+static void position() {
     json_t *json;
     size_t flags = JSON_DISABLE_EOF_CHECK;
     json_error_t error;
 
     json = json_loads("{\"foo\": \"bar\"}", 0, &error);
-    if(error.position != 14)
+    if (error.position != 14)
         fail("json_loads returned a wrong position");
     json_decref(json);
 
     json = json_loads("{\"foo\": \"bar\"} baz quux", flags, &error);
-    if(error.position != 14)
+    if (error.position != 14)
         fail("json_loads returned a wrong position");
     json_decref(json);
 }
 
-static void error_code()
-{
+static void error_code() {
     json_error_t error;
     json_t *json = json_loads("[123] garbage", 0, &error);
-    if(json != NULL)
+    if (json != NULL)
         fail("json_loads returned not NULL");
-    if(strlen(error.text) >= JSON_ERROR_TEXT_LENGTH)
+    if (strlen(error.text) >= JSON_ERROR_TEXT_LENGTH)
         fail("error.text longer than expected");
-    if(json_error_code(&error) != json_error_end_of_input_expected)
+    if (json_error_code(&error) != json_error_end_of_input_expected)
         fail("json_loads returned incorrect error code");
 
     json = json_loads("{\"foo\": ", 0, &error);
-    if(json != NULL)
+    if (json != NULL)
         fail("json_loads returned not NULL");
-    if(strlen(error.text) >= JSON_ERROR_TEXT_LENGTH)
+    if (strlen(error.text) >= JSON_ERROR_TEXT_LENGTH)
         fail("error.text longer than expected");
-    if(json_error_code(&error) != json_error_premature_end_of_input)
+    if (json_error_code(&error) != json_error_premature_end_of_input)
         fail("json_loads returned incorrect error code");
 }
 
-static void run_tests()
-{
+static void run_tests() {
     file_not_found();
     very_long_file_name();
     reject_duplicates();
diff --git a/test/suites/api/test_load_callback.c b/test/suites/api/test_load_callback.c
index 9449528..b292fcf 100644
--- a/test/suites/api/test_load_callback.c
+++ b/test/suites/api/test_load_callback.c
@@ -5,10 +5,10 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
+#include "util.h"
 #include <jansson.h>
-#include <string.h>
 #include <stdlib.h>
-#include "util.h"
+#include <string.h>
 
 struct my_source {
     const char *buf;
@@ -18,8 +18,7 @@ struct my_source {
 
 static const char my_str[] = "[\"A\", {\"B\": \"C\", \"e\": false}, 1, null, \"foo\"]";
 
-static size_t greedy_reader(void *buf, size_t buflen, void *arg)
-{
+static size_t greedy_reader(void *buf, size_t buflen, void *arg) {
     struct my_source *s = arg;
     if (buflen > s->cap - s->off)
         buflen = s->cap - s->off;
@@ -32,8 +31,7 @@ static size_t greedy_reader(void *buf, size_t buflen, void *arg)
     }
 }
 
-static void run_tests()
-{
+static void run_tests() {
     struct my_source s;
     json_t *json;
     json_error_t error;
@@ -55,21 +53,25 @@ static void run_tests()
     json = json_load_callback(greedy_reader, &s, 0, &error);
     if (json) {
         json_decref(json);
-        fail("json_load_callback should have failed on an incomplete stream, but it didn't");
+        fail("json_load_callback should have failed on an incomplete stream, "
+             "but it didn't");
     }
     if (strcmp(error.source, "<callback>") != 0) {
         fail("json_load_callback returned an invalid error source");
     }
     if (strcmp(error.text, "']' expected near end of file") != 0) {
-        fail("json_load_callback returned an invalid error message for an unclosed top-level array");
+        fail("json_load_callback returned an invalid error message for an "
+             "unclosed top-level array");
     }
 
     json = json_load_callback(NULL, NULL, 0, &error);
     if (json) {
         json_decref(json);
-        fail("json_load_callback should have failed on NULL load callback, but it didn't");
+        fail("json_load_callback should have failed on NULL load callback, but "
+             "it didn't");
     }
     if (strcmp(error.text, "wrong arguments") != 0) {
-        fail("json_load_callback returned an invalid error message for a NULL load callback");
+        fail("json_load_callback returned an invalid error message for a NULL "
+             "load callback");
     }
 }
diff --git a/test/suites/api/test_loadb.c b/test/suites/api/test_loadb.c
index 64e1fc5..2cd88fe 100644
--- a/test/suites/api/test_loadb.c
+++ b/test/suites/api/test_loadb.c
@@ -5,19 +5,18 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
+#include "util.h"
 #include <jansson.h>
 #include <string.h>
-#include "util.h"
 
-static void run_tests()
-{
+static void run_tests() {
     json_t *json;
     json_error_t error;
     const char str[] = "[\"A\", {\"B\": \"C\"}, 1, 2, 3]garbage";
     size_t len = strlen(str) - strlen("garbage");
 
     json = json_loadb(str, len, 0, &error);
-    if(!json) {
+    if (!json) {
         fail("json_loadb failed on a valid JSON buffer");
     }
     json_decref(json);
@@ -25,12 +24,14 @@ static void run_tests()
     json = json_loadb(str, len - 1, 0, &error);
     if (json) {
         json_decref(json);
-        fail("json_loadb should have failed on an incomplete buffer, but it didn't");
+        fail("json_loadb should have failed on an incomplete buffer, but it "
+             "didn't");
     }
-    if(error.line != 1) {
+    if (error.line != 1) {
         fail("json_loadb returned an invalid line number on fail");
     }
-    if(strcmp(error.text, "']' expected near end of file") != 0) {
-        fail("json_loadb returned an invalid error message for an unclosed top-level array");
+    if (strcmp(error.text, "']' expected near end of file") != 0) {
+        fail("json_loadb returned an invalid error message for an unclosed "
+             "top-level array");
     }
 }
diff --git a/test/suites/api/test_memory_funcs.c b/test/suites/api/test_memory_funcs.c
index 02e450c..4fd6166 100644
--- a/test/suites/api/test_memory_funcs.c
+++ b/test/suites/api/test_memory_funcs.c
@@ -1,5 +1,5 @@
-#include <string.h>
 #include <jansson.h>
+#include <string.h>
 
 #include "util.h"
 
@@ -8,29 +8,21 @@ static int free_called = 0;
 static size_t malloc_used = 0;
 
 /* helpers */
-static void create_and_free_complex_object()
-{
+static void create_and_free_complex_object() {
     json_t *obj;
 
-    obj = json_pack("{s:i,s:n,s:b,s:b,s:{s:s},s:[i,i,i]}",
-                    "foo", 42,
-                    "bar",
-                    "baz", 1,
-                    "qux", 0,
-                    "alice", "bar", "baz",
-                    "bob", 9, 8, 7);
+    obj = json_pack("{s:i,s:n,s:b,s:b,s:{s:s},s:[i,i,i]}", "foo", 42, "bar", "baz", 1,
+                    "qux", 0, "alice", "bar", "baz", "bob", 9, 8, 7);
 
     json_decref(obj);
 }
 
-static void create_and_free_object_with_oom()
-{
+static void create_and_free_object_with_oom() {
     int i;
     char key[4];
     json_t *obj = json_object();
 
-    for (i = 0; i < 10; i++)
-    {
+    for (i = 0; i < 10; i++) {
         snprintf(key, sizeof key, "%d", i);
         json_object_set_new(obj, key, json_integer(i));
     }
@@ -38,20 +30,17 @@ static void create_and_free_object_with_oom()
     json_decref(obj);
 }
 
-static void *my_malloc(size_t size)
-{
+static void *my_malloc(size_t size) {
     malloc_called = 1;
     return malloc(size);
 }
 
-static void my_free(void *ptr)
-{
+static void my_free(void *ptr) {
     free_called = 1;
     free(ptr);
 }
 
-static void test_simple()
-{
+static void test_simple() {
     json_malloc_t mfunc = NULL;
     json_free_t ffunc = NULL;
 
@@ -59,14 +48,11 @@ static void test_simple()
     json_get_alloc_funcs(&mfunc, &ffunc);
     create_and_free_complex_object();
 
-    if (malloc_called != 1 || free_called != 1
-        || mfunc != my_malloc || ffunc != my_free)
+    if (malloc_called != 1 || free_called != 1 || mfunc != my_malloc || ffunc != my_free)
         fail("Custom allocation failed");
 }
 
-
-static void *oom_malloc(size_t size)
-{
+static void *oom_malloc(size_t size) {
     if (malloc_used + size > 800)
         return NULL;
 
@@ -74,14 +60,12 @@ static void *oom_malloc(size_t size)
     return malloc(size);
 }
 
-static void oom_free(void *ptr)
-{
+static void oom_free(void *ptr) {
     free_called++;
     free(ptr);
 }
 
-static void test_oom()
-{
+static void test_oom() {
     free_called = 0;
     json_set_alloc_funcs(oom_malloc, oom_free);
     create_and_free_object_with_oom();
@@ -90,46 +74,40 @@ static void test_oom()
         fail("Allocation with OOM failed");
 }
 
-
 /*
   Test the secure memory functions code given in the API reference
   documentation, but by using plain memset instead of
   guaranteed_memset().
 */
 
-static void *secure_malloc(size_t size)
-{
+static void *secure_malloc(size_t size) {
     /* Store the memory area size in the beginning of the block */
     void *ptr = malloc(size + 8);
     *((size_t *)ptr) = size;
     return (char *)ptr + 8;
 }
 
-static void secure_free(void *ptr)
-{
+static void secure_free(void *ptr) {
     size_t size;
 
     ptr = (char *)ptr - 8;
     size = *((size_t *)ptr);
 
-    /*guaranteed_*/memset(ptr, 0, size + 8);
+    /*guaranteed_*/ memset(ptr, 0, size + 8);
     free(ptr);
 }
 
-static void test_secure_funcs(void)
-{
+static void test_secure_funcs(void) {
     json_set_alloc_funcs(secure_malloc, secure_free);
     create_and_free_complex_object();
 }
 
-static void test_bad_args(void)
-{
+static void test_bad_args(void) {
     /* The result of this test is not crashing. */
     json_get_alloc_funcs(NULL, NULL);
 }
 
-static void run_tests()
-{
+static void run_tests() {
     test_simple();
     test_secure_funcs();
     test_oom();
diff --git a/test/suites/api/test_number.c b/test/suites/api/test_number.c
index bf33aec..2a22a67 100644
--- a/test/suites/api/test_number.c
+++ b/test/suites/api/test_number.c
@@ -5,9 +5,9 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
-#include <math.h>
-#include <jansson.h>
 #include "util.h"
+#include <jansson.h>
+#include <math.h>
 
 #ifdef INFINITY
 // This test triggers "warning C4756: overflow in constant arithmetic"
@@ -15,20 +15,19 @@
 // (This can only be done on function level so we keep these tests separate)
 #ifdef _MSC_VER
 #pragma warning(push)
-#pragma warning (disable: 4756)
+#pragma warning(disable : 4756)
 #endif
-static void test_inifity()
-{
+static void test_inifity() {
     json_t *real = json_real(INFINITY);
     if (real != NULL)
-       fail("could construct a real from Inf");
+        fail("could construct a real from Inf");
 
     real = json_real(1.0);
     if (json_real_set(real, INFINITY) != -1)
-	    fail("could set a real to Inf");
+        fail("could set a real to Inf");
 
     if (json_real_value(real) != 1.0)
-       fail("real value changed unexpectedly");
+        fail("real value changed unexpectedly");
 
     json_decref(real);
 #ifdef _MSC_VER
@@ -37,33 +36,32 @@ static void test_inifity()
 }
 #endif // INFINITY
 
-static void test_bad_args(void)
-{
+static void test_bad_args(void) {
     json_t *txt = json_string("test");
 
-    if(json_integer_value(NULL) != 0)
+    if (json_integer_value(NULL) != 0)
         fail("json_integer_value did not return 0 for non-integer");
-    if(json_integer_value(txt) != 0)
+    if (json_integer_value(txt) != 0)
         fail("json_integer_value did not return 0 for non-integer");
 
-    if(!json_integer_set(NULL, 0))
+    if (!json_integer_set(NULL, 0))
         fail("json_integer_set did not return error for non-integer");
-    if(!json_integer_set(txt, 0))
+    if (!json_integer_set(txt, 0))
         fail("json_integer_set did not return error for non-integer");
 
-    if(json_real_value(NULL) != 0.0)
+    if (json_real_value(NULL) != 0.0)
         fail("json_real_value did not return 0.0 for non-real");
-    if(json_real_value(txt) != 0.0)
+    if (json_real_value(txt) != 0.0)
         fail("json_real_value did not return 0.0 for non-real");
 
-    if(!json_real_set(NULL, 0.0))
+    if (!json_real_set(NULL, 0.0))
         fail("json_real_set did not return error for non-real");
-    if(!json_real_set(txt, 0.0))
+    if (!json_real_set(txt, 0.0))
         fail("json_real_set did not return error for non-real");
 
-    if(json_number_value(NULL) != 0.0)
+    if (json_number_value(NULL) != 0.0)
         fail("json_number_value did not return 0.0 for non-numeric");
-    if(json_number_value(txt) != 0.0)
+    if (json_number_value(txt) != 0.0)
         fail("json_number_value did not return 0.0 for non-numeric");
 
     if (txt->refcount != 1)
@@ -72,8 +70,7 @@ static void test_bad_args(void)
     json_decref(txt);
 }
 
-static void run_tests()
-{
+static void run_tests() {
     json_t *integer, *real;
     json_int_t i;
     double d;
@@ -81,24 +78,24 @@ static void run_tests()
     integer = json_integer(5);
     real = json_real(100.1);
 
-    if(!integer)
+    if (!integer)
         fail("unable to create integer");
-    if(!real)
+    if (!real)
         fail("unable to create real");
 
     i = json_integer_value(integer);
-    if(i != 5)
+    if (i != 5)
         fail("wrong integer value");
 
     d = json_real_value(real);
-    if(d != 100.1)
+    if (d != 100.1)
         fail("wrong real value");
 
     d = json_number_value(integer);
-    if(d != 5.0)
+    if (d != 5.0)
         fail("wrong number value");
     d = json_number_value(real);
-    if(d != 100.1)
+    if (d != 100.1)
         fail("wrong number value");
 
     json_decref(integer);
@@ -106,14 +103,14 @@ static void run_tests()
 
 #ifdef NAN
     real = json_real(NAN);
-    if(real != NULL)
+    if (real != NULL)
         fail("could construct a real from NaN");
 
     real = json_real(1.0);
-    if(json_real_set(real, NAN) != -1)
+    if (json_real_set(real, NAN) != -1)
         fail("could set a real to NaN");
 
-    if(json_real_value(real) != 1.0)
+    if (json_real_value(real) != 1.0)
         fail("real value changed unexpectedly");
 
     json_decref(real);
diff --git a/test/suites/api/test_object.c b/test/suites/api/test_object.c
index 5112fc7..331edf2 100644
--- a/test/suites/api/test_object.c
+++ b/test/suites/api/test_object.c
@@ -5,43 +5,39 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
+#include "util.h"
 #include <jansson.h>
 #include <string.h>
-#include "util.h"
 
-static void test_clear()
-{
+static void test_clear() {
     json_t *object, *ten;
 
     object = json_object();
     ten = json_integer(10);
 
-    if(!object)
+    if (!object)
         fail("unable to create object");
-    if(!ten)
+    if (!ten)
         fail("unable to create integer");
 
-    if(json_object_set(object, "a", ten) ||
-       json_object_set(object, "b", ten) ||
-       json_object_set(object, "c", ten) ||
-       json_object_set(object, "d", ten) ||
-       json_object_set(object, "e", ten))
+    if (json_object_set(object, "a", ten) || json_object_set(object, "b", ten) ||
+        json_object_set(object, "c", ten) || json_object_set(object, "d", ten) ||
+        json_object_set(object, "e", ten))
         fail("unable to set value");
 
-    if(json_object_size(object) != 5)
+    if (json_object_size(object) != 5)
         fail("invalid size");
 
     json_object_clear(object);
 
-    if(json_object_size(object) != 0)
+    if (json_object_size(object) != 0)
         fail("invalid size after clear");
 
     json_decref(ten);
     json_decref(object);
 }
 
-static void test_update()
-{
+static void test_update() {
     json_t *object, *other, *nine, *ten;
 
     object = json_object();
@@ -50,113 +46,95 @@ static void test_update()
     nine = json_integer(9);
     ten = json_integer(10);
 
-    if(!object || !other)
+    if (!object || !other)
         fail("unable to create object");
-    if(!nine || !ten)
+    if (!nine || !ten)
         fail("unable to create integer");
 
-
     /* update an empty object with an empty object */
 
-    if(json_object_update(object, other))
+    if (json_object_update(object, other))
         fail("unable to update an empty object with an empty object");
 
-    if(json_object_size(object) != 0)
+    if (json_object_size(object) != 0)
         fail("invalid size after update");
 
-    if(json_object_size(other) != 0)
+    if (json_object_size(other) != 0)
         fail("invalid size for updater after update");
 
-
     /* update an empty object with a nonempty object */
 
-    if(json_object_set(other, "a", ten) ||
-       json_object_set(other, "b", ten) ||
-       json_object_set(other, "c", ten) ||
-       json_object_set(other, "d", ten) ||
-       json_object_set(other, "e", ten))
+    if (json_object_set(other, "a", ten) || json_object_set(other, "b", ten) ||
+        json_object_set(other, "c", ten) || json_object_set(other, "d", ten) ||
+        json_object_set(other, "e", ten))
         fail("unable to set value");
 
-    if(json_object_update(object, other))
+    if (json_object_update(object, other))
         fail("unable to update an empty object");
 
-    if(json_object_size(object) != 5)
+    if (json_object_size(object) != 5)
         fail("invalid size after update");
 
-    if(json_object_get(object, "a") != ten ||
-       json_object_get(object, "b") != ten ||
-       json_object_get(object, "c") != ten ||
-       json_object_get(object, "d") != ten ||
-       json_object_get(object, "e") != ten)
+    if (json_object_get(object, "a") != ten || json_object_get(object, "b") != ten ||
+        json_object_get(object, "c") != ten || json_object_get(object, "d") != ten ||
+        json_object_get(object, "e") != ten)
         fail("update works incorrectly");
 
-
     /* perform the same update again */
 
-    if(json_object_update(object, other))
+    if (json_object_update(object, other))
         fail("unable to update a non-empty object");
 
-    if(json_object_size(object) != 5)
+    if (json_object_size(object) != 5)
         fail("invalid size after update");
 
-    if(json_object_get(object, "a") != ten ||
-       json_object_get(object, "b") != ten ||
-       json_object_get(object, "c") != ten ||
-       json_object_get(object, "d") != ten ||
-       json_object_get(object, "e") != ten)
+    if (json_object_get(object, "a") != ten || json_object_get(object, "b") != ten ||
+        json_object_get(object, "c") != ten || json_object_get(object, "d") != ten ||
+        json_object_get(object, "e") != ten)
         fail("update works incorrectly");
 
-
     /* update a nonempty object with a nonempty object with both old
        and new keys */
 
-    if(json_object_clear(other))
+    if (json_object_clear(other))
         fail("clear failed");
 
-    if(json_object_set(other, "a", nine) ||
-       json_object_set(other, "b", nine) ||
-       json_object_set(other, "f", nine) ||
-       json_object_set(other, "g", nine) ||
-       json_object_set(other, "h", nine))
+    if (json_object_set(other, "a", nine) || json_object_set(other, "b", nine) ||
+        json_object_set(other, "f", nine) || json_object_set(other, "g", nine) ||
+        json_object_set(other, "h", nine))
         fail("unable to set value");
 
-    if(json_object_update(object, other))
+    if (json_object_update(object, other))
         fail("unable to update a nonempty object");
 
-    if(json_object_size(object) != 8)
+    if (json_object_size(object) != 8)
         fail("invalid size after update");
 
-    if(json_object_get(object, "a") != nine ||
-       json_object_get(object, "b") != nine ||
-       json_object_get(object, "f") != nine ||
-       json_object_get(object, "g") != nine ||
-       json_object_get(object, "h") != nine)
+    if (json_object_get(object, "a") != nine || json_object_get(object, "b") != nine ||
+        json_object_get(object, "f") != nine || json_object_get(object, "g") != nine ||
+        json_object_get(object, "h") != nine)
         fail("update works incorrectly");
 
     /* update_new check */
-    if(json_object_clear(object))
+    if (json_object_clear(object))
         fail("clear failed");
 
-    if(json_object_set(object, "a", ten) ||
-       json_object_set(object, "b", ten) ||
-       json_object_set(object, "c", ten) ||
-       json_object_set(object, "d", ten) ||
-       json_object_set(object, "e", ten))
+    if (json_object_set(object, "a", ten) || json_object_set(object, "b", ten) ||
+        json_object_set(object, "c", ten) || json_object_set(object, "d", ten) ||
+        json_object_set(object, "e", ten))
         fail("unable to set value");
 
-    if(json_object_update_new(object, json_pack("{s:O, s:O, s:O}", "b", nine, "f", nine, "g", nine)))
+    if (json_object_update_new(
+            object, json_pack("{s:O, s:O, s:O}", "b", nine, "f", nine, "g", nine)))
         fail("unable to update_new a nonempty object");
 
-    if(json_object_size(object) != 7)
+    if (json_object_size(object) != 7)
         fail("invalid size after update_new");
 
-    if(json_object_get(object, "a") != ten ||
-       json_object_get(object, "b") != nine ||
-       json_object_get(object, "c") != ten ||
-       json_object_get(object, "d") != ten ||
-       json_object_get(object, "e") != ten ||
-       json_object_get(object, "f") != nine ||
-       json_object_get(object, "g") != nine)
+    if (json_object_get(object, "a") != ten || json_object_get(object, "b") != nine ||
+        json_object_get(object, "c") != ten || json_object_get(object, "d") != ten ||
+        json_object_get(object, "e") != ten || json_object_get(object, "f") != nine ||
+        json_object_get(object, "g") != nine)
         fail("update_new works incorrectly");
 
     json_decref(nine);
@@ -165,8 +143,7 @@ static void test_update()
     json_decref(object);
 }
 
-static void test_set_many_keys()
-{
+static void test_set_many_keys() {
     json_t *object, *value;
     const char *keys = "abcdefghijklmnopqrstuvwxyz";
     char buf[2];
@@ -191,23 +168,22 @@ static void test_set_many_keys()
     json_decref(value);
 }
 
-static void test_conditional_updates()
-{
+static void test_conditional_updates() {
     json_t *object, *other;
 
     object = json_pack("{sisi}", "foo", 1, "bar", 2);
     other = json_pack("{sisi}", "foo", 3, "baz", 4);
 
-    if(json_object_update_existing(object, other))
+    if (json_object_update_existing(object, other))
         fail("json_object_update_existing failed");
 
-    if(json_object_size(object) != 2)
+    if (json_object_size(object) != 2)
         fail("json_object_update_existing added new items");
 
-    if(json_integer_value(json_object_get(object, "foo")) != 3)
+    if (json_integer_value(json_object_get(object, "foo")) != 3)
         fail("json_object_update_existing failed to update existing key");
 
-    if(json_integer_value(json_object_get(object, "bar")) != 2)
+    if (json_integer_value(json_object_get(object, "bar")) != 2)
         fail("json_object_update_existing updated wrong key");
 
     json_decref(object);
@@ -215,35 +191,35 @@ static void test_conditional_updates()
     /* json_object_update_existing_new check */
     object = json_pack("{sisi}", "foo", 1, "bar", 2);
 
-    if(json_object_update_existing_new(object, json_pack("{sisi}", "foo", 3, "baz", 4)))
+    if (json_object_update_existing_new(object, json_pack("{sisi}", "foo", 3, "baz", 4)))
         fail("json_object_update_existing_new failed");
 
-    if(json_object_size(object) != 2)
+    if (json_object_size(object) != 2)
         fail("json_object_update_existing_new added new items");
 
-    if(json_integer_value(json_object_get(object, "foo")) != 3)
+    if (json_integer_value(json_object_get(object, "foo")) != 3)
         fail("json_object_update_existing_new failed to update existing key");
 
-    if(json_integer_value(json_object_get(object, "bar")) != 2)
+    if (json_integer_value(json_object_get(object, "bar")) != 2)
         fail("json_object_update_existing_new updated wrong key");
 
     json_decref(object);
 
     object = json_pack("{sisi}", "foo", 1, "bar", 2);
 
-    if(json_object_update_missing(object, other))
+    if (json_object_update_missing(object, other))
         fail("json_object_update_missing failed");
 
-    if(json_object_size(object) != 3)
+    if (json_object_size(object) != 3)
         fail("json_object_update_missing didn't add new items");
 
-    if(json_integer_value(json_object_get(object, "foo")) != 1)
+    if (json_integer_value(json_object_get(object, "foo")) != 1)
         fail("json_object_update_missing updated existing key");
 
-    if(json_integer_value(json_object_get(object, "bar")) != 2)
+    if (json_integer_value(json_object_get(object, "bar")) != 2)
         fail("json_object_update_missing updated wrong key");
 
-    if(json_integer_value(json_object_get(object, "baz")) != 4)
+    if (json_integer_value(json_object_get(object, "baz")) != 4)
         fail("json_object_update_missing didn't add new items");
 
     json_decref(object);
@@ -251,27 +227,26 @@ static void test_conditional_updates()
     /* json_object_update_missing_new check */
     object = json_pack("{sisi}", "foo", 1, "bar", 2);
 
-    if(json_object_update_missing_new(object, json_pack("{sisi}", "foo", 3, "baz", 4)))
+    if (json_object_update_missing_new(object, json_pack("{sisi}", "foo", 3, "baz", 4)))
         fail("json_object_update_missing_new failed");
 
-    if(json_object_size(object) != 3)
+    if (json_object_size(object) != 3)
         fail("json_object_update_missing_new didn't add new items");
 
-    if(json_integer_value(json_object_get(object, "foo")) != 1)
+    if (json_integer_value(json_object_get(object, "foo")) != 1)
         fail("json_object_update_missing_new updated existing key");
 
-    if(json_integer_value(json_object_get(object, "bar")) != 2)
+    if (json_integer_value(json_object_get(object, "bar")) != 2)
         fail("json_object_update_missing_new updated wrong key");
 
-    if(json_integer_value(json_object_get(object, "baz")) != 4)
+    if (json_integer_value(json_object_get(object, "baz")) != 4)
         fail("json_object_update_missing_new didn't add new items");
 
     json_decref(object);
     json_decref(other);
 }
 
-static void test_recursive_updates()
-{
+static void test_recursive_updates() {
     json_t *invalid, *object, *other, *barBefore, *barAfter;
 
     invalid = json_integer(42);
@@ -279,24 +254,24 @@ static void test_recursive_updates()
     object = json_pack("{sis{si}}", "foo", 1, "bar", "baz", 2);
     other = json_pack("{sisisi}", "foo", 3, "bar", 4, "baz", 5);
 
-    if(!json_object_update_recursive(invalid, other))
+    if (!json_object_update_recursive(invalid, other))
         fail("json_object_update_recursive accepted non-object argument");
 
     json_decref(invalid);
 
-    if(json_object_update_recursive(object, other))
+    if (json_object_update_recursive(object, other))
         fail("json_object_update_recursive failed");
 
-    if(json_object_size(object) != 3)
+    if (json_object_size(object) != 3)
         fail("invalid size after update");
 
-    if(json_integer_value(json_object_get(object, "foo")) != 3)
+    if (json_integer_value(json_object_get(object, "foo")) != 3)
         fail("json_object_update_recursive failed to update existing key");
 
-    if(json_integer_value(json_object_get(object, "bar")) != 4)
+    if (json_integer_value(json_object_get(object, "bar")) != 4)
         fail("json_object_update_recursive failed to overwrite object");
 
-    if(json_integer_value(json_object_get(object, "baz")) != 5)
+    if (json_integer_value(json_object_get(object, "baz")) != 5)
         fail("json_object_update_recursive didn't add new item");
 
     json_decref(object);
@@ -306,26 +281,26 @@ static void test_recursive_updates()
     other = json_pack("{s{si}}", "bar", "baz", 3);
     barBefore = json_object_get(object, "bar");
 
-    if(!barBefore)
+    if (!barBefore)
         fail("can't get bar object before json_object_update_recursive");
 
-    if(json_object_update_recursive(object, other))
+    if (json_object_update_recursive(object, other))
         fail("json_object_update_recursive failed");
 
-    if(json_object_size(object) != 2)
+    if (json_object_size(object) != 2)
         fail("invalid size after update");
 
-    if(!json_object_get(object, "foo"))
+    if (!json_object_get(object, "foo"))
         fail("json_object_update_recursive removed existing key");
 
-    if(json_integer_value(json_object_get(json_object_get(object, "bar"), "baz")) != 3)
+    if (json_integer_value(json_object_get(json_object_get(object, "bar"), "baz")) != 3)
         fail("json_object_update_recursive failed to update nested value");
 
     barAfter = json_object_get(object, "bar");
-    if(!barAfter)
+    if (!barAfter)
         fail("can't get bar object after json_object_update_recursive");
 
-    if(barBefore != barAfter)
+    if (barBefore != barAfter)
         fail("bar object reference changed after json_object_update_recursive");
 
     json_decref(object);
@@ -337,39 +312,37 @@ static void test_recursive_updates()
     json_object_set(json_object_get(json_object_get(other, "foo"), "bar"), "baz",
                     json_object_get(other, "foo"));
 
-    if(!json_object_update_recursive(object, other))
+    if (!json_object_update_recursive(object, other))
         fail("json_object_update_recursive update a circular reference!");
 
     json_object_set_new(json_object_get(json_object_get(other, "foo"), "bar"), "baz",
                         json_integer(1));
 
-    if(json_object_update_recursive(object, other))
+    if (json_object_update_recursive(object, other))
         fail("json_object_update_recursive failed!");
 
     json_decref(object);
     json_decref(other);
 }
 
-static void test_circular()
-{
+static void test_circular() {
     json_t *object1, *object2;
 
     object1 = json_object();
     object2 = json_object();
-    if(!object1 || !object2)
+    if (!object1 || !object2)
         fail("unable to create object");
 
     /* the simple case is checked */
-    if(json_object_set(object1, "a", object1) == 0)
+    if (json_object_set(object1, "a", object1) == 0)
         fail("able to set self");
 
     /* create circular references */
-    if(json_object_set(object1, "a", object2) ||
-       json_object_set(object2, "a", object1))
+    if (json_object_set(object1, "a", object2) || json_object_set(object2, "a", object1))
         fail("unable to set value");
 
     /* circularity is detected when dumping */
-    if(json_dumps(object1, 0) != NULL)
+    if (json_dumps(object1, 0) != NULL)
         fail("able to dump circulars");
 
     /* decref twice to deal with the circular references */
@@ -378,72 +351,69 @@ static void test_circular()
     json_decref(object1);
 }
 
-static void test_set_nocheck()
-{
+static void test_set_nocheck() {
     json_t *object, *string;
 
     object = json_object();
     string = json_string("bar");
 
-    if(!object)
+    if (!object)
         fail("unable to create object");
-    if(!string)
+    if (!string)
         fail("unable to create string");
 
-    if(json_object_set_nocheck(object, "foo", string))
+    if (json_object_set_nocheck(object, "foo", string))
         fail("json_object_set_nocheck failed");
-    if(json_object_get(object, "foo") != string)
+    if (json_object_get(object, "foo") != string)
         fail("json_object_get after json_object_set_nocheck failed");
 
     /* invalid UTF-8 in key */
-    if(json_object_set_nocheck(object, "a\xefz", string))
+    if (json_object_set_nocheck(object, "a\xefz", string))
         fail("json_object_set_nocheck failed for invalid UTF-8");
-    if(json_object_get(object, "a\xefz") != string)
+    if (json_object_get(object, "a\xefz") != string)
         fail("json_object_get after json_object_set_nocheck failed");
 
-    if(json_object_set_new_nocheck(object, "bax", json_integer(123)))
+    if (json_object_set_new_nocheck(object, "bax", json_integer(123)))
         fail("json_object_set_new_nocheck failed");
-    if(json_integer_value(json_object_get(object, "bax")) != 123)
+    if (json_integer_value(json_object_get(object, "bax")) != 123)
         fail("json_object_get after json_object_set_new_nocheck failed");
 
     /* invalid UTF-8 in key */
-    if(json_object_set_new_nocheck(object, "asdf\xfe", json_integer(321)))
+    if (json_object_set_new_nocheck(object, "asdf\xfe", json_integer(321)))
         fail("json_object_set_new_nocheck failed for invalid UTF-8");
-    if(json_integer_value(json_object_get(object, "asdf\xfe")) != 321)
+    if (json_integer_value(json_object_get(object, "asdf\xfe")) != 321)
         fail("json_object_get after json_object_set_new_nocheck failed");
 
     json_decref(string);
     json_decref(object);
 }
 
-static void test_iterators()
-{
+static void test_iterators() {
     json_t *object, *foo, *bar, *baz;
     void *iter;
 
-    if(json_object_iter(NULL))
+    if (json_object_iter(NULL))
         fail("able to iterate over NULL");
 
-    if(json_object_iter_next(NULL, NULL))
+    if (json_object_iter_next(NULL, NULL))
         fail("able to increment an iterator on a NULL object");
 
     object = json_object();
     foo = json_string("foo");
     bar = json_string("bar");
     baz = json_string("baz");
-    if(!object || !foo || !bar || !baz)
+    if (!object || !foo || !bar || !baz)
         fail("unable to create values");
 
-    if(json_object_iter_next(object, NULL))
+    if (json_object_iter_next(object, NULL))
         fail("able to increment a NULL iterator");
 
-    if(json_object_set(object, "a", foo) ||
-       json_object_set(object, "b", bar) ||
-       json_object_set(object, "c", baz))
+    if (json_object_set(object, "a", foo) || json_object_set(object, "b", bar) ||
+        json_object_set(object, "c", baz))
         fail("unable to populate object");
 
     iter = json_object_iter(object);
-    if(!iter)
+    if (!iter)
         fail("unable to get iterator");
     if (strcmp(json_object_iter_key(iter), "a") != 0)
         fail("iterating doesn't yield keys in order");
@@ -451,7 +421,7 @@ static void test_iterators()
         fail("iterating doesn't yield values in order");
 
     iter = json_object_iter_next(object, iter);
-    if(!iter)
+    if (!iter)
         fail("unable to increment iterator");
     if (strcmp(json_object_iter_key(iter), "b") != 0)
         fail("iterating doesn't yield keys in order");
@@ -459,36 +429,36 @@ static void test_iterators()
         fail("iterating doesn't yield values in order");
 
     iter = json_object_iter_next(object, iter);
-    if(!iter)
+    if (!iter)
         fail("unable to increment iterator");
     if (strcmp(json_object_iter_key(iter), "c") != 0)
         fail("iterating doesn't yield keys in order");
     if (json_object_iter_value(iter) != baz)
         fail("iterating doesn't yield values in order");
 
-    if(json_object_iter_next(object, iter) != NULL)
+    if (json_object_iter_next(object, iter) != NULL)
         fail("able to iterate over the end");
 
-    if(json_object_iter_at(object, "foo"))
+    if (json_object_iter_at(object, "foo"))
         fail("json_object_iter_at() succeeds for non-existent key");
 
     iter = json_object_iter_at(object, "b");
-    if(!iter)
+    if (!iter)
         fail("json_object_iter_at() fails for an existing key");
 
-    if(strcmp(json_object_iter_key(iter), "b"))
+    if (strcmp(json_object_iter_key(iter), "b"))
         fail("iterating failed: wrong key");
-    if(json_object_iter_value(iter) != bar)
+    if (json_object_iter_value(iter) != bar)
         fail("iterating failed: wrong value");
 
-    if(json_object_iter_set(object, iter, baz))
+    if (json_object_iter_set(object, iter, baz))
         fail("unable to set value at iterator");
 
-    if(strcmp(json_object_iter_key(iter), "b"))
+    if (strcmp(json_object_iter_key(iter), "b"))
         fail("json_object_iter_key() fails after json_object_iter_set()");
-    if(json_object_iter_value(iter) != baz)
+    if (json_object_iter_value(iter) != baz)
         fail("json_object_iter_value() fails after json_object_iter_set()");
-    if(json_object_get(object, "b") != baz)
+    if (json_object_get(object, "b") != baz)
         fail("json_object_get() fails after json_object_iter_set()");
 
     json_decref(object);
@@ -497,113 +467,109 @@ static void test_iterators()
     json_decref(baz);
 }
 
-static void test_misc()
-{
+static void test_misc() {
     json_t *object, *string, *other_string, *value;
 
     object = json_object();
     string = json_string("test");
     other_string = json_string("other");
 
-    if(!object)
+    if (!object)
         fail("unable to create object");
-    if(!string || !other_string)
+    if (!string || !other_string)
         fail("unable to create string");
 
-    if(json_object_get(object, "a"))
+    if (json_object_get(object, "a"))
         fail("value for nonexisting key");
 
-    if(json_object_set(object, "a", string))
+    if (json_object_set(object, "a", string))
         fail("unable to set value");
 
-    if(!json_object_set(object, NULL, string))
+    if (!json_object_set(object, NULL, string))
         fail("able to set NULL key");
 
-    if(json_object_del(object, "a"))
+    if (json_object_del(object, "a"))
         fail("unable to del the only key");
 
-    if(json_object_set(object, "a", string))
+    if (json_object_set(object, "a", string))
         fail("unable to set value");
 
-    if(!json_object_set(object, "a", NULL))
+    if (!json_object_set(object, "a", NULL))
         fail("able to set NULL value");
 
     /* invalid UTF-8 in key */
-    if(!json_object_set(object, "a\xefz", string))
+    if (!json_object_set(object, "a\xefz", string))
         fail("able to set invalid unicode key");
 
     value = json_object_get(object, "a");
-    if(!value)
+    if (!value)
         fail("no value for existing key");
-    if(value != string)
+    if (value != string)
         fail("got different value than what was added");
 
     /* "a", "lp" and "px" collide in a five-bucket hashtable */
-    if(json_object_set(object, "b", string) ||
-       json_object_set(object, "lp", string) ||
-       json_object_set(object, "px", string))
+    if (json_object_set(object, "b", string) || json_object_set(object, "lp", string) ||
+        json_object_set(object, "px", string))
         fail("unable to set value");
 
     value = json_object_get(object, "a");
-    if(!value)
+    if (!value)
         fail("no value for existing key");
-    if(value != string)
+    if (value != string)
         fail("got different value than what was added");
 
-    if(json_object_set(object, "a", other_string))
+    if (json_object_set(object, "a", other_string))
         fail("unable to replace an existing key");
 
     value = json_object_get(object, "a");
-    if(!value)
+    if (!value)
         fail("no value for existing key");
-    if(value != other_string)
+    if (value != other_string)
         fail("got different value than what was set");
 
-    if(!json_object_del(object, "nonexisting"))
+    if (!json_object_del(object, "nonexisting"))
         fail("able to delete a nonexisting key");
 
-    if(json_object_del(object, "px"))
+    if (json_object_del(object, "px"))
         fail("unable to delete an existing key");
 
-    if(json_object_del(object, "a"))
+    if (json_object_del(object, "a"))
         fail("unable to delete an existing key");
 
-    if(json_object_del(object, "lp"))
+    if (json_object_del(object, "lp"))
         fail("unable to delete an existing key");
 
-
     /* add many keys to initiate rehashing */
 
-    if(json_object_set(object, "a", string))
+    if (json_object_set(object, "a", string))
         fail("unable to set value");
 
-    if(json_object_set(object, "lp", string))
+    if (json_object_set(object, "lp", string))
         fail("unable to set value");
 
-    if(json_object_set(object, "px", string))
+    if (json_object_set(object, "px", string))
         fail("unable to set value");
 
-    if(json_object_set(object, "c", string))
+    if (json_object_set(object, "c", string))
         fail("unable to set value");
 
-    if(json_object_set(object, "d", string))
+    if (json_object_set(object, "d", string))
         fail("unable to set value");
 
-    if(json_object_set(object, "e", string))
+    if (json_object_set(object, "e", string))
         fail("unable to set value");
 
-
-    if(json_object_set_new(object, "foo", json_integer(123)))
+    if (json_object_set_new(object, "foo", json_integer(123)))
         fail("unable to set new value");
 
     value = json_object_get(object, "foo");
-    if(!json_is_integer(value) || json_integer_value(value) != 123)
+    if (!json_is_integer(value) || json_integer_value(value) != 123)
         fail("json_object_set_new works incorrectly");
 
-    if(!json_object_set_new(object, NULL, json_integer(432)))
+    if (!json_object_set_new(object, NULL, json_integer(432)))
         fail("able to set_new NULL key");
 
-    if(!json_object_set_new(object, "foo", NULL))
+    if (!json_object_set_new(object, "foo", NULL))
         fail("able to set_new NULL value");
 
     json_decref(string);
@@ -611,12 +577,12 @@ static void test_misc()
     json_decref(object);
 }
 
-static void test_preserve_order()
-{
+static void test_preserve_order() {
     json_t *object;
     char *result;
 
-    const char *expected = "{\"foobar\": 1, \"bazquux\": 6, \"lorem ipsum\": 3, \"sit amet\": 5, \"helicopter\": 7}";
+    const char *expected = "{\"foobar\": 1, \"bazquux\": 6, \"lorem ipsum\": "
+                           "3, \"sit amet\": 5, \"helicopter\": 7}";
 
     object = json_object();
 
@@ -637,7 +603,7 @@ static void test_preserve_order()
 
     result = json_dumps(object, JSON_PRESERVE_ORDER);
 
-    if(strcmp(expected, result) != 0) {
+    if (strcmp(expected, result) != 0) {
         fprintf(stderr, "%s != %s", expected, result);
         fail("JSON_PRESERVE_ORDER doesn't work");
     }
@@ -646,44 +612,38 @@ static void test_preserve_order()
     json_decref(object);
 }
 
-static void test_object_foreach()
-{
+static void test_object_foreach() {
     const char *key;
     json_t *object1, *object2, *value;
 
     object1 = json_pack("{sisisi}", "foo", 1, "bar", 2, "baz", 3);
     object2 = json_object();
 
-    json_object_foreach(object1, key, value)
-        json_object_set(object2, key, value);
+    json_object_foreach(object1, key, value) json_object_set(object2, key, value);
 
-    if(!json_equal(object1, object2))
+    if (!json_equal(object1, object2))
         fail("json_object_foreach failed to iterate all key-value pairs");
 
     json_decref(object1);
     json_decref(object2);
 }
 
-static void test_object_foreach_safe()
-{
+static void test_object_foreach_safe() {
     const char *key;
     void *tmp;
     json_t *object, *value;
 
     object = json_pack("{sisisi}", "foo", 1, "bar", 2, "baz", 3);
 
-    json_object_foreach_safe(object, tmp, key, value) {
-        json_object_del(object, key);
-    }
+    json_object_foreach_safe(object, tmp, key, value) { json_object_del(object, key); }
 
-    if(json_object_size(object) != 0)
+    if (json_object_size(object) != 0)
         fail("json_object_foreach_safe failed to iterate all key-value pairs");
 
     json_decref(object);
 }
 
-static void test_bad_args(void)
-{
+static void test_bad_args(void) {
     json_t *obj = json_object();
     json_t *num = json_integer(1);
     void *iter;
@@ -698,99 +658,116 @@ static void test_bad_args(void)
     if (!iter)
         fail("failed to retrieve test iterator");
 
-    if(json_object_size(NULL) != 0)
+    if (json_object_size(NULL) != 0)
         fail("json_object_size with non-object argument returned non-zero");
-    if(json_object_size(num) != 0)
+    if (json_object_size(num) != 0)
         fail("json_object_size with non-object argument returned non-zero");
 
-    if(json_object_get(NULL, "test") != NULL)
+    if (json_object_get(NULL, "test") != NULL)
         fail("json_object_get with non-object argument returned non-NULL");
-    if(json_object_get(num, "test") != NULL)
+    if (json_object_get(num, "test") != NULL)
         fail("json_object_get with non-object argument returned non-NULL");
-    if(json_object_get(obj, NULL) != NULL)
+    if (json_object_get(obj, NULL) != NULL)
         fail("json_object_get with NULL key returned non-NULL");
 
-    if(!json_object_set_new_nocheck(NULL, "test", json_null()))
-        fail("json_object_set_new_nocheck with non-object argument did not return error");
-    if(!json_object_set_new_nocheck(num, "test", json_null()))
-        fail("json_object_set_new_nocheck with non-object argument did not return error");
-    if(!json_object_set_new_nocheck(obj, "test", json_incref(obj)))
-        fail("json_object_set_new_nocheck with object == value did not return error");
-    if(!json_object_set_new_nocheck(obj, NULL, json_object()))
+    if (!json_object_set_new_nocheck(NULL, "test", json_null()))
+        fail("json_object_set_new_nocheck with non-object argument did not "
+             "return error");
+    if (!json_object_set_new_nocheck(num, "test", json_null()))
+        fail("json_object_set_new_nocheck with non-object argument did not "
+             "return error");
+    if (!json_object_set_new_nocheck(obj, "test", json_incref(obj)))
+        fail("json_object_set_new_nocheck with object == value did not return "
+             "error");
+    if (!json_object_set_new_nocheck(obj, NULL, json_object()))
         fail("json_object_set_new_nocheck with NULL key did not return error");
 
-    if(!json_object_del(NULL, "test"))
+    if (!json_object_del(NULL, "test"))
         fail("json_object_del with non-object argument did not return error");
-    if(!json_object_del(num, "test"))
+    if (!json_object_del(num, "test"))
         fail("json_object_del with non-object argument did not return error");
-    if(!json_object_del(obj, NULL))
+    if (!json_object_del(obj, NULL))
         fail("json_object_del with NULL key did not return error");
 
-    if(!json_object_clear(NULL))
+    if (!json_object_clear(NULL))
         fail("json_object_clear with non-object argument did not return error");
-    if(!json_object_clear(num))
+    if (!json_object_clear(num))
         fail("json_object_clear with non-object argument did not return error");
 
-    if(!json_object_update(NULL, obj))
-        fail("json_object_update with non-object first argument did not return error");
-    if(!json_object_update(num, obj))
-        fail("json_object_update with non-object first argument did not return error");
-    if(!json_object_update(obj, NULL))
-        fail("json_object_update with non-object second argument did not return error");
-    if(!json_object_update(obj, num))
-        fail("json_object_update with non-object second argument did not return error");
-
-    if(!json_object_update_existing(NULL, obj))
-        fail("json_object_update_existing with non-object first argument did not return error");
-    if(!json_object_update_existing(num, obj))
-        fail("json_object_update_existing with non-object first argument did not return error");
-    if(!json_object_update_existing(obj, NULL))
-        fail("json_object_update_existing with non-object second argument did not return error");
-    if(!json_object_update_existing(obj, num))
-        fail("json_object_update_existing with non-object second argument did not return error");
-
-    if(!json_object_update_missing(NULL, obj))
-        fail("json_object_update_missing with non-object first argument did not return error");
-    if(!json_object_update_missing(num, obj))
-        fail("json_object_update_missing with non-object first argument did not return error");
-    if(!json_object_update_missing(obj, NULL))
-        fail("json_object_update_missing with non-object second argument did not return error");
-    if(!json_object_update_missing(obj, num))
-        fail("json_object_update_missing with non-object second argument did not return error");
-
-    if(json_object_iter(NULL) != NULL)
+    if (!json_object_update(NULL, obj))
+        fail("json_object_update with non-object first argument did not return "
+             "error");
+    if (!json_object_update(num, obj))
+        fail("json_object_update with non-object first argument did not return "
+             "error");
+    if (!json_object_update(obj, NULL))
+        fail("json_object_update with non-object second argument did not "
+             "return error");
+    if (!json_object_update(obj, num))
+        fail("json_object_update with non-object second argument did not "
+             "return error");
+
+    if (!json_object_update_existing(NULL, obj))
+        fail("json_object_update_existing with non-object first argument did "
+             "not return error");
+    if (!json_object_update_existing(num, obj))
+        fail("json_object_update_existing with non-object first argument did "
+             "not return error");
+    if (!json_object_update_existing(obj, NULL))
+        fail("json_object_update_existing with non-object second argument did "
+             "not return error");
+    if (!json_object_update_existing(obj, num))
+        fail("json_object_update_existing with non-object second argument did "
+             "not return error");
+
+    if (!json_object_update_missing(NULL, obj))
+        fail("json_object_update_missing with non-object first argument did "
+             "not return error");
+    if (!json_object_update_missing(num, obj))
+        fail("json_object_update_missing with non-object first argument did "
+             "not return error");
+    if (!json_object_update_missing(obj, NULL))
+        fail("json_object_update_missing with non-object second argument did "
+             "not return error");
+    if (!json_object_update_missing(obj, num))
+        fail("json_object_update_missing with non-object second argument did "
+             "not return error");
+
+    if (json_object_iter(NULL) != NULL)
         fail("json_object_iter with non-object argument returned non-NULL");
-    if(json_object_iter(num) != NULL)
+    if (json_object_iter(num) != NULL)
         fail("json_object_iter with non-object argument returned non-NULL");
 
-    if(json_object_iter_at(NULL, "test") != NULL)
+    if (json_object_iter_at(NULL, "test") != NULL)
         fail("json_object_iter_at with non-object argument returned non-NULL");
-    if(json_object_iter_at(num, "test") != NULL)
+    if (json_object_iter_at(num, "test") != NULL)
         fail("json_object_iter_at with non-object argument returned non-NULL");
-    if(json_object_iter_at(obj, NULL) != NULL)
+    if (json_object_iter_at(obj, NULL) != NULL)
         fail("json_object_iter_at with NULL iter returned non-NULL");
 
-    if(json_object_iter_next(obj, NULL) != NULL)
+    if (json_object_iter_next(obj, NULL) != NULL)
         fail("json_object_iter_next with NULL iter returned non-NULL");
-    if(json_object_iter_next(num, iter) != NULL)
+    if (json_object_iter_next(num, iter) != NULL)
         fail("json_object_iter_next with non-object argument returned non-NULL");
 
-    if(json_object_iter_key(NULL) != NULL)
+    if (json_object_iter_key(NULL) != NULL)
         fail("json_object_iter_key with NULL iter returned non-NULL");
 
-    if(json_object_key_to_iter(NULL) != NULL)
+    if (json_object_key_to_iter(NULL) != NULL)
         fail("json_object_key_to_iter with NULL iter returned non-NULL");
 
-    if(json_object_iter_value(NULL) != NULL)
+    if (json_object_iter_value(NULL) != NULL)
         fail("json_object_iter_value with NULL iter returned non-NULL");
 
-    if(!json_object_iter_set_new(NULL, iter, json_incref(num)))
-        fail("json_object_iter_set_new with non-object argument did not return error");
-    if(!json_object_iter_set_new(num, iter, json_incref(num)))
-        fail("json_object_iter_set_new with non-object argument did not return error");
-    if(!json_object_iter_set_new(obj, NULL, json_incref(num)))
+    if (!json_object_iter_set_new(NULL, iter, json_incref(num)))
+        fail("json_object_iter_set_new with non-object argument did not return "
+             "error");
+    if (!json_object_iter_set_new(num, iter, json_incref(num)))
+        fail("json_object_iter_set_new with non-object argument did not return "
+             "error");
+    if (!json_object_iter_set_new(obj, NULL, json_incref(num)))
         fail("json_object_iter_set_new with NULL iter did not return error");
-    if(!json_object_iter_set_new(obj, iter, NULL))
+    if (!json_object_iter_set_new(obj, iter, NULL))
         fail("json_object_iter_set_new with NULL value did not return error");
 
     if (obj->refcount != 1)
@@ -803,8 +780,7 @@ static void test_bad_args(void)
     json_decref(num);
 }
 
-static void run_tests()
-{
+static void run_tests() {
     test_misc();
     test_clear();
     test_update();
diff --git a/test/suites/api/test_pack.c b/test/suites/api/test_pack.c
index 084f170..865f60b 100644
--- a/test/suites/api/test_pack.c
+++ b/test/suites/api/test_pack.c
@@ -12,11 +12,11 @@
 
 #include <jansson_config.h>
 
-#include <string.h>
+#include "util.h"
 #include <jansson.h>
-#include <stdio.h>
 #include <math.h>
-#include "util.h"
+#include <stdio.h>
+#include <string.h>
 
 #ifdef INFINITY
 // This test triggers "warning C4756: overflow in constant arithmetic"
@@ -24,23 +24,25 @@
 // (This can only be done on function level so we keep these tests separate)
 #ifdef _MSC_VER
 #pragma warning(push)
-#pragma warning (disable: 4756)
+#pragma warning(disable : 4756)
 #endif
-static void test_inifity()
-{
+static void test_inifity() {
     json_error_t error;
 
     if (json_pack_ex(&error, 0, "f", INFINITY))
-       fail("json_pack infinity incorrectly succeeded");
-    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, 1, 1);
+        fail("json_pack infinity incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1,
+                1, 1);
 
     if (json_pack_ex(&error, 0, "[f]", INFINITY))
-       fail("json_pack infinity array element incorrectly succeeded");
-    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, 2, 2);
+        fail("json_pack infinity array element incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1,
+                2, 2);
 
     if (json_pack_ex(&error, 0, "{s:f}", "key", INFINITY))
-       fail("json_pack infinity object value incorrectly succeeded");
-    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, 4, 4);
+        fail("json_pack infinity object value incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1,
+                4, 4);
 
 #ifdef _MSC_VER
 #pragma warning(pop)
@@ -48,8 +50,7 @@ static void test_inifity()
 }
 #endif // INFINITY
 
-static void run_tests()
-{
+static void run_tests() {
     json_t *value;
     int i;
     char buffer[4] = {'t', 'e', 's', 't'};
@@ -60,115 +61,117 @@ static void run_tests()
      */
     /* true */
     value = json_pack("b", 1);
-    if(!json_is_true(value))
+    if (!json_is_true(value))
         fail("json_pack boolean failed");
-    if(value->refcount != (size_t)-1)
+    if (value->refcount != (size_t)-1)
         fail("json_pack boolean refcount failed");
     json_decref(value);
 
     /* false */
     value = json_pack("b", 0);
-    if(!json_is_false(value))
+    if (!json_is_false(value))
         fail("json_pack boolean failed");
-    if(value->refcount != (size_t)-1)
+    if (value->refcount != (size_t)-1)
         fail("json_pack boolean refcount failed");
     json_decref(value);
 
     /* null */
     value = json_pack("n");
-    if(!json_is_null(value))
+    if (!json_is_null(value))
         fail("json_pack null failed");
-    if(value->refcount != (size_t)-1)
+    if (value->refcount != (size_t)-1)
         fail("json_pack null refcount failed");
     json_decref(value);
 
     /* integer */
     value = json_pack("i", 1);
-    if(!json_is_integer(value) || json_integer_value(value) != 1)
+    if (!json_is_integer(value) || json_integer_value(value) != 1)
         fail("json_pack integer failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack integer refcount failed");
     json_decref(value);
 
     /* integer from json_int_t */
     value = json_pack("I", (json_int_t)555555);
-    if(!json_is_integer(value) || json_integer_value(value) != 555555)
+    if (!json_is_integer(value) || json_integer_value(value) != 555555)
         fail("json_pack json_int_t failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack integer refcount failed");
     json_decref(value);
 
     /* real */
     value = json_pack("f", 1.0);
-    if(!json_is_real(value) || json_real_value(value) != 1.0)
+    if (!json_is_real(value) || json_real_value(value) != 1.0)
         fail("json_pack real failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack real refcount failed");
     json_decref(value);
 
     /* string */
     value = json_pack("s", "test");
-    if(!json_is_string(value) || strcmp("test", json_string_value(value)))
+    if (!json_is_string(value) || strcmp("test", json_string_value(value)))
         fail("json_pack string failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack string refcount failed");
     json_decref(value);
 
     /* nullable string (defined case) */
     value = json_pack("s?", "test");
-    if(!json_is_string(value) || strcmp("test", json_string_value(value)))
+    if (!json_is_string(value) || strcmp("test", json_string_value(value)))
         fail("json_pack nullable string (defined case) failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack nullable string (defined case) refcount failed");
     json_decref(value);
 
     /* nullable string (NULL case) */
     value = json_pack("s?", NULL);
-    if(!json_is_null(value))
+    if (!json_is_null(value))
         fail("json_pack nullable string (NULL case) failed");
-    if(value->refcount != (size_t)-1)
+    if (value->refcount != (size_t)-1)
         fail("json_pack nullable string (NULL case) refcount failed");
     json_decref(value);
 
     /* nullable string concatenation */
-    if(json_pack_ex(&error, 0, "s?+", "test", "ing"))
+    if (json_pack_ex(&error, 0, "s?+", "test", "ing"))
         fail("json_pack failed to catch invalid format 's?+'");
-    check_error(json_error_invalid_format, "Cannot use '+' on optional strings", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Cannot use '+' on optional strings",
+                "<format>", 1, 2, 2);
 
     /* nullable string with integer length */
-    if(json_pack_ex(&error, 0, "s?#", "test", 4))
+    if (json_pack_ex(&error, 0, "s?#", "test", 4))
         fail("json_pack failed to catch invalid format 's?#'");
-    check_error(json_error_invalid_format, "Cannot use '#' on optional strings", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Cannot use '#' on optional strings",
+                "<format>", 1, 2, 2);
 
     /* string and length (int) */
     value = json_pack("s#", "test asdf", 4);
-    if(!json_is_string(value) || strcmp("test", json_string_value(value)))
+    if (!json_is_string(value) || strcmp("test", json_string_value(value)))
         fail("json_pack string and length failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack string and length refcount failed");
     json_decref(value);
 
     /* string and length (size_t) */
     value = json_pack("s%", "test asdf", (size_t)4);
-    if(!json_is_string(value) || strcmp("test", json_string_value(value)))
+    if (!json_is_string(value) || strcmp("test", json_string_value(value)))
         fail("json_pack string and length failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack string and length refcount failed");
     json_decref(value);
 
     /* string and length (int), non-NUL terminated string */
     value = json_pack("s#", buffer, 4);
-    if(!json_is_string(value) || strcmp("test", json_string_value(value)))
+    if (!json_is_string(value) || strcmp("test", json_string_value(value)))
         fail("json_pack string and length (int) failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack string and length (int) refcount failed");
     json_decref(value);
 
     /* string and length (size_t), non-NUL terminated string */
     value = json_pack("s%", buffer, (size_t)4);
-    if(!json_is_string(value) || strcmp("test", json_string_value(value)))
+    if (!json_is_string(value) || strcmp("test", json_string_value(value)))
         fail("json_pack string and length (size_t) failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack string and length (size_t) refcount failed");
     json_decref(value);
 
@@ -177,151 +180,156 @@ static void run_tests()
         fail("json_pack string concatenation succeeded with NULL string");
 
     value = json_pack("s++", "te", "st", "ing");
-    if(!json_is_string(value) || strcmp("testing", json_string_value(value)))
+    if (!json_is_string(value) || strcmp("testing", json_string_value(value)))
         fail("json_pack string concatenation failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack string concatenation refcount failed");
     json_decref(value);
 
     /* string concatenation and length (int) */
     value = json_pack("s#+#+", "test", 1, "test", 2, "test");
-    if(!json_is_string(value) || strcmp("ttetest", json_string_value(value)))
+    if (!json_is_string(value) || strcmp("ttetest", json_string_value(value)))
         fail("json_pack string concatenation and length (int) failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack string concatenation and length (int) refcount failed");
     json_decref(value);
 
     /* string concatenation and length (size_t) */
     value = json_pack("s%+%+", "test", (size_t)1, "test", (size_t)2, "test");
-    if(!json_is_string(value) || strcmp("ttetest", json_string_value(value)))
+    if (!json_is_string(value) || strcmp("ttetest", json_string_value(value)))
         fail("json_pack string concatenation and length (size_t) failed");
-    if(value->refcount != (size_t)1)
-        fail("json_pack string concatenation and length (size_t) refcount failed");
+    if (value->refcount != (size_t)1)
+        fail("json_pack string concatenation and length (size_t) refcount "
+             "failed");
     json_decref(value);
 
     /* empty object */
     value = json_pack("{}", 1.0);
-    if(!json_is_object(value) || json_object_size(value) != 0)
+    if (!json_is_object(value) || json_object_size(value) != 0)
         fail("json_pack empty object failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack empty object refcount failed");
     json_decref(value);
 
     /* empty list */
     value = json_pack("[]", 1.0);
-    if(!json_is_array(value) || json_array_size(value) != 0)
+    if (!json_is_array(value) || json_array_size(value) != 0)
         fail("json_pack empty list failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack empty list failed");
     json_decref(value);
 
     /* non-incref'd object */
     value = json_pack("o", json_integer(1));
-    if(!json_is_integer(value) || json_integer_value(value) != 1)
+    if (!json_is_integer(value) || json_integer_value(value) != 1)
         fail("json_pack object failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack integer refcount failed");
     json_decref(value);
 
     /* non-incref'd nullable object (defined case) */
     value = json_pack("o?", json_integer(1));
-    if(!json_is_integer(value) || json_integer_value(value) != 1)
+    if (!json_is_integer(value) || json_integer_value(value) != 1)
         fail("json_pack nullable object (defined case) failed");
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack nullable object (defined case) refcount failed");
     json_decref(value);
 
     /* non-incref'd nullable object (NULL case) */
     value = json_pack("o?", NULL);
-    if(!json_is_null(value))
+    if (!json_is_null(value))
         fail("json_pack nullable object (NULL case) failed");
-    if(value->refcount != (size_t)-1)
+    if (value->refcount != (size_t)-1)
         fail("json_pack nullable object (NULL case) refcount failed");
     json_decref(value);
 
     /* incref'd object */
     value = json_pack("O", json_integer(1));
-    if(!json_is_integer(value) || json_integer_value(value) != 1)
+    if (!json_is_integer(value) || json_integer_value(value) != 1)
         fail("json_pack object failed");
-    if(value->refcount != (size_t)2)
+    if (value->refcount != (size_t)2)
         fail("json_pack integer refcount failed");
     json_decref(value);
     json_decref(value);
 
     /* incref'd nullable object (defined case) */
     value = json_pack("O?", json_integer(1));
-    if(!json_is_integer(value) || json_integer_value(value) != 1)
+    if (!json_is_integer(value) || json_integer_value(value) != 1)
         fail("json_pack incref'd nullable object (defined case) failed");
-    if(value->refcount != (size_t)2)
-        fail("json_pack incref'd nullable object (defined case) refcount failed");
+    if (value->refcount != (size_t)2)
+        fail("json_pack incref'd nullable object (defined case) refcount "
+             "failed");
     json_decref(value);
     json_decref(value);
 
     /* incref'd nullable object (NULL case) */
     value = json_pack("O?", NULL);
-    if(!json_is_null(value))
+    if (!json_is_null(value))
         fail("json_pack incref'd nullable object (NULL case) failed");
-    if(value->refcount != (size_t)-1)
+    if (value->refcount != (size_t)-1)
         fail("json_pack incref'd nullable object (NULL case) refcount failed");
 
     /* simple object */
     value = json_pack("{s:[]}", "foo");
-    if(!json_is_object(value) || json_object_size(value) != 1)
+    if (!json_is_object(value) || json_object_size(value) != 1)
         fail("json_pack array failed");
-    if(!json_is_array(json_object_get(value, "foo")))
+    if (!json_is_array(json_object_get(value, "foo")))
         fail("json_pack array failed");
-    if(json_object_get(value, "foo")->refcount != (size_t)1)
+    if (json_object_get(value, "foo")->refcount != (size_t)1)
         fail("json_pack object refcount failed");
     json_decref(value);
 
     /* object with complex key */
     value = json_pack("{s+#+: []}", "foo", "barbar", 3, "baz");
-    if(!json_is_object(value) || json_object_size(value) != 1)
+    if (!json_is_object(value) || json_object_size(value) != 1)
         fail("json_pack array failed");
-    if(!json_is_array(json_object_get(value, "foobarbaz")))
+    if (!json_is_array(json_object_get(value, "foobarbaz")))
         fail("json_pack array failed");
-    if(json_object_get(value, "foobarbaz")->refcount != (size_t)1)
+    if (json_object_get(value, "foobarbaz")->refcount != (size_t)1)
         fail("json_pack object refcount failed");
     json_decref(value);
 
     /* object with optional members */
     value = json_pack("{s:s,s:o,s:O}", "a", NULL, "b", NULL, "c", NULL);
-    if(value)
+    if (value)
         fail("json_pack object optional incorrectly succeeded");
 
     value = json_pack("{s:**}", "a", NULL);
-    if(value)
+    if (value)
         fail("json_pack object optional invalid incorrectly succeeded");
 
     if (json_pack_ex(&error, 0, "{s:i*}", "a", 1))
         fail("json_pack object optional invalid incorrectly succeeded");
-    check_error(json_error_invalid_format, "Expected format 's', got '*'", "<format>", 1, 5, 5);
+    check_error(json_error_invalid_format, "Expected format 's', got '*'", "<format>", 1,
+                5, 5);
 
     value = json_pack("{s:s*,s:o*,s:O*}", "a", NULL, "b", NULL, "c", NULL);
-    if(!json_is_object(value) || json_object_size(value) != 0)
+    if (!json_is_object(value) || json_object_size(value) != 0)
         fail("json_pack object optional failed");
     json_decref(value);
 
     value = json_pack("{s:s*}", "key", "\xff\xff");
-    if(value)
-        fail("json_pack object optional with invalid UTF-8 incorrectly succeeded");
+    if (value)
+        fail("json_pack object optional with invalid UTF-8 incorrectly "
+             "succeeded");
 
-    if(json_pack_ex(&error, 0, "{s: s*#}", "key", "test", 1))
+    if (json_pack_ex(&error, 0, "{s: s*#}", "key", "test", 1))
         fail("json_pack failed to catch invalid format 's*#'");
-    check_error(json_error_invalid_format, "Cannot use '#' on optional strings", "<format>", 1, 6, 6);
+    check_error(json_error_invalid_format, "Cannot use '#' on optional strings",
+                "<format>", 1, 6, 6);
 
-    if(json_pack_ex(&error, 0, "{s: s*+}", "key", "test", "ing"))
+    if (json_pack_ex(&error, 0, "{s: s*+}", "key", "test", "ing"))
         fail("json_pack failed to catch invalid format 's*+'");
-    check_error(json_error_invalid_format, "Cannot use '+' on optional strings", "<format>", 1, 6, 6);
+    check_error(json_error_invalid_format, "Cannot use '+' on optional strings",
+                "<format>", 1, 6, 6);
 
     /* simple array */
     value = json_pack("[i,i,i]", 0, 1, 2);
-    if(!json_is_array(value) || json_array_size(value) != 3)
+    if (!json_is_array(value) || json_array_size(value) != 3)
         fail("json_pack object failed");
-    for(i=0; i<3; i++)
-    {
-        if(!json_is_integer(json_array_get(value, i)) ||
-           json_integer_value(json_array_get(value, i)) != i)
+    for (i = 0; i < 3; i++) {
+        if (!json_is_integer(json_array_get(value, i)) ||
+            json_integer_value(json_array_get(value, i)) != i)
 
             fail("json_pack integer array failed");
     }
@@ -329,18 +337,19 @@ static void run_tests()
 
     /* simple array with optional members */
     value = json_pack("[s,o,O]", NULL, NULL, NULL);
-    if(value)
+    if (value)
         fail("json_pack array optional incorrectly succeeded");
 
     if (json_pack_ex(&error, 0, "[i*]", 1))
         fail("json_pack array optional invalid incorrectly succeeded");
-    check_error(json_error_invalid_format, "Unexpected format character '*'", "<format>", 1, 3, 3);
+    check_error(json_error_invalid_format, "Unexpected format character '*'", "<format>",
+                1, 3, 3);
 
     value = json_pack("[**]", NULL);
-    if(value)
+    if (value)
         fail("json_pack array optional invalid incorrectly succeeded");
     value = json_pack("[s*,o*,O*]", NULL, NULL, NULL);
-    if(!json_is_array(value) || json_array_size(value) != 0)
+    if (!json_is_array(value) || json_array_size(value) != 0)
         fail("json_pack array optional failed");
     json_decref(value);
 
@@ -348,15 +357,18 @@ static void run_tests()
     /* Invalid float values */
     if (json_pack_ex(&error, 0, "f", NAN))
         fail("json_pack NAN incorrectly succeeded");
-    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, 1, 1);
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1,
+                1, 1);
 
     if (json_pack_ex(&error, 0, "[f]", NAN))
-       fail("json_pack NAN array element incorrectly succeeded");
-    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, 2, 2);
+        fail("json_pack NAN array element incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1,
+                2, 2);
 
     if (json_pack_ex(&error, 0, "{s:f}", "key", NAN))
-       fail("json_pack NAN object value incorrectly succeeded");
-    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, 4, 4);
+        fail("json_pack NAN object value incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1,
+                4, 4);
 #endif
 
 #ifdef INFINITY
@@ -365,19 +377,19 @@ static void run_tests()
 
     /* Whitespace; regular string */
     value = json_pack(" s\t ", "test");
-    if(!json_is_string(value) || strcmp("test", json_string_value(value)))
+    if (!json_is_string(value) || strcmp("test", json_string_value(value)))
         fail("json_pack string (with whitespace) failed");
     json_decref(value);
 
     /* Whitespace; empty array */
     value = json_pack("[ ]");
-    if(!json_is_array(value) || json_array_size(value) != 0)
+    if (!json_is_array(value) || json_array_size(value) != 0)
         fail("json_pack empty array (with whitespace) failed");
     json_decref(value);
 
     /* Whitespace; array */
     value = json_pack("[ i , i,  i ] ", 1, 2, 3);
-    if(!json_is_array(value) || json_array_size(value) != 3)
+    if (!json_is_array(value) || json_array_size(value) != 3)
         fail("json_pack array (with whitespace) failed");
     json_decref(value);
 
@@ -386,133 +398,150 @@ static void run_tests()
      */
 
     /* newline in format string */
-    if(json_pack_ex(&error, 0, "{\n\n1"))
+    if (json_pack_ex(&error, 0, "{\n\n1"))
         fail("json_pack failed to catch invalid format '1'");
-    check_error(json_error_invalid_format, "Expected format 's', got '1'", "<format>", 3, 1, 4);
+    check_error(json_error_invalid_format, "Expected format 's', got '1'", "<format>", 3,
+                1, 4);
 
     /* mismatched open/close array/object */
-    if(json_pack_ex(&error, 0, "[}"))
+    if (json_pack_ex(&error, 0, "[}"))
         fail("json_pack failed to catch mismatched '}'");
-    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>",
+                1, 2, 2);
 
-    if(json_pack_ex(&error, 0, "{]"))
+    if (json_pack_ex(&error, 0, "{]"))
         fail("json_pack failed to catch mismatched ']'");
-    check_error(json_error_invalid_format, "Expected format 's', got ']'", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Expected format 's', got ']'", "<format>", 1,
+                2, 2);
 
     /* missing close array */
-    if(json_pack_ex(&error, 0, "["))
+    if (json_pack_ex(&error, 0, "["))
         fail("json_pack failed to catch missing ']'");
-    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>",
+                1, 2, 2);
 
     /* missing close object */
-    if(json_pack_ex(&error, 0, "{"))
+    if (json_pack_ex(&error, 0, "{"))
         fail("json_pack failed to catch missing '}'");
-    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>",
+                1, 2, 2);
 
     /* garbage after format string */
-    if(json_pack_ex(&error, 0, "[i]a", 42))
+    if (json_pack_ex(&error, 0, "[i]a", 42))
         fail("json_pack failed to catch garbage after format string");
-    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, 4, 4);
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1,
+                4, 4);
 
-    if(json_pack_ex(&error, 0, "ia", 42))
+    if (json_pack_ex(&error, 0, "ia", 42))
         fail("json_pack failed to catch garbage after format string");
-    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1,
+                2, 2);
 
     /* NULL string */
-    if(json_pack_ex(&error, 0, "s", NULL))
+    if (json_pack_ex(&error, 0, "s", NULL))
         fail("json_pack failed to catch null argument string");
     check_error(json_error_null_value, "NULL string", "<args>", 1, 1, 1);
 
     /* + on its own */
-    if(json_pack_ex(&error, 0, "+", NULL))
+    if (json_pack_ex(&error, 0, "+", NULL))
         fail("json_pack failed to a lone +");
-    check_error(json_error_invalid_format, "Unexpected format character '+'", "<format>", 1, 1, 1);
+    check_error(json_error_invalid_format, "Unexpected format character '+'", "<format>",
+                1, 1, 1);
 
     /* Empty format */
-    if(json_pack_ex(&error, 0, ""))
+    if (json_pack_ex(&error, 0, ""))
         fail("json_pack failed to catch empty format string");
-    check_error(json_error_invalid_argument, "NULL or empty format string", "<format>", -1, -1, 0);
+    check_error(json_error_invalid_argument, "NULL or empty format string", "<format>",
+                -1, -1, 0);
 
     /* NULL format */
-    if(json_pack_ex(&error, 0, NULL))
+    if (json_pack_ex(&error, 0, NULL))
         fail("json_pack failed to catch NULL format string");
-    check_error(json_error_invalid_argument, "NULL or empty format string", "<format>", -1, -1, 0);
+    check_error(json_error_invalid_argument, "NULL or empty format string", "<format>",
+                -1, -1, 0);
 
     /* NULL key */
-    if(json_pack_ex(&error, 0, "{s:i}", NULL, 1))
+    if (json_pack_ex(&error, 0, "{s:i}", NULL, 1))
         fail("json_pack failed to catch NULL key");
     check_error(json_error_null_value, "NULL object key", "<args>", 1, 2, 2);
 
     /* NULL value followed by object still steals the object's ref */
     value = json_incref(json_object());
-    if(json_pack_ex(&error, 0, "{s:s,s:o}", "badnull", NULL, "dontleak", value))
+    if (json_pack_ex(&error, 0, "{s:s,s:o}", "badnull", NULL, "dontleak", value))
         fail("json_pack failed to catch NULL value");
     check_error(json_error_null_value, "NULL string", "<args>", 1, 4, 4);
-    if(value->refcount != (size_t)1)
+    if (value->refcount != (size_t)1)
         fail("json_pack failed to steal reference after error.");
     json_decref(value);
 
     /* More complicated checks for row/columns */
-    if(json_pack_ex(&error, 0, "{ {}: s }", "foo"))
+    if (json_pack_ex(&error, 0, "{ {}: s }", "foo"))
         fail("json_pack failed to catch object as key");
-    check_error(json_error_invalid_format, "Expected format 's', got '{'", "<format>", 1, 3, 3);
+    check_error(json_error_invalid_format, "Expected format 's', got '{'", "<format>", 1,
+                3, 3);
 
     /* Complex object */
-    if(json_pack_ex(&error, 0, "{ s: {},  s:[ii{} }", "foo", "bar", 12, 13))
+    if (json_pack_ex(&error, 0, "{ s: {},  s:[ii{} }", "foo", "bar", 12, 13))
         fail("json_pack failed to catch missing ]");
-    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", 1, 19, 19);
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>",
+                1, 19, 19);
 
     /* Complex array */
-    if(json_pack_ex(&error, 0, "[[[[[   [[[[[  [[[[ }]]]] ]]]] ]]]]]"))
+    if (json_pack_ex(&error, 0, "[[[[[   [[[[[  [[[[ }]]]] ]]]] ]]]]]"))
         fail("json_pack failed to catch extra }");
-    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", 1, 21, 21);
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>",
+                1, 21, 21);
 
     /* Invalid UTF-8 in object key */
-    if(json_pack_ex(&error, 0, "{s:i}", "\xff\xff", 42))
+    if (json_pack_ex(&error, 0, "{s:i}", "\xff\xff", 42))
         fail("json_pack failed to catch invalid UTF-8 in an object key");
     check_error(json_error_invalid_utf8, "Invalid UTF-8 object key", "<args>", 1, 2, 2);
 
     /* Invalid UTF-8 in a string */
-    if(json_pack_ex(&error, 0, "{s:s}", "foo", "\xff\xff"))
+    if (json_pack_ex(&error, 0, "{s:s}", "foo", "\xff\xff"))
         fail("json_pack failed to catch invalid UTF-8 in a string");
     check_error(json_error_invalid_utf8, "Invalid UTF-8 string", "<args>", 1, 4, 4);
 
     /* Invalid UTF-8 in an optional '?' string */
-    if(json_pack_ex(&error, 0, "{s:s?}", "foo", "\xff\xff"))
-        fail("json_pack failed to catch invalid UTF-8 in an optional '?' string");
+    if (json_pack_ex(&error, 0, "{s:s?}", "foo", "\xff\xff"))
+        fail("json_pack failed to catch invalid UTF-8 in an optional '?' "
+             "string");
     check_error(json_error_invalid_utf8, "Invalid UTF-8 string", "<args>", 1, 5, 5);
 
     /* Invalid UTF-8 in an optional '*' string */
-    if(json_pack_ex(&error, 0, "{s:s*}", "foo", "\xff\xff"))
-        fail("json_pack failed to catch invalid UTF-8 in an optional '*' string");
+    if (json_pack_ex(&error, 0, "{s:s*}", "foo", "\xff\xff"))
+        fail("json_pack failed to catch invalid UTF-8 in an optional '*' "
+             "string");
     check_error(json_error_invalid_utf8, "Invalid UTF-8 string", "<args>", 1, 5, 5);
 
     /* Invalid UTF-8 in a concatenated key */
-    if(json_pack_ex(&error, 0, "{s+:i}", "\xff\xff", "concat", 42))
+    if (json_pack_ex(&error, 0, "{s+:i}", "\xff\xff", "concat", 42))
         fail("json_pack failed to catch invalid UTF-8 in an object key");
     check_error(json_error_invalid_utf8, "Invalid UTF-8 object key", "<args>", 1, 3, 3);
 
-    if(json_pack_ex(&error, 0, "{s:o}", "foo", NULL))
+    if (json_pack_ex(&error, 0, "{s:o}", "foo", NULL))
         fail("json_pack failed to catch nullable object");
     check_error(json_error_null_value, "NULL object", "<args>", 1, 4, 4);
 
-    if(json_pack_ex(&error, 0, "{s:O}", "foo", NULL))
+    if (json_pack_ex(&error, 0, "{s:O}", "foo", NULL))
         fail("json_pack failed to catch nullable incref object");
     check_error(json_error_null_value, "NULL object", "<args>", 1, 4, 4);
 
-    if(json_pack_ex(&error, 0, "{s+:o}", "foo", "bar", NULL))
+    if (json_pack_ex(&error, 0, "{s+:o}", "foo", "bar", NULL))
         fail("json_pack failed to catch non-nullable object value");
     check_error(json_error_null_value, "NULL object", "<args>", 1, 5, 5);
 
-    if(json_pack_ex(&error, 0, "[1s", "Hi"))
+    if (json_pack_ex(&error, 0, "[1s", "Hi"))
         fail("json_pack failed to catch invalid format");
-    check_error(json_error_invalid_format, "Unexpected format character '1'", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected format character '1'", "<format>",
+                1, 2, 2);
 
-    if(json_pack_ex(&error, 0, "[1s+", "Hi", "ya"))
+    if (json_pack_ex(&error, 0, "[1s+", "Hi", "ya"))
         fail("json_pack failed to catch invalid format");
-    check_error(json_error_invalid_format, "Unexpected format character '1'", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected format character '1'", "<format>",
+                1, 2, 2);
 
-    if(json_pack_ex(&error, 0, "[so]", NULL, json_object()))
+    if (json_pack_ex(&error, 0, "[so]", NULL, json_object()))
         fail("json_pack failed to catch NULL value");
     check_error(json_error_null_value, "NULL string", "<args>", 1, 2, 2);
 }
diff --git a/test/suites/api/test_simple.c b/test/suites/api/test_simple.c
index 8277187..7a3f6b7 100644
--- a/test/suites/api/test_simple.c
+++ b/test/suites/api/test_simple.c
@@ -5,54 +5,53 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
-#include <string.h>
-#include <jansson.h>
 #include "util.h"
+#include <jansson.h>
+#include <string.h>
 
-static void test_bad_args(void)
-{
+static void test_bad_args(void) {
     json_t *num = json_integer(1);
     json_t *txt = json_string("test");
 
     if (!num || !txt)
         fail("failed to allocate test objects");
 
-    if(json_string_nocheck(NULL) != NULL)
+    if (json_string_nocheck(NULL) != NULL)
         fail("json_string_nocheck with NULL argument did not return NULL");
-    if(json_stringn_nocheck(NULL, 0) != NULL)
+    if (json_stringn_nocheck(NULL, 0) != NULL)
         fail("json_stringn_nocheck with NULL argument did not return NULL");
-    if(json_string(NULL) != NULL)
+    if (json_string(NULL) != NULL)
         fail("json_string with NULL argument did not return NULL");
-    if(json_stringn(NULL, 0) != NULL)
+    if (json_stringn(NULL, 0) != NULL)
         fail("json_stringn with NULL argument did not return NULL");
 
-    if(json_string_length(NULL) != 0)
+    if (json_string_length(NULL) != 0)
         fail("json_string_length with non-string argument did not return 0");
-    if(json_string_length(num) != 0)
+    if (json_string_length(num) != 0)
         fail("json_string_length with non-string argument did not return 0");
 
-    if(json_string_value(NULL) != NULL)
+    if (json_string_value(NULL) != NULL)
         fail("json_string_value with non-string argument did not return NULL");
-    if(json_string_value(num) != NULL)
+    if (json_string_value(num) != NULL)
         fail("json_string_value with non-string argument did not return NULL");
 
-    if(!json_string_setn_nocheck(NULL, "", 0))
+    if (!json_string_setn_nocheck(NULL, "", 0))
         fail("json_string_setn with non-string argument did not return error");
-    if(!json_string_setn_nocheck(num, "", 0))
+    if (!json_string_setn_nocheck(num, "", 0))
         fail("json_string_setn with non-string argument did not return error");
-    if(!json_string_setn_nocheck(txt, NULL, 0))
+    if (!json_string_setn_nocheck(txt, NULL, 0))
         fail("json_string_setn_nocheck with NULL value did not return error");
 
-    if(!json_string_set_nocheck(txt, NULL))
+    if (!json_string_set_nocheck(txt, NULL))
         fail("json_string_set_nocheck with NULL value did not return error");
-    if(!json_string_set(txt, NULL))
+    if (!json_string_set(txt, NULL))
         fail("json_string_set with NULL value did not return error");
-    if(!json_string_setn(txt, NULL, 0))
+    if (!json_string_setn(txt, NULL, 0))
         fail("json_string_setn with NULL value did not return error");
 
-    if(num->refcount != 1)
+    if (num->refcount != 1)
         fail("unexpected reference count for num");
-    if(txt->refcount != 1)
+    if (txt->refcount != 1)
         fail("unexpected reference count for txt");
 
     json_decref(num);
@@ -60,83 +59,80 @@ static void test_bad_args(void)
 }
 
 /* Call the simple functions not covered by other tests of the public API */
-static void run_tests()
-{
+static void run_tests() {
     json_t *value;
 
     value = json_boolean(1);
-    if(!json_is_true(value))
+    if (!json_is_true(value))
         fail("json_boolean(1) failed");
     json_decref(value);
 
     value = json_boolean(-123);
-    if(!json_is_true(value))
+    if (!json_is_true(value))
         fail("json_boolean(-123) failed");
     json_decref(value);
 
     value = json_boolean(0);
-    if(!json_is_false(value))
+    if (!json_is_false(value))
         fail("json_boolean(0) failed");
-    if(json_boolean_value(value) != 0)
+    if (json_boolean_value(value) != 0)
         fail("json_boolean_value failed");
     json_decref(value);
 
-
     value = json_integer(1);
-    if(json_typeof(value) != JSON_INTEGER)
+    if (json_typeof(value) != JSON_INTEGER)
         fail("json_typeof failed");
 
-    if(json_is_object(value))
+    if (json_is_object(value))
         fail("json_is_object failed");
 
-    if(json_is_array(value))
+    if (json_is_array(value))
         fail("json_is_array failed");
 
-    if(json_is_string(value))
+    if (json_is_string(value))
         fail("json_is_string failed");
 
-    if(!json_is_integer(value))
+    if (!json_is_integer(value))
         fail("json_is_integer failed");
 
-    if(json_is_real(value))
+    if (json_is_real(value))
         fail("json_is_real failed");
 
-    if(!json_is_number(value))
+    if (!json_is_number(value))
         fail("json_is_number failed");
 
-    if(json_is_true(value))
+    if (json_is_true(value))
         fail("json_is_true failed");
 
-    if(json_is_false(value))
+    if (json_is_false(value))
         fail("json_is_false failed");
 
-    if(json_is_boolean(value))
+    if (json_is_boolean(value))
         fail("json_is_boolean failed");
 
-    if(json_is_null(value))
+    if (json_is_null(value))
         fail("json_is_null failed");
 
     json_decref(value);
 
-
     value = json_string("foo");
-    if(!value)
+    if (!value)
         fail("json_string failed");
-    if(strcmp(json_string_value(value), "foo"))
+    if (strcmp(json_string_value(value), "foo"))
         fail("invalid string value");
     if (json_string_length(value) != 3)
         fail("invalid string length");
 
-    if(json_string_set(value, "barr"))
+    if (json_string_set(value, "barr"))
         fail("json_string_set failed");
-    if(strcmp(json_string_value(value), "barr"))
+    if (strcmp(json_string_value(value), "barr"))
         fail("invalid string value");
     if (json_string_length(value) != 4)
         fail("invalid string length");
 
-    if(json_string_setn(value, "hi\0ho", 5))
+    if (json_string_setn(value, "hi\0ho", 5))
         fail("json_string_set failed");
-    if(memcmp(json_string_value(value), "hi\0ho\0", 6))
+    if (memcmp(json_string_value(value), "hi\0ho\0", 6))
         fail("invalid string value");
     if (json_string_length(value) != 5)
         fail("invalid string length");
@@ -144,32 +140,32 @@ static void run_tests()
     json_decref(value);
 
     value = json_string(NULL);
-    if(value)
+    if (value)
         fail("json_string(NULL) failed");
 
     /* invalid UTF-8  */
     value = json_string("a\xefz");
-    if(value)
+    if (value)
         fail("json_string(<invalid utf-8>) failed");
 
     value = json_string_nocheck("foo");
-    if(!value)
+    if (!value)
         fail("json_string_nocheck failed");
-    if(strcmp(json_string_value(value), "foo"))
+    if (strcmp(json_string_value(value), "foo"))
         fail("invalid string value");
     if (json_string_length(value) != 3)
         fail("invalid string length");
 
-    if(json_string_set_nocheck(value, "barr"))
+    if (json_string_set_nocheck(value, "barr"))
         fail("json_string_set_nocheck failed");
-    if(strcmp(json_string_value(value), "barr"))
+    if (strcmp(json_string_value(value), "barr"))
         fail("invalid string value");
     if (json_string_length(value) != 4)
         fail("invalid string length");
 
-    if(json_string_setn_nocheck(value, "hi\0ho", 5))
+    if (json_string_setn_nocheck(value, "hi\0ho", 5))
         fail("json_string_set failed");
-    if(memcmp(json_string_value(value), "hi\0ho\0", 6))
+    if (memcmp(json_string_value(value), "hi\0ho\0", 6))
         fail("invalid string value");
     if (json_string_length(value) != 5)
         fail("invalid string length");
@@ -178,113 +174,112 @@ static void run_tests()
 
     /* invalid UTF-8 */
     value = json_string_nocheck("qu\xff");
-    if(!value)
+    if (!value)
         fail("json_string_nocheck failed");
-    if(strcmp(json_string_value(value), "qu\xff"))
+    if (strcmp(json_string_value(value), "qu\xff"))
         fail("invalid string value");
     if (json_string_length(value) != 3)
         fail("invalid string length");
 
-    if(json_string_set_nocheck(value, "\xfd\xfe\xff"))
+    if (json_string_set_nocheck(value, "\xfd\xfe\xff"))
         fail("json_string_set_nocheck failed");
-    if(strcmp(json_string_value(value), "\xfd\xfe\xff"))
+    if (strcmp(json_string_value(value), "\xfd\xfe\xff"))
         fail("invalid string value");
     if (json_string_length(value) != 3)
         fail("invalid string length");
 
     json_decref(value);
 
-
     value = json_integer(123);
-    if(!value)
+    if (!value)
         fail("json_integer failed");
-    if(json_integer_value(value) != 123)
+    if (json_integer_value(value) != 123)
         fail("invalid integer value");
-    if(json_number_value(value) != 123.0)
+    if (json_number_value(value) != 123.0)
         fail("invalid number value");
 
-    if(json_integer_set(value, 321))
+    if (json_integer_set(value, 321))
         fail("json_integer_set failed");
-    if(json_integer_value(value) != 321)
+    if (json_integer_value(value) != 321)
         fail("invalid integer value");
-    if(json_number_value(value) != 321.0)
+    if (json_number_value(value) != 321.0)
         fail("invalid number value");
 
     json_decref(value);
 
     value = json_real(123.123);
-    if(!value)
+    if (!value)
         fail("json_real failed");
-    if(json_real_value(value) != 123.123)
+    if (json_real_value(value) != 123.123)
         fail("invalid integer value");
-    if(json_number_value(value) != 123.123)
+    if (json_number_value(value) != 123.123)
         fail("invalid number value");
 
-    if(json_real_set(value, 321.321))
+    if (json_real_set(value, 321.321))
         fail("json_real_set failed");
-    if(json_real_value(value) != 321.321)
+    if (json_real_value(value) != 321.321)
         fail("invalid real value");
-    if(json_number_value(value) != 321.321)
+    if (json_number_value(value) != 321.321)
         fail("invalid number value");
 
     json_decref(value);
 
     value = json_true();
-    if(!value)
+    if (!value)
         fail("json_true failed");
     json_decref(value);
 
     value = json_false();
-    if(!value)
+    if (!value)
         fail("json_false failed");
     json_decref(value);
 
     value = json_null();
-    if(!value)
+    if (!value)
         fail("json_null failed");
     json_decref(value);
 
     /* Test reference counting on singletons (true, false, null) */
     value = json_true();
-    if(value->refcount != (size_t)-1)
-      fail("refcounting true works incorrectly");
+    if (value->refcount != (size_t)-1)
+        fail("refcounting true works incorrectly");
     json_decref(value);
-    if(value->refcount != (size_t)-1)
-      fail("refcounting true works incorrectly");
+    if (value->refcount != (size_t)-1)
+        fail("refcounting true works incorrectly");
     json_incref(value);
-    if(value->refcount != (size_t)-1)
-      fail("refcounting true works incorrectly");
+    if (value->refcount != (size_t)-1)
+        fail("refcounting true works incorrectly");
 
     value = json_false();
-    if(value->refcount != (size_t)-1)
-      fail("refcounting false works incorrectly");
+    if (value->refcount != (size_t)-1)
+        fail("refcounting false works incorrectly");
     json_decref(value);
-    if(value->refcount != (size_t)-1)
-      fail("refcounting false works incorrectly");
+    if (value->refcount != (size_t)-1)
+        fail("refcounting false works incorrectly");
     json_incref(value);
-    if(value->refcount != (size_t)-1)
-      fail("refcounting false works incorrectly");
+    if (value->refcount != (size_t)-1)
+        fail("refcounting false works incorrectly");
 
     value = json_null();
-    if(value->refcount != (size_t)-1)
-      fail("refcounting null works incorrectly");
+    if (value->refcount != (size_t)-1)
+        fail("refcounting null works incorrectly");
     json_decref(value);
-    if(value->refcount != (size_t)-1)
-      fail("refcounting null works incorrectly");
+    if (value->refcount != (size_t)-1)
+        fail("refcounting null works incorrectly");
     json_incref(value);
-    if(value->refcount != (size_t)-1)
-      fail("refcounting null works incorrectly");
+    if (value->refcount != (size_t)-1)
+        fail("refcounting null works incorrectly");
 
 #ifdef json_auto_t
     value = json_string("foo");
     {
         json_auto_t *test = json_incref(value);
         /* Use test so GCC doesn't complain it is unused. */
-        if(!json_is_string(test))
+        if (!json_is_string(test))
             fail("value type check failed");
     }
-    if(value->refcount != 1)
-	fail("automatic decrement failed");
+    if (value->refcount != 1)
+        fail("automatic decrement failed");
     json_decref(value);
 #endif
 
diff --git a/test/suites/api/test_sprintf.c b/test/suites/api/test_sprintf.c
index c0a4cf7..60a0b60 100644
--- a/test/suites/api/test_sprintf.c
+++ b/test/suites/api/test_sprintf.c
@@ -1,7 +1,6 @@
-#include <string.h>
-#include <jansson.h>
 #include "util.h"
-
+#include <jansson.h>
+#include <string.h>
 
 static void test_sprintf() {
     json_t *s = json_sprintf("foo bar %d", 42);
@@ -27,8 +26,4 @@ static void test_sprintf() {
         fail("json_sprintf unexpected success with invalid UTF");
 }
 
-
-static void run_tests()
-{
-    test_sprintf();
-}
+static void run_tests() { test_sprintf(); }
diff --git a/test/suites/api/test_unpack.c b/test/suites/api/test_unpack.c
index 4516917..139ec6f 100644
--- a/test/suites/api/test_unpack.c
+++ b/test/suites/api/test_unpack.c
@@ -6,13 +6,12 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
-#include <string.h>
+#include "util.h"
 #include <jansson.h>
 #include <stdio.h>
-#include "util.h"
+#include <string.h>
 
-static void run_tests()
-{
+static void run_tests() {
     json_t *j, *j2;
     int i1, i2, i3;
     json_int_t I1;
@@ -29,89 +28,89 @@ static void run_tests()
 
     /* true */
     rv = json_unpack(json_true(), "b", &i1);
-    if(rv || !i1)
+    if (rv || !i1)
         fail("json_unpack boolean failed");
 
     /* false */
     rv = json_unpack(json_false(), "b", &i1);
-    if(rv || i1)
+    if (rv || i1)
         fail("json_unpack boolean failed");
 
     /* null */
-    if(json_unpack(json_null(), "n"))
+    if (json_unpack(json_null(), "n"))
         fail("json_unpack null failed");
 
     /* integer */
     j = json_integer(42);
     rv = json_unpack(j, "i", &i1);
-    if(rv || i1 != 42)
+    if (rv || i1 != 42)
         fail("json_unpack integer failed");
     json_decref(j);
 
     /* json_int_t */
     j = json_integer(5555555);
     rv = json_unpack(j, "I", &I1);
-    if(rv || I1 != 5555555)
+    if (rv || I1 != 5555555)
         fail("json_unpack json_int_t failed");
     json_decref(j);
 
     /* real */
     j = json_real(1.7);
     rv = json_unpack(j, "f", &f);
-    if(rv || f != 1.7)
+    if (rv || f != 1.7)
         fail("json_unpack real failed");
     json_decref(j);
 
     /* number */
     j = json_integer(12345);
     rv = json_unpack(j, "F", &f);
-    if(rv || f != 12345.0)
+    if (rv || f != 12345.0)
         fail("json_unpack (real or) integer failed");
     json_decref(j);
 
     j = json_real(1.7);
     rv = json_unpack(j, "F", &f);
-    if(rv || f != 1.7)
+    if (rv || f != 1.7)
         fail("json_unpack real (or integer) failed");
     json_decref(j);
 
     /* string */
     j = json_string("foo");
     rv = json_unpack(j, "s", &s);
-    if(rv || strcmp(s, "foo"))
+    if (rv || strcmp(s, "foo"))
         fail("json_unpack string failed");
     json_decref(j);
 
     /* string with length (size_t) */
     j = json_string("foo");
     rv = json_unpack(j, "s%", &s, &z);
-    if(rv || strcmp(s, "foo") || z != 3)
+    if (rv || strcmp(s, "foo") || z != 3)
         fail("json_unpack string with length (size_t) failed");
     json_decref(j);
 
     /* empty object */
     j = json_object();
-    if(json_unpack(j, "{}"))
+    if (json_unpack(j, "{}"))
         fail("json_unpack empty object failed");
     json_decref(j);
 
     /* empty list */
     j = json_array();
-    if(json_unpack(j, "[]"))
+    if (json_unpack(j, "[]"))
         fail("json_unpack empty list failed");
     json_decref(j);
 
     /* non-incref'd object */
     j = json_object();
     rv = json_unpack(j, "o", &j2);
-    if(rv || j2 != j || j->refcount != 1)
+    if (rv || j2 != j || j->refcount != 1)
         fail("json_unpack object failed");
     json_decref(j);
 
     /* incref'd object */
     j = json_object();
     rv = json_unpack(j, "O", &j2);
-    if(rv || j2 != j || j->refcount != 2)
+    if (rv || j2 != j || j->refcount != 2)
         fail("json_unpack object failed");
     json_decref(j);
     json_decref(j);
@@ -119,21 +118,21 @@ static void run_tests()
     /* simple object */
     j = json_pack("{s:i}", "foo", 42);
     rv = json_unpack(j, "{s:i}", "foo", &i1);
-    if(rv || i1 != 42)
+    if (rv || i1 != 42)
         fail("json_unpack simple object failed");
     json_decref(j);
 
     /* simple array */
     j = json_pack("[iii]", 1, 2, 3);
     rv = json_unpack(j, "[i,i,i]", &i1, &i2, &i3);
-    if(rv || i1 != 1 || i2 != 2 || i3 != 3)
+    if (rv || i1 != 1 || i2 != 2 || i3 != 3)
         fail("json_unpack simple array failed");
     json_decref(j);
 
     /* object with many items & strict checking */
     j = json_pack("{s:i, s:i, s:i}", "a", 1, "b", 2, "c", 3);
     rv = json_unpack(j, "{s:i, s:i, s:i}", "a", &i1, "b", &i2, "c", &i3);
-    if(rv || i1 != 1 || i2 != 2 || i3 != 3)
+    if (rv || i1 != 1 || i2 != 2 || i3 != 3)
         fail("json_unpack object with many items failed");
     json_decref(j);
 
@@ -142,65 +141,73 @@ static void run_tests()
      */
 
     j = json_integer(42);
-    if(!json_unpack_ex(j, &error, 0, "z"))
+    if (!json_unpack_ex(j, &error, 0, "z"))
         fail("json_unpack succeeded with invalid format character");
-    check_error(json_error_invalid_format, "Unexpected format character 'z'", "<format>", 1, 1, 1);
+    check_error(json_error_invalid_format, "Unexpected format character 'z'", "<format>",
+                1, 1, 1);
 
-    if(!json_unpack_ex(NULL, &error, 0, "[i]"))
+    if (!json_unpack_ex(NULL, &error, 0, "[i]"))
         fail("json_unpack succeeded with NULL root");
     check_error(json_error_null_value, "NULL root value", "<root>", -1, -1, 0);
     json_decref(j);
 
     /* mismatched open/close array/object */
     j = json_pack("[]");
-    if(!json_unpack_ex(j, &error, 0, "[}"))
+    if (!json_unpack_ex(j, &error, 0, "[}"))
         fail("json_unpack failed to catch mismatched ']'");
-    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>",
+                1, 2, 2);
     json_decref(j);
 
     j = json_pack("{}");
-    if(!json_unpack_ex(j, &error, 0, "{]"))
+    if (!json_unpack_ex(j, &error, 0, "{]"))
         fail("json_unpack failed to catch mismatched '}'");
-    check_error(json_error_invalid_format, "Expected format 's', got ']'", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Expected format 's', got ']'", "<format>", 1,
+                2, 2);
     json_decref(j);
 
     /* missing close array */
     j = json_pack("[]");
-    if(!json_unpack_ex(j, &error, 0, "["))
+    if (!json_unpack_ex(j, &error, 0, "["))
         fail("json_unpack failed to catch missing ']'");
-    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>",
+                1, 2, 2);
     json_decref(j);
 
     /* missing close object */
     j = json_pack("{}");
-    if(!json_unpack_ex(j, &error, 0, "{"))
+    if (!json_unpack_ex(j, &error, 0, "{"))
         fail("json_unpack failed to catch missing '}'");
-    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>",
+                1, 2, 2);
     json_decref(j);
 
     /* garbage after format string */
     j = json_pack("[i]", 42);
-    if(!json_unpack_ex(j, &error, 0, "[i]a", &i1))
+    if (!json_unpack_ex(j, &error, 0, "[i]a", &i1))
         fail("json_unpack failed to catch garbage after format string");
-    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, 4, 4);
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1,
+                4, 4);
     json_decref(j);
 
     j = json_integer(12345);
-    if(!json_unpack_ex(j, &error, 0, "ia", &i1))
+    if (!json_unpack_ex(j, &error, 0, "ia", &i1))
         fail("json_unpack failed to catch garbage after format string");
-    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1,
+                2, 2);
     json_decref(j);
 
     /* NULL format string */
     j = json_pack("[]");
-    if(!json_unpack_ex(j, &error, 0, NULL))
+    if (!json_unpack_ex(j, &error, 0, NULL))
         fail("json_unpack failed to catch null format string");
-    check_error(json_error_invalid_argument, "NULL or empty format string", "<format>", -1, -1, 0);
+    check_error(json_error_invalid_argument, "NULL or empty format string", "<format>",
+                -1, -1, 0);
     json_decref(j);
 
     /* NULL string pointer */
     j = json_string("foobie");
-    if(!json_unpack_ex(j, &error, 0, "s", NULL))
+    if (!json_unpack_ex(j, &error, 0, "s", NULL))
         fail("json_unpack failed to catch null string pointer");
     check_error(json_error_null_value, "NULL string argument", "<args>", 1, 1, 1);
     json_decref(j);
@@ -208,64 +215,75 @@ static void run_tests()
     /* invalid types */
     j = json_integer(42);
     j2 = json_string("foo");
-    if(!json_unpack_ex(j, &error, 0, "s"))
+    if (!json_unpack_ex(j, &error, 0, "s"))
         fail("json_unpack failed to catch invalid type");
-    check_error(json_error_wrong_type, "Expected string, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected string, got integer", "<validation>", 1,
+                1, 1);
 
-    if(!json_unpack_ex(j, &error, 0, "n"))
+    if (!json_unpack_ex(j, &error, 0, "n"))
         fail("json_unpack failed to catch invalid type");
-    check_error(json_error_wrong_type, "Expected null, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected null, got integer", "<validation>", 1, 1,
+                1);
 
-    if(!json_unpack_ex(j, &error, 0, "b"))
+    if (!json_unpack_ex(j, &error, 0, "b"))
         fail("json_unpack failed to catch invalid type");
-    check_error(json_error_wrong_type, "Expected true or false, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected true or false, got integer",
+                "<validation>", 1, 1, 1);
 
-    if(!json_unpack_ex(j2, &error, 0, "i"))
+    if (!json_unpack_ex(j2, &error, 0, "i"))
         fail("json_unpack failed to catch invalid type");
-    check_error(json_error_wrong_type, "Expected integer, got string", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected integer, got string", "<validation>", 1,
+                1, 1);
 
-    if(!json_unpack_ex(j2, &error, 0, "I"))
+    if (!json_unpack_ex(j2, &error, 0, "I"))
         fail("json_unpack failed to catch invalid type");
-    check_error(json_error_wrong_type, "Expected integer, got string", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected integer, got string", "<validation>", 1,
+                1, 1);
 
-    if(!json_unpack_ex(j, &error, 0, "f"))
+    if (!json_unpack_ex(j, &error, 0, "f"))
         fail("json_unpack failed to catch invalid type");
-    check_error(json_error_wrong_type, "Expected real, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected real, got integer", "<validation>", 1, 1,
+                1);
 
-    if(!json_unpack_ex(j2, &error, 0, "F"))
+    if (!json_unpack_ex(j2, &error, 0, "F"))
         fail("json_unpack failed to catch invalid type");
-    check_error(json_error_wrong_type, "Expected real or integer, got string", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected real or integer, got string",
+                "<validation>", 1, 1, 1);
 
-    if(!json_unpack_ex(j, &error, 0, "[i]"))
+    if (!json_unpack_ex(j, &error, 0, "[i]"))
         fail("json_unpack failed to catch invalid type");
-    check_error(json_error_wrong_type, "Expected array, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected array, got integer", "<validation>", 1,
+                1, 1);
 
-    if(!json_unpack_ex(j, &error, 0, "{si}", "foo"))
+    if (!json_unpack_ex(j, &error, 0, "{si}", "foo"))
         fail("json_unpack failed to catch invalid type");
-    check_error(json_error_wrong_type, "Expected object, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected object, got integer", "<validation>", 1,
+                1, 1);
 
     json_decref(j);
     json_decref(j2);
 
     /* Array index out of range */
     j = json_pack("[i]", 1);
-    if(!json_unpack_ex(j, &error, 0, "[ii]", &i1, &i2))
+    if (!json_unpack_ex(j, &error, 0, "[ii]", &i1, &i2))
         fail("json_unpack failed to catch index out of array bounds");
-    check_error(json_error_index_out_of_range, "Array index 1 out of range", "<validation>", 1, 3, 3);
+    check_error(json_error_index_out_of_range, "Array index 1 out of range",
+                "<validation>", 1, 3, 3);
     json_decref(j);
 
     /* NULL object key */
     j = json_pack("{si}", "foo", 42);
-    if(!json_unpack_ex(j, &error, 0, "{si}", NULL, &i1))
+    if (!json_unpack_ex(j, &error, 0, "{si}", NULL, &i1))
         fail("json_unpack failed to catch null string pointer");
     check_error(json_error_null_value, "NULL object key", "<args>", 1, 2, 2);
     json_decref(j);
 
     /* Object key not found */
     j = json_pack("{si}", "foo", 42);
-    if(!json_unpack_ex(j, &error, 0, "{si}", "baz", &i1))
+    if (!json_unpack_ex(j, &error, 0, "{si}", "baz", &i1))
         fail("json_unpack failed to catch null string pointer");
-    check_error(json_error_item_not_found, "Object item not found: baz", "<validation>", 1, 3, 3);
+    check_error(json_error_item_not_found, "Object item not found: baz", "<validation>",
+                1, 3, 3);
     json_decref(j);
 
     /*
@@ -274,133 +292,140 @@ static void run_tests()
 
     j = json_pack("[iii]", 1, 2, 3);
     rv = json_unpack(j, "[iii!]", &i1, &i2, &i3);
-    if(rv || i1 != 1 || i2 != 2 || i3 != 3)
+    if (rv || i1 != 1 || i2 != 2 || i3 != 3)
         fail("json_unpack array with strict validation failed");
     json_decref(j);
 
     j = json_pack("[iii]", 1, 2, 3);
-    if(!json_unpack_ex(j, &error, 0, "[ii!]", &i1, &i2))
+    if (!json_unpack_ex(j, &error, 0, "[ii!]", &i1, &i2))
         fail("json_unpack array with strict validation failed");
-    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", "<validation>", 1, 5, 5);
+    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked",
+                "<validation>", 1, 5, 5);
     json_decref(j);
 
     /* Like above, but with JSON_STRICT instead of '!' format */
     j = json_pack("[iii]", 1, 2, 3);
-    if(!json_unpack_ex(j, &error, JSON_STRICT, "[ii]", &i1, &i2))
+    if (!json_unpack_ex(j, &error, JSON_STRICT, "[ii]", &i1, &i2))
         fail("json_unpack array with strict validation failed");
-    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", "<validation>", 1, 4, 4);
+    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked",
+                "<validation>", 1, 4, 4);
     json_decref(j);
 
     j = json_pack("{s:s, s:i}", "foo", "bar", "baz", 42);
     rv = json_unpack(j, "{sssi!}", "foo", &s, "baz", &i1);
-    if(rv || strcmp(s, "bar") != 0 || i1 != 42)
+    if (rv || strcmp(s, "bar") != 0 || i1 != 42)
         fail("json_unpack object with strict validation failed");
     json_decref(j);
 
     /* Unpack the same item twice */
     j = json_pack("{s:s, s:i, s:b}", "foo", "bar", "baz", 42, "quux", 1);
-    if(!json_unpack_ex(j, &error, 0, "{s:s,s:s!}", "foo", &s, "foo", &s))
+    if (!json_unpack_ex(j, &error, 0, "{s:s,s:s!}", "foo", &s, "foo", &s))
         fail("json_unpack object with strict validation failed");
     {
-        const char *possible_errors[] = {
-            "2 object item(s) left unpacked: baz, quux",
-            "2 object item(s) left unpacked: quux, baz"
-        };
-        check_errors(json_error_end_of_input_expected, possible_errors, 2, "<validation>", 1, 10, 10);
+        const char *possible_errors[] = {"2 object item(s) left unpacked: baz, quux",
+                                         "2 object item(s) left unpacked: quux, baz"};
+        check_errors(json_error_end_of_input_expected, possible_errors, 2, "<validation>",
+                     1, 10, 10);
     }
     json_decref(j);
 
     j = json_pack("[i,{s:i,s:n},[i,i]]", 1, "foo", 2, "bar", 3, 4);
-    if(json_unpack_ex(j, NULL, JSON_STRICT | JSON_VALIDATE_ONLY,
-                      "[i{sisn}[ii]]", "foo", "bar"))
+    if (json_unpack_ex(j, NULL, JSON_STRICT | JSON_VALIDATE_ONLY, "[i{sisn}[ii]]", "foo",
+                       "bar"))
         fail("json_unpack complex value with strict validation failed");
     json_decref(j);
 
     /* ! and * must be last */
     j = json_pack("[ii]", 1, 2);
-    if(!json_unpack_ex(j, &error, 0, "[i!i]", &i1, &i2))
+    if (!json_unpack_ex(j, &error, 0, "[i!i]", &i1, &i2))
         fail("json_unpack failed to catch ! in the middle of an array");
-    check_error(json_error_invalid_format, "Expected ']' after '!', got 'i'", "<format>", 1, 4, 4);
+    check_error(json_error_invalid_format, "Expected ']' after '!', got 'i'", "<format>",
+                1, 4, 4);
 
-    if(!json_unpack_ex(j, &error, 0, "[i*i]", &i1, &i2))
+    if (!json_unpack_ex(j, &error, 0, "[i*i]", &i1, &i2))
         fail("json_unpack failed to catch * in the middle of an array");
-    check_error(json_error_invalid_format, "Expected ']' after '*', got 'i'", "<format>", 1, 4, 4);
+    check_error(json_error_invalid_format, "Expected ']' after '*', got 'i'", "<format>",
+                1, 4, 4);
     json_decref(j);
 
     j = json_pack("{sssi}", "foo", "bar", "baz", 42);
-    if(!json_unpack_ex(j, &error, 0, "{ss!si}", "foo", &s, "baz", &i1))
+    if (!json_unpack_ex(j, &error, 0, "{ss!si}", "foo", &s, "baz", &i1))
         fail("json_unpack failed to catch ! in the middle of an object");
-    check_error(json_error_invalid_format, "Expected '}' after '!', got 's'", "<format>", 1, 5, 5);
+    check_error(json_error_invalid_format, "Expected '}' after '!', got 's'", "<format>",
+                1, 5, 5);
 
-    if(!json_unpack_ex(j, &error, 0, "{ss*si}", "foo", &s, "baz", &i1))
+    if (!json_unpack_ex(j, &error, 0, "{ss*si}", "foo", &s, "baz", &i1))
         fail("json_unpack failed to catch ! in the middle of an object");
-    check_error(json_error_invalid_format, "Expected '}' after '*', got 's'", "<format>", 1, 5, 5);
+    check_error(json_error_invalid_format, "Expected '}' after '*', got 's'", "<format>",
+                1, 5, 5);
     json_decref(j);
 
     /* Error in nested object */
     j = json_pack("{s{snsn}}", "foo", "bar", "baz");
-    if(!json_unpack_ex(j, &error, 0, "{s{sn!}}", "foo", "bar"))
+    if (!json_unpack_ex(j, &error, 0, "{s{sn!}}", "foo", "bar"))
         fail("json_unpack nested object with strict validation failed");
-    check_error(json_error_end_of_input_expected, "1 object item(s) left unpacked: baz", "<validation>", 1, 7, 7);
+    check_error(json_error_end_of_input_expected, "1 object item(s) left unpacked: baz",
+                "<validation>", 1, 7, 7);
     json_decref(j);
 
     /* Error in nested array */
     j = json_pack("[[ii]]", 1, 2);
-    if(!json_unpack_ex(j, &error, 0, "[[i!]]", &i1))
+    if (!json_unpack_ex(j, &error, 0, "[[i!]]", &i1))
         fail("json_unpack nested array with strict validation failed");
-    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", "<validation>", 1, 5, 5);
+    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked",
+                "<validation>", 1, 5, 5);
     json_decref(j);
 
     /* Optional values */
     j = json_object();
     i1 = 0;
-    if(json_unpack(j, "{s?i}", "foo", &i1))
+    if (json_unpack(j, "{s?i}", "foo", &i1))
         fail("json_unpack failed for optional key");
-    if(i1 != 0)
+    if (i1 != 0)
         fail("json_unpack unpacked an optional key");
     json_decref(j);
 
     i1 = 0;
     j = json_pack("{si}", "foo", 42);
-    if(json_unpack(j, "{s?i}", "foo", &i1))
+    if (json_unpack(j, "{s?i}", "foo", &i1))
         fail("json_unpack failed for an optional value");
-    if(i1 != 42)
+    if (i1 != 42)
         fail("json_unpack failed to unpack an optional value");
     json_decref(j);
 
     j = json_object();
     i1 = i2 = i3 = 0;
-    if(json_unpack(j, "{s?[ii]s?{s{si}}}",
-                   "foo", &i1, &i2,
-                   "bar", "baz", "quux", &i3))
+    if (json_unpack(j, "{s?[ii]s?{s{si}}}", "foo", &i1, &i2, "bar", "baz", "quux", &i3))
         fail("json_unpack failed for complex optional values");
-    if(i1 != 0 || i2 != 0 || i3 != 0)
+    if (i1 != 0 || i2 != 0 || i3 != 0)
         fail("json_unpack unexpectedly unpacked something");
     json_decref(j);
 
     j = json_pack("{s{si}}", "foo", "bar", 42);
-    if(json_unpack(j, "{s?{s?i}}", "foo", "bar", &i1))
+    if (json_unpack(j, "{s?{s?i}}", "foo", "bar", &i1))
         fail("json_unpack failed for complex optional values");
-    if(i1 != 42)
+    if (i1 != 42)
         fail("json_unpack failed to unpack");
     json_decref(j);
 
     /* Combine ? and ! */
     j = json_pack("{si}", "foo", 42);
     i1 = i2 = 0;
-    if(json_unpack(j, "{sis?i!}", "foo", &i1, "bar", &i2))
+    if (json_unpack(j, "{sis?i!}", "foo", &i1, "bar", &i2))
         fail("json_unpack failed for optional values with strict mode");
-    if(i1 != 42)
+    if (i1 != 42)
         fail("json_unpack failed to unpack");
-    if(i2 != 0)
+    if (i2 != 0)
         fail("json_unpack failed to unpack");
     json_decref(j);
 
     /* But don't compensate a missing key with an optional one. */
     j = json_pack("{sisi}", "foo", 42, "baz", 43);
     i1 = i2 = i3 = 0;
-    if(!json_unpack_ex(j, &error, 0, "{sis?i!}", "foo", &i1, "bar", &i2))
-        fail("json_unpack failed for optional values with strict mode and compensation");
-    check_error(json_error_end_of_input_expected, "1 object item(s) left unpacked: baz", "<validation>", 1, 8, 8);
+    if (!json_unpack_ex(j, &error, 0, "{sis?i!}", "foo", &i1, "bar", &i2))
+        fail("json_unpack failed for optional values with strict mode and "
+             "compensation");
+    check_error(json_error_end_of_input_expected, "1 object item(s) left unpacked: baz",
+                "<validation>", 1, 8, 8);
     json_decref(j);
 }
diff --git a/test/suites/api/test_version.c b/test/suites/api/test_version.c
index 73c406c..05e0e96 100644
--- a/test/suites/api/test_version.c
+++ b/test/suites/api/test_version.c
@@ -5,20 +5,19 @@
  * it under the terms of the MIT license. See LICENSE for details.
  */
 
-#include <string.h>
-#include <jansson.h>
 #include "util.h"
+#include <jansson.h>
+#include <string.h>
 
-static void test_version_str(void)
-{
+static void test_version_str(void) {
     if (strcmp(jansson_version_str(), JANSSON_VERSION)) {
         fail("jansson_version_str returned invalid version string");
     }
 }
 
-static void test_version_cmp()
-{
-    if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION, JANSSON_MICRO_VERSION)) {
+static void test_version_cmp() {
+    if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION,
+                            JANSSON_MICRO_VERSION)) {
         fail("jansson_version_cmp equality check failed");
     }
 
@@ -27,32 +26,36 @@ static void test_version_cmp()
     }
 
     if (JANSSON_MINOR_VERSION) {
-        if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION - 1, JANSSON_MICRO_VERSION) <= 0) {
+        if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION - 1,
+                                JANSSON_MICRO_VERSION) <= 0) {
             fail("jansson_version_cmp less than check failed");
         }
     }
 
     if (JANSSON_MICRO_VERSION) {
-        if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION, JANSSON_MICRO_VERSION - 1) <= 0) {
+        if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION,
+                                JANSSON_MICRO_VERSION - 1) <= 0) {
             fail("jansson_version_cmp less than check failed");
         }
     }
 
-    if (jansson_version_cmp(JANSSON_MAJOR_VERSION + 1, JANSSON_MINOR_VERSION, JANSSON_MICRO_VERSION) >= 0) {
+    if (jansson_version_cmp(JANSSON_MAJOR_VERSION + 1, JANSSON_MINOR_VERSION,
+                            JANSSON_MICRO_VERSION) >= 0) {
         fail("jansson_version_cmp greater than check failed");
     }
 
-    if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION + 1, JANSSON_MICRO_VERSION) >= 0) {
+    if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION + 1,
+                            JANSSON_MICRO_VERSION) >= 0) {
         fail("jansson_version_cmp greater than check failed");
     }
 
-    if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION, JANSSON_MICRO_VERSION + 1) >= 0) {
+    if (jansson_version_cmp(JANSSON_MAJOR_VERSION, JANSSON_MINOR_VERSION,
+                            JANSSON_MICRO_VERSION + 1) >= 0) {
         fail("jansson_version_cmp greater than check failed");
     }
 }
 
-static void run_tests()
-{
+static void run_tests() {
     test_version_str();
     test_version_cmp();
 }
diff --git a/test/suites/api/util.h b/test/suites/api/util.h
index 9b658e7..d964c49 100644
--- a/test/suites/api/util.h
+++ b/test/suites/api/util.h
@@ -22,68 +22,64 @@
 
 #define failhdr fprintf(stderr, "%s:%d: ", __FILE__, __LINE__)
 
-#define fail(msg)                                                \
-    do {                                                         \
-        failhdr;                                                 \
-        fprintf(stderr, "%s\n", msg);                            \
-        exit(1);                                                 \
-    } while(0)
+#define fail(msg)                                                                        \
+    do {                                                                                 \
+        failhdr;                                                                         \
+        fprintf(stderr, "%s\n", msg);                                                    \
+        exit(1);                                                                         \
+    } while (0)
 
 /* Assumes json_error_t error */
-#define check_errors(code_, texts_, num_, source_,                      \
-    line_, column_, position_)                                          \
-    do {                                                                \
-        int i_, found_ = 0;                                             \
-        if(json_error_code(&error) != code_) {                          \
-            failhdr;                                                    \
-            fprintf(stderr, "code: %d != %d\n",                         \
-                    json_error_code(&error), code_);                    \
-            exit(1);                                                    \
-        }                                                               \
-        for(i_ = 0; i_ < num_; i_++) {                                  \
-            if(strcmp(error.text, texts_[i_]) == 0) {                   \
-                found_ = 1;                                             \
-                break;                                                  \
-            }                                                           \
-        }                                                               \
-        if (!found_) {                                                  \
-            failhdr;                                                    \
-            if (num_ == 1) {                                            \
-                fprintf(stderr, "text: \"%s\" != \"%s\"\n", error.text, texts_[0]); \
-            } else {                                                    \
-                fprintf(stderr, "text: \"%s\" does not match\n", error.text); \
-            }                                                           \
-            exit(1);                                                    \
-        }                                                               \
-        if(strcmp(error.source, source_) != 0) {                        \
-            failhdr;                                                    \
-                                                                        \
-            fprintf(stderr, "source: \"%s\" != \"%s\"\n", error.source, source_); \
-            exit(1);                                                    \
-        }                                                               \
-        if(error.line != line_) {                                       \
-            failhdr;                                                    \
-            fprintf(stderr, "line: %d != %d\n", error.line, line_);     \
-            exit(1);                                                    \
-        }                                                               \
-        if(error.column != column_) {                                   \
-            failhdr;                                                    \
-            fprintf(stderr, "column: %d != %d\n", error.column, column_); \
-            exit(1);                                                    \
-        }                                                               \
-        if(error.position != position_) {                               \
-            failhdr;                                                    \
-            fprintf(stderr, "position: %d != %d\n", error.position, position_); \
-            exit(1);                                                    \
-        }                                                               \
-    } while(0)
-
+#define check_errors(code_, texts_, num_, source_, line_, column_, position_)            \
+    do {                                                                                 \
+        int i_, found_ = 0;                                                              \
+        if (json_error_code(&error) != code_) {                                          \
+            failhdr;                                                                     \
+            fprintf(stderr, "code: %d != %d\n", json_error_code(&error), code_);         \
+            exit(1);                                                                     \
+        }                                                                                \
+        for (i_ = 0; i_ < num_; i_++) {                                                  \
+            if (strcmp(error.text, texts_[i_]) == 0) {                                   \
+                found_ = 1;                                                              \
+                break;                                                                   \
+            }                                                                            \
+        }                                                                                \
+        if (!found_) {                                                                   \
+            failhdr;                                                                     \
+            if (num_ == 1) {                                                             \
+                fprintf(stderr, "text: \"%s\" != \"%s\"\n", error.text, texts_[0]);      \
+            } else {                                                                     \
+                fprintf(stderr, "text: \"%s\" does not match\n", error.text);            \
+            }                                                                            \
+            exit(1);                                                                     \
+        }                                                                                \
+        if (strcmp(error.source, source_) != 0) {                                        \
+            failhdr;                                                                     \
+                                                                                         \
+            fprintf(stderr, "source: \"%s\" != \"%s\"\n", error.source, source_);        \
+            exit(1);                                                                     \
+        }                                                                                \
+        if (error.line != line_) {                                                       \
+            failhdr;                                                                     \
+            fprintf(stderr, "line: %d != %d\n", error.line, line_);                      \
+            exit(1);                                                                     \
+        }                                                                                \
+        if (error.column != column_) {                                                   \
+            failhdr;                                                                     \
+            fprintf(stderr, "column: %d != %d\n", error.column, column_);                \
+            exit(1);                                                                     \
+        }                                                                                \
+        if (error.position != position_) {                                               \
+            failhdr;                                                                     \
+            fprintf(stderr, "position: %d != %d\n", error.position, position_);          \
+            exit(1);                                                                     \
+        }                                                                                \
+    } while (0)
 
 /* Assumes json_error_t error */
-#define check_error(code_, text_, source_, line_, column_, position_)   \
+#define check_error(code_, text_, source_, line_, column_, position_)                    \
     check_errors(code_, &text_, 1, source_, line_, column_, position_)
 
-
 static void run_tests();
 
 int main() {