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 #include -#include #include +#include -#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 #include #include -#include /* 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 #include #include #include -#include #ifdef HAVE_UNISTD_H #include #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 #include "jansson_private.h" +#include -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 #endif -#include /* for JSON_INLINE */ -#include "jansson_private.h" /* for container_of() */ #include "hashtable.h" +#include "jansson_private.h" /* for container_of() */ +#include /* 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 #include "jansson.h" +#include 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 -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 -#include /* for size_t */ #include +#include +#include /* 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(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_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++) +#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) -{ +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 -#include "jansson.h" #include "hashtable.h" +#include "jansson.h" +#include "jansson_private_config.h" #include "strbuffer.h" +#include -#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 #include #include #include #include #include -#include #ifdef HAVE_UNISTD_H #include #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 = ""; else source = ""; @@ -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 = ""; 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 #include "jansson.h" #include "jansson_private.h" #include "utf.h" +#include 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, "", 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, "", 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, "", json_error_invalid_format, "Cannot use '%c' on optional strings", t); + set_error(s, "", 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, "", 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, "", 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, "", 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, "", 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, "", json_error_invalid_format, "Unexpected end of format string"); + if (!token(s)) { + set_error(s, "", json_error_invalid_format, + "Unexpected end of format string"); goto error; } - if(token(s) != 's') { - set_error(s, "", json_error_invalid_format, "Expected format 's', got '%c'", token(s)); + if (token(s) != 's') { + set_error(s, "", 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, "", 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, "", 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, "", 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, "", json_error_invalid_format, "Unexpected end of format string"); + if (!token(s)) { + set_error(s, "", 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, "", json_error_out_of_memory, "Unable to append to array"); + if (!s->has_error && json_array_append_new(array, value)) { + set_error(s, "", 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, "", json_error_numeric_overflow, "Invalid floating point value"); + set_error(s, "", 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, "", json_error_invalid_format, "Unexpected format character '%c'", - token(s)); + set_error(s, "", 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, "", 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, "", 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, "", json_error_invalid_format, "Expected '}' after '%c', got '%c'", - (strict == 1 ? '!' : '*'), token(s)); + if (strict != 0) { + set_error(s, "", json_error_invalid_format, + "Expected '}' after '%c', got '%c'", (strict == 1 ? '!' : '*'), + token(s)); goto out; } - if(!token(s)) { - set_error(s, "", json_error_invalid_format, "Unexpected end of format string"); + if (!token(s)) { + set_error(s, "", 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, "", json_error_invalid_format, "Expected format 's', got '%c'", token(s)); + if (token(s) != 's') { + set_error(s, "", 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, "", 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, "", json_error_item_not_found, "Object item not found: %s", key); + if (!value && !opt) { + set_error(s, "", 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, "", json_error_end_of_input_expected, - "%li object item(s) left unpacked: %s", - unpacked, + "%li object item(s) left unpacked: %s", unpacked, keys_res ? "" : 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, "", json_error_wrong_type, "Expected array, got %s", type_name(root)); + if (root && !json_is_array(root)) { + set_error(s, "", 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, "", json_error_invalid_format, "Expected ']' after '%c', got '%c'", - (strict == 1 ? '!' : '*'), + if (strict != 0) { + set_error(s, "", json_error_invalid_format, + "Expected ']' after '%c', got '%c'", (strict == 1 ? '!' : '*'), token(s)); return -1; } - if(!token(s)) { - set_error(s, "", json_error_invalid_format, "Unexpected end of format string"); + if (!token(s)) { + set_error(s, "", 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, "", json_error_invalid_format, "Unexpected format character '%c'", - token(s)); + if (!strchr(unpack_value_starters, token(s))) { + set_error(s, "", 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, "", json_error_index_out_of_range, "Array index %lu out of range", - (unsigned long)i); + if (!value) { + set_error(s, "", 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, "", json_error_end_of_input_expected, "%li array item(s) left unpacked", diff); + set_error(s, "", 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, "", json_error_wrong_type, "Expected string, got %s", - type_name(root)); + if (root && !json_is_string(root)) { + set_error(s, "", 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, "", 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, "", json_error_null_value, "NULL string length argument"); + if (!len_target) { + set_error(s, "", 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, "", json_error_wrong_type, "Expected integer, got %s", - type_name(root)); + if (root && !json_is_integer(root)) { + set_error(s, "", 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, "", json_error_wrong_type, "Expected integer, got %s", - type_name(root)); + if (root && !json_is_integer(root)) { + set_error(s, "", 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, "", json_error_wrong_type, "Expected true or false, got %s", - type_name(root)); + if (root && !json_is_boolean(root)) { + set_error(s, "", 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, "", json_error_wrong_type, "Expected real, got %s", - type_name(root)); + if (root && !json_is_real(root)) { + set_error(s, "", 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, "", json_error_wrong_type, "Expected real or integer, got %s", - type_name(root)); + if (root && !json_is_number(root)) { + set_error(s, "", 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, "", json_error_wrong_type, "Expected null, got %s", - type_name(root)); + if (root && !json_is_null(root)) { + set_error(s, "", json_error_wrong_type, + "Expected null, got %s", type_name(root)); return -1; } return 0; default: - set_error(s, "", json_error_invalid_format, "Unexpected format character '%c'", - token(s)); + set_error(s, "", 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, ""); - 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, "", json_error_invalid_format, "Garbage after format string"); + set_error(&s, "", 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, ""); 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, ""); - 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, "", json_error_invalid_format, "Garbage after format string"); + if (token(&s)) { + set_error(&s, "", 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 #include -#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 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 -#include -#include -#include -#include #include "jansson_private.h" #include "strbuffer.h" +#include +#include +#include +#include +#include /* 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 #include "utf.h" +#include -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 #endif +#include #ifdef HAVE_STDINT_H #include #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 #endif +#include #include #include #include -#include #ifdef HAVE_STDINT_H #include #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 #endif +#include +#include #include #include #include -#include -#include #ifdef HAVE_LOCALE_H #include - #endif +#endif #if _WIN32 -#include /* for _setmode() */ -#include /* for _O_BINARY */ +#include /* for _O_BINARY */ +#include /* 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 #include "util.h" +#include -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 (!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 (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 #include #include -#include -#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 -#include #include "util.h" +#include +#include -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": }}} - array: [[[]]] + object: {"a": {"b": {"c": }}} + 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": }}} @@ -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 -#include -#include #include "util.h" +#include +#include +#include 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 #include "util.h" +#include -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 #include -#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\"'", "", 1, 16, 16); + check_error(json_error_duplicate_key, "duplicate object key near '\"foo\"'", + "", 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'", "", 1, 18, 18); + check_error(json_error_end_of_input_expected, "end of file expected near 'garbage'", + "", 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 -#include -#include #include "util.h" +#include +#include +#include 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, "") != 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 #include -#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 #include +#include #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 -#include #include "util.h" +#include +#include #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 #include -#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(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_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_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_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 -#include -#include -#include -#include #include "util.h" +#include +#include +#include +#include #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", "", 1, 1, 1); + fail("json_pack infinity incorrectly succeeded"); + check_error(json_error_numeric_overflow, "Invalid floating point value", "", 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", "", 1, 2, 2); + fail("json_pack infinity array element incorrectly succeeded"); + check_error(json_error_numeric_overflow, "Invalid floating point value", "", 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", "", 1, 4, 4); + fail("json_pack infinity object value incorrectly succeeded"); + check_error(json_error_numeric_overflow, "Invalid floating point value", "", 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", "", 1, 2, 2); + check_error(json_error_invalid_format, "Cannot use '+' on optional strings", + "", 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", "", 1, 2, 2); + check_error(json_error_invalid_format, "Cannot use '#' on optional strings", + "", 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 '*'", "", 1, 5, 5); + check_error(json_error_invalid_format, "Expected format 's', got '*'", "", 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", "", 1, 6, 6); + check_error(json_error_invalid_format, "Cannot use '#' on optional strings", + "", 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", "", 1, 6, 6); + check_error(json_error_invalid_format, "Cannot use '+' on optional strings", + "", 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 '*'", "", 1, 3, 3); + check_error(json_error_invalid_format, "Unexpected format character '*'", "", + 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", "", 1, 1, 1); + check_error(json_error_numeric_overflow, "Invalid floating point value", "", 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", "", 1, 2, 2); + fail("json_pack NAN array element incorrectly succeeded"); + check_error(json_error_numeric_overflow, "Invalid floating point value", "", 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", "", 1, 4, 4); + fail("json_pack NAN object value incorrectly succeeded"); + check_error(json_error_numeric_overflow, "Invalid floating point value", "", 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'", "", 3, 1, 4); + check_error(json_error_invalid_format, "Expected format 's', got '1'", "", 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 '}'", "", 1, 2, 2); + check_error(json_error_invalid_format, "Unexpected format character '}'", "", + 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 ']'", "", 1, 2, 2); + check_error(json_error_invalid_format, "Expected format 's', got ']'", "", 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", "", 1, 2, 2); + check_error(json_error_invalid_format, "Unexpected end of format string", "", + 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", "", 1, 2, 2); + check_error(json_error_invalid_format, "Unexpected end of format string", "", + 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", "", 1, 4, 4); + check_error(json_error_invalid_format, "Garbage after format string", "", 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", "", 1, 2, 2); + check_error(json_error_invalid_format, "Garbage after format string", "", 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", "", 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 '+'", "", 1, 1, 1); + check_error(json_error_invalid_format, "Unexpected format character '+'", "", + 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", "", -1, -1, 0); + check_error(json_error_invalid_argument, "NULL or empty format string", "", + -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", "", -1, -1, 0); + check_error(json_error_invalid_argument, "NULL or empty format string", "", + -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", "", 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", "", 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 '{'", "", 1, 3, 3); + check_error(json_error_invalid_format, "Expected format 's', got '{'", "", 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 '}'", "", 1, 19, 19); + check_error(json_error_invalid_format, "Unexpected format character '}'", "", + 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 '}'", "", 1, 21, 21); + check_error(json_error_invalid_format, "Unexpected format character '}'", "", + 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", "", 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", "", 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", "", 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", "", 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", "", 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", "", 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", "", 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", "", 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'", "", 1, 2, 2); + check_error(json_error_invalid_format, "Unexpected format character '1'", "", + 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'", "", 1, 2, 2); + check_error(json_error_invalid_format, "Unexpected format character '1'", "", + 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", "", 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 -#include #include "util.h" +#include +#include -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() 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 -#include #include "util.h" - +#include +#include 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 +#include "util.h" #include #include -#include "util.h" +#include -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'", "", 1, 1, 1); + check_error(json_error_invalid_format, "Unexpected format character 'z'", "", + 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", "", -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 '}'", "", 1, 2, 2); + check_error(json_error_invalid_format, "Unexpected format character '}'", "", + 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 ']'", "", 1, 2, 2); + check_error(json_error_invalid_format, "Expected format 's', got ']'", "", 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", "", 1, 2, 2); + check_error(json_error_invalid_format, "Unexpected end of format string", "", + 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", "", 1, 2, 2); + check_error(json_error_invalid_format, "Unexpected end of format string", "", + 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", "", 1, 4, 4); + check_error(json_error_invalid_format, "Garbage after format string", "", 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", "", 1, 2, 2); + check_error(json_error_invalid_format, "Garbage after format string", "", 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", "", -1, -1, 0); + check_error(json_error_invalid_argument, "NULL or empty format string", "", + -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", "", 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", "", 1, 1, 1); + check_error(json_error_wrong_type, "Expected string, got integer", "", 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", "", 1, 1, 1); + check_error(json_error_wrong_type, "Expected null, got integer", "", 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", "", 1, 1, 1); + check_error(json_error_wrong_type, "Expected true or false, got integer", + "", 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", "", 1, 1, 1); + check_error(json_error_wrong_type, "Expected integer, got string", "", 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", "", 1, 1, 1); + check_error(json_error_wrong_type, "Expected integer, got string", "", 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", "", 1, 1, 1); + check_error(json_error_wrong_type, "Expected real, got integer", "", 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", "", 1, 1, 1); + check_error(json_error_wrong_type, "Expected real or integer, got string", + "", 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", "", 1, 1, 1); + check_error(json_error_wrong_type, "Expected array, got integer", "", 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", "", 1, 1, 1); + check_error(json_error_wrong_type, "Expected object, got integer", "", 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", "", 1, 3, 3); + check_error(json_error_index_out_of_range, "Array index 1 out of range", + "", 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", "", 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", "", 1, 3, 3); + check_error(json_error_item_not_found, "Object item not found: baz", "", + 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", "", 1, 5, 5); + check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", + "", 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", "", 1, 4, 4); + check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", + "", 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, "", 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, "", + 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'", "", 1, 4, 4); + check_error(json_error_invalid_format, "Expected ']' after '!', got 'i'", "", + 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'", "", 1, 4, 4); + check_error(json_error_invalid_format, "Expected ']' after '*', got 'i'", "", + 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'", "", 1, 5, 5); + check_error(json_error_invalid_format, "Expected '}' after '!', got 's'", "", + 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'", "", 1, 5, 5); + check_error(json_error_invalid_format, "Expected '}' after '*', got 's'", "", + 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", "", 1, 7, 7); + check_error(json_error_end_of_input_expected, "1 object item(s) left unpacked: baz", + "", 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", "", 1, 5, 5); + check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", + "", 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", "", 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", + "", 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 -#include #include "util.h" +#include +#include -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() {