Reformat the json_object-split branch with clang-format

Remove all of the temporary defines, structures, old compat fuctions, extra fields, etc... that were needed during the conversion to a split set of json_object_* structures.

.clang-format

@@ -0,0 +1,53 @@
+BasedOnStyle:  LLVM
+# If true, clang-format will attempt to re-flow comments
+ReflowComments: false
+# The column limit.
+ColumnLimit: 100
+# Indent width for line continuations.
+ContinuationIndentWidth: 4
+# The number of columns to use for indentation.
+IndentWidth: 8
+# The number of columns used for tab stops.
+TabWidth: 8
+UseTab: ForIndentation
+
+# Options for aligning backslashes in escaped newlines.
+AlignEscapedNewlines: Left
+# Short Block Style
+AllowShortBlocksOnASingleLine:  true
+# If true, short case labels will be contracted to a single line.
+AllowShortCaseLabelsOnASingleLine: true
+# Dependent on the value, int f() { return 0; } can be put on a single line.
+AllowShortFunctionsOnASingleLine:  Empty
+# The brace breaking style to use.
+BreakBeforeBraces: Custom
+# Control of individual brace wrapping cases.
+BraceWrapping:
+  # Wrap class definition.
+  AfterClass: true
+  # Wrap control statements
+  AfterControlStatement: true
+  # Wrap enum definitions.
+  AfterEnum: true
+  # Wrap function definitions.
+  AfterFunction: true
+  # Wrap namespace definitions.
+  AfterNamespace: true
+  # Wrap struct definitions.
+  AfterStruct: true
+  # Wrap union definitions.
+  AfterUnion: true
+  # Wrap extern blocks.
+  AfterExternBlock: false
+  # Wrap before catch.
+  BeforeCatch: true
+  # Wrap before else.
+  BeforeElse: true
+  # Indent the wrapped braces themselves.
+  IndentBraces:  false
+  # If false, empty function body can be put on a single line.
+  SplitEmptyFunction:  false
+  # If false, empty record (e.g. class, struct or union) body can be put on a single line.
+  SplitEmptyRecord:  false
+  # If false, empty namespace body can be put on a single line.
+  SplitEmptyNamespace:  false

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,23 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+Note: for general questions and comments, please use the forums at:
+https://groups.google.com/forum/#!forum/json-c
+
+**Describe the bug**
+A clear and concise description of what the bug is, and any information about where you're running into the bug that you feel might be relevant.
+
+**Steps To Reproduce**
+List the steps to reproduce the behavior.
+If possible, please attach a sample json file and/or a minimal code example.
+
+**Version and Platform**
+- json-c version: [e.g. json-c-0.14, or a specific commit hash]
+- OS: [e.g. Ubuntu 20.04, Debian Buster, NetBSD 9, etc...]
+- Custom cmake/build flags, if any

.gitignore

@@ -12,9 +12,7 @@
 *.autosave
 
 # Tests
-/test-driver
 /tests/Makefile
-/tests/Makefile.in
 /tests/test1
 /tests/test1Formatted
 /tests/test2
@@ -44,17 +42,12 @@
 /tests/*.trs
 
 # Generated folders
+/build
 /Debug
 /Release
 /*/Debug
 /*/Release
 
-# Generated binaries
-*.lo
-*.o
-/libjson-c.la
-/libjson.la
-
 # Archives
 *.zip
 *.tar.*
@@ -74,38 +67,27 @@
 *.dmg
 *.ipa
 
-.deps/
-.libs/
-/aclocal.m4
-/autoconf-archive
-/autom4te.cache
-/config.guess
-/config.h.in
+# It's not good practice to build directly in the source tree
+# but ignore cmake auto-generated files anyway:
 /json_config.h
-/compile
 /config.h
-/config.log
-/config.status
-/config.sub
-/configure
-/depcomp
-/doc
-/install-sh
-/json.pc
 /json-c.pc
-/json-c-uninstalled.pc
-/libtool
-/ltmain.sh
 /Makefile
-/Makefile.in
-/missing
-/stamp-h1
-/stamp-h2
-
-# cmake auto-generated files
 /CMakeCache.txt
 /CMakeFiles
-/cmake_install.cmake
-/include
+/CMakeDoxyfile.in
+/*.cmake
+/DartConfiguration.tcl
+/tests/CMakeFiles/
+/tests/*.cmake
+/Testing/
+
+# ...and build artifacts.
+/doc/html
 /libjson-c.a
 /libjson-c.so
+/libjson-c.so.*
+
+# Benchmarking input and output
+/bench/data
+/bench/work

.travis.yml

@@ -1,32 +1,153 @@
-language: cpp
-
-compiler:
-  - gcc
-  - clang
-
-addons:
-  apt:
-    packages:
-      - cppcheck
-
-os:
-  - linux
-  - osx
-
-before_install:
-  - echo $LANG
-  - echo $LC_ALL
-  - set -e
-
-install:
-  - sh autogen.sh
-
-before_script:
-  - ./configure
-
-script:
-  - make
-
-after_success:
-  - make check
-  - if type cppcheck &> /dev/null ; then cppcheck --error-exitcode=1 --quiet *.h *.c tests/ ; fi
+language: cpp
+matrix:
+  include:
+# gcc
+#   xenial
+#   gcc 5 is the default on xenial
+    - os: linux
+      dist: xenial
+      compiler: gcc
+      addons:
+        apt:
+          packages:
+            - valgrind
+            - cppcheck
+            - doxygen
+            - cmake
+      env: CHECK="true"
+#   bionic
+    - os: linux
+      dist: bionic
+      compiler: gcc
+      env: MATRIX_EVAL="CC=gcc-6 && CXX=g++-6"
+
+    # gcc 7 is the default on bionic
+    - os: linux
+      dist: bionic
+      compiler: gcc
+      env: CHECK="true"
+    - os: linux
+      dist: bionic
+      compiler: gcc
+      env: MATRIX_EVAL="CC=gcc-8 && CXX=g++-8"
+
+# clang
+#   xenial
+    - os: linux
+      dist: xenial
+      compiler: clang
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-xenial-5.0
+          packages:
+            - clang-5.0
+            - cmake
+      env: MATRIX_EVAL="CC=clang-5.0 && CXX=clang++-5.0"
+    - os: linux
+      dist: xenial
+      compiler: clang
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-xenial-6.0
+          packages:
+            - clang-6.0
+            - cmake
+      env: MATRIX_EVAL="CC=clang-6.0 && CXX=clang++-6.0"
+
+    # clang-7 is the default on xenial and bionic
+    - os: linux
+      dist: xenial
+      compiler: clang
+      addons:
+        apt:
+          packages:
+            - valgrind
+            - cppcheck
+            - doxygen
+            - cmake
+      env: CHECK="true"
+
+# bionic
+    - os: linux
+      dist: bionic
+      compiler: clang
+      env: CHECK="true"
+# osx
+    - os: osx
+      osx_image: xcode9.4
+      env: XCODE="true"
+    - os: osx
+      osx_image: xcode10.1
+      env: XCODE="true" CHECK="true"
+
+# run coveralls
+    - os: linux
+      dist: xenial
+      compiler: gcc
+      addons:
+        apt:
+          packages:
+            - lcov
+      env: CHECK="true"
+      before_install:
+        - sudo gem install coveralls-lcov
+        - echo $CC
+        - echo $LANG
+        - echo $LC_ALL
+        - set -e
+        - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+            eval "${MATRIX_EVAL}";
+            if [ -n "$MATRIX_EVAL" ] && [ "$TRAVIS_COMPILER" != "clang" ]; then
+              sudo apt-get install -y $CC;
+            fi;
+          fi
+      before_script:
+        - export CFLAGS="-fprofile-arcs -ftest-coverage"
+        - mkdir build && cd build && cmake ..
+      script:
+        - make
+        - make test
+      after_success:
+        - cd ..
+        - lcov -d build/ -b . -c -o build/all_coverage.info
+        - lcov -r build/all_coverage.info '/usr/*' '*CMakeFiles*' '*fuzz*' '*test*' -o build/coverage.info
+        - coveralls-lcov --verbose build/coverage.info
+
+#  allow_failures:
+#    - os: osx
+
+before_install:
+  - echo $CC
+  - echo $LANG
+  - echo $LC_ALL
+  - set -e
+  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+      eval "${MATRIX_EVAL}";
+      if [ -n "$MATRIX_EVAL" ] && [ "$TRAVIS_COMPILER" != "clang" ]; then
+        sudo apt-get install -y $CC;
+      fi;
+    fi
+
+before_script:
+  # XXX osx on travis doesn't work w/ set -e, so turn it off :(
+  - set +e
+  - mkdir -p build || echo "Failed to mkdir build"
+  - cd build || echo "Failed to cd build"
+  - cmake .. || echo "Failed to run cmake"
+
+script:
+  - make
+  # when using bionic, Travis seems to ignore the "addons" section, so installing the packages with apt-get...
+  - if [ -n "$CHECK" ]; then
+      if [ "$TRAVIS_OS_NAME" = "osx" ]; then
+        brew install doxygen;
+      else
+        if [ "$TRAVIS_DIST" = "bionic" ]; then
+          sudo apt-get install -y valgrind cppcheck doxygen;
+        fi;
+      fi;
+      make distcheck;
+      if type cppcheck &> /dev/null ; then cppcheck --error-exitcode=1 --quiet *.h *.c tests/ ; fi;
+    fi

AUTHORS

@@ -1,5 +1,30 @@
-Michael Clark <michael@metaparadigm.com>
-Jehiah Czebotar <jehiah@gmail.com>
-Eric Haszlakiewicz <hawicz+json-c@gmail.com>
+Alexander Dahl <post@lespocky.de>
+andy5995 <andy400-dev@yahoo.com>
+Björn Esser <besser82@fedoraproject.org>
+changyong guo <guo1487@163.com>
+chenguoping <chenguopingdota@163.com>
+Christopher Head <chead@chead.ca>
+Chris Wolfe <chriswwolfe@gmail.com>
 C. Watford (christopher.watford@gmail.com)
-
+Darjan Krijan <darjan_krijan@gmx.de>
+Eric Hawicz <erh+git@nimenees.com>
+grdowns <grdowns@microsoft.com>
+Ivan Romanov <drizt@land.ru>
+Jaap Keuter <jaap.keuter@xs4all.nl>
+janczer <menshikov.ivn@gmail.com>
+Jehan <jehan@girinstud.io>
+Jehiah Czebotar <jehiah@gmail.com>
+Jonathan Wiens <j.wiens@teles.com>
+Jose Bollo <jose.bollo@iot.bzh>
+Keith Holman <keith.holman@windriver.com>
+Liang, Gao <liang.gao@intel.com>
+max <mpano91@gmail.com>
+Michael Clark <michael@metaparadigm.com>
+myd7349 <myd7349@gmail.com>
+Pierce Lopez <pierce.lopez@gmail.com>
+Po-Chuan Hsieh <sunpoet@sunpoet.net>
+Ramiro Polla <ramiro.polla@gmail.com>
+Rikard Falkeborn <rikard.falkeborn@gmail.com>
+Robert <roby_p97@yahoo.com>
+Rubasri Kalidas <rubasri.kalidas@intel.com>
+Unmanned Player <36690541+unmanned-player@users.noreply.github.com>

CMakeLists.txt

@@ -1,136 +1,463 @@
-#Licensed under the MIT license. See LICENSE file in the project root for full license information.
+# Many projects still are stuck using CMake 2.8 is several places so it's good to provide backward support too. This is
+# specially true in old embedded systems (OpenWRT and friends) where CMake isn't necessarily upgraded.
+cmake_minimum_required(VERSION 2.8)
 
-cmake_minimum_required(VERSION 2.8.7)
-cmake_policy(SET CMP0048 NEW)
-project(json-c VERSION 0.12.99)
-
-
-include(CheckSymbolExists)
-
-check_symbol_exists(strtoll "stdlib.h" HAVE_STRTOLL)
-
-set(cmake_strtoll "strtoll")
-if (NOT HAVE_STRTOLL)
-  # Use _strtoi64 if strtoll is not available.
-  check_symbol_exists(_strtoi64 stdlib.h have_strtoi64)
-  if (have_strtoi64)
-    set(HAVE_STRTOLL 1)
-    set(cmake_strtoll "_strtoi64")
-    # could do the same for strtoull, if needed
-  endif ()
-endif ()
-
-
-
-if(MSVC)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4100 /wd4996 /wd4244 /wd4706 /wd4702 /wd4127 /wd4701")
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4100 /wd4996 /wd4244 /wd4706 /wd4702 /wd4127 /wd4701")
-  set(cmake_create_config 1)
-elseif(MINGW)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -D_GNU_SOURCE=1")
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -D_GNU_SOURCE=1")
-  if (MSYS OR CMAKE_GENERATOR STREQUAL "Unix Makefiles")
-    execute_process(COMMAND echo ${CMAKE_CURRENT_SOURCE_DIR} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-    execute_process(COMMAND sh autogen.sh WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-    execute_process(COMMAND sh ./configure WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-    file(COPY ./config.h DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/include/)
-    file(COPY ./json_config.h DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/include/)
-  else()
-    set(cmake_create_config 1)
-  endif()
-elseif(UNIX)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -D_GNU_SOURCE")
-  execute_process(COMMAND echo ${CMAKE_CURRENT_SOURCE_DIR} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-  execute_process(COMMAND sh autogen.sh WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-  execute_process(COMMAND ./configure WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-  file(COPY ./config.h DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/include/)
-  file(COPY ./json_config.h DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/include/)
+if(POLICY CMP0048)
+	cmake_policy(SET CMP0048 NEW)
 endif()
 
-if (cmake_create_config)
-  file(REMOVE ./config.h)  # make sure any stale one is gone
-  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.win32 ${CMAKE_CURRENT_BINARY_DIR}/include/config.h)
-  file(COPY ./json_config.h.win32 DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/include/)
-  file(RENAME ${CMAKE_CURRENT_BINARY_DIR}/include/json_config.h.win32 ${CMAKE_CURRENT_BINARY_DIR}/include/json_config.h)
-endif ()
+# JSON-C library is C only project.
+project(json-c LANGUAGES C VERSION 0.14.99)
 
-include_directories(${CMAKE_CURRENT_BINARY_DIR}/include)
+# If we've got 3.0 then it's good, let's provide support. Otherwise, leave it be.
+if(POLICY CMP0038)
+  # Policy CMP0038 introduced was in CMake 3.0
+  cmake_policy(SET CMP0038 NEW)
+endif()
+
+if(POLICY CMP0054)
+    cmake_policy(SET CMP0054 NEW)
+endif()
+
+# set default build type if not specified by user
+if(NOT CMAKE_BUILD_TYPE)
+	set(CMAKE_BUILD_TYPE debug)
+endif()
+
+set(CMAKE_C_FLAGS_RELEASE   "${CMAKE_C_FLAGS_RELEASE} -O2")
+
+# Include file check macros honor CMAKE_REQUIRED_LIBRARIES
+# i.e. the check_include_file() calls will include -lm when checking.
+if(POLICY CMP0075)
+	cmake_policy(SET CMP0075 NEW)
+endif()
+
+include(CTest)
+
+if (CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_TESTING AND
+   (NOT MSVC OR NOT (MSVC_VERSION LESS 1800)) # Tests need at least VS2013
+   )
+add_subdirectory(tests)
+endif()
+
+if (NOT MSVC)  # cmd line apps don't built on Windows currently.
+add_subdirectory(apps)
+endif()
+
+# Set some packaging variables.
+set(CPACK_PACKAGE_NAME              "${PROJECT_NAME}")
+set(CPACK_PACKAGE_VERSION_MAJOR     "${PROJECT_VERSION_MAJOR}")
+set(CPACK_PACKAGE_VERSION_MINOR     "${PROJECT_VERSION_MINOR}")
+set(CPACK_PACKAGE_VERSION_PATCH     "${PROJECT_VERSION_PATCH}")
+set(JSON_C_BUGREPORT                "json-c@googlegroups.com")
+set(CPACK_SOURCE_IGNORE_FILES
+        ${PROJECT_SOURCE_DIR}/build
+        ${PROJECT_SOURCE_DIR}/cmake-build-debug
+        ${PROJECT_SOURCE_DIR}/pack
+        ${PROJECT_SOURCE_DIR}/.idea
+        ${PROJECT_SOURCE_DIR}/.DS_Store
+        ${PROJECT_SOURCE_DIR}/.git
+        ${PROJECT_SOURCE_DIR}/.vscode)
+
+include(CheckSymbolExists)
+include(CheckIncludeFile)
+include(CheckIncludeFiles)
+include(CheckCSourceCompiles)
+include(CheckTypeSize)
+include(CPack)
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+
+option(BUILD_SHARED_LIBS  "Default to building shared libraries" ON)
+option(BUILD_STATIC_LIBS  "Default to building static libraries" ON)
+
+# Generate a release merge and test it to verify the correctness of republishing the package.
+ADD_CUSTOM_TARGET(distcheck
+COMMAND make package_source
+    COMMAND tar -xvf "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source.tar.gz"
+    COMMAND mkdir "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/build"
+    COMMAND cmake "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/" -B"./${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/build/"
+    COMMAND make -C "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/build"
+    COMMAND make test -C "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/build"
+    COMMAND rm -rf "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source"
+)
+
+# Enable or disable features. By default, all features are turned off.
+option(DISABLE_BSYMBOLIC              "Avoid linking with -Bsymbolic-function."               OFF)
+option(DISABLE_THREAD_LOCAL_STORAGE   "Disable using Thread-Local Storage (HAVE___THREAD)."   OFF)
+option(DISABLE_WERROR                 "Avoid treating compiler warnings as fatal errors."     OFF)
+option(ENABLE_RDRAND                  "Enable RDRAND Hardware RNG Hash Seed."                 OFF)
+option(ENABLE_THREADING               "Enable partial threading support."                     OFF)
+
+if (UNIX OR MINGW OR CYGWIN)
+    list(APPEND CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE)
+endif()
+
+if (UNIX)
+    list(APPEND CMAKE_REQUIRED_LIBRARIES   m)
+endif()
+
+if (MSVC)
+    list(APPEND CMAKE_REQUIRED_DEFINITIONS /D_CRT_SECURE_NO_DEPRECATE)
+    list(APPEND CMAKE_REQUIRED_FLAGS /wd4996)
+endif()
+
+check_include_file("fcntl.h"        HAVE_FCNTL_H)
+check_include_file("inttypes.h"     HAVE_INTTYPES_H)
+check_include_file(stdarg.h         HAVE_STDARG_H)
+check_include_file(strings.h        HAVE_STRINGS_H)
+check_include_file(string.h         HAVE_STRING_H)
+check_include_file(syslog.h         HAVE_SYSLOG_H)
+
+
+check_include_files("stdlib.h;stdarg.h;string.h;float.h" STDC_HEADERS)
+
+check_include_file(unistd.h         HAVE_UNISTD_H)
+check_include_file(sys/types.h      HAVE_SYS_TYPES_H)
+check_include_file(sys/resource.h   HAVE_SYS_RESOURCE_H) # for getrusage
+
+check_include_file("dlfcn.h"        HAVE_DLFCN_H)
+check_include_file("endian.h"       HAVE_ENDIAN_H)
+check_include_file("limits.h"       HAVE_LIMITS_H)
+check_include_file("locale.h"       HAVE_LOCALE_H)
+check_include_file("memory.h"       HAVE_MEMORY_H)
+
+check_include_file(stdint.h         HAVE_STDINT_H)
+check_include_file(stdlib.h         HAVE_STDLIB_H)
+check_include_file(sys/cdefs.h      HAVE_SYS_CDEFS_H)
+check_include_file(sys/param.h      HAVE_SYS_PARAM_H)
+check_include_file(sys/stat.h       HAVE_SYS_STAT_H)
+check_include_file(xlocale.h        HAVE_XLOCALE_H)
+
+if (HAVE_INTTYPES_H AND NOT MSVC)
+    set(JSON_C_HAVE_INTTYPES_H 1)
+endif()
+
+check_symbol_exists(_isnan          "float.h" HAVE_DECL__ISNAN)
+check_symbol_exists(_finite         "float.h" HAVE_DECL__FINITE)
+
+if ((MSVC AND NOT (MSVC_VERSION LESS 1800)) OR MINGW OR CYGWIN OR UNIX)
+    check_symbol_exists(INFINITY    "math.h" HAVE_DECL_INFINITY)
+    check_symbol_exists(isinf       "math.h" HAVE_DECL_ISINF)
+    check_symbol_exists(isnan       "math.h" HAVE_DECL_ISNAN)
+    check_symbol_exists(nan         "math.h" HAVE_DECL_NAN)
+endif()
+
+check_symbol_exists(_doprnt         "stdio.h" HAVE_DOPRNT)
+if (UNIX OR MINGW OR CYGWIN)
+    check_symbol_exists(snprintf    "stdio.h" HAVE_SNPRINTF)
+endif()
+check_symbol_exists(vasprintf       "stdio.h" HAVE_VASPRINTF)
+check_symbol_exists(vsnprintf       "stdio.h" HAVE_VSNPRINTF)
+check_symbol_exists(vprintf         "stdio.h" HAVE_VPRINTF)
+
+if (HAVE_FCNTL_H)
+    check_symbol_exists(open        "fcntl.h" HAVE_OPEN)
+endif()
+if (HAVE_STDLIB_H)
+    check_symbol_exists(realloc     "stdlib.h" HAVE_REALLOC)
+endif()
+if (HAVE_LOCALE_H)
+    check_symbol_exists(setlocale   "locale.h" HAVE_SETLOCALE)
+    check_symbol_exists(uselocale   "locale.h" HAVE_USELOCALE)
+endif()
+if (HAVE_STRINGS_H)
+    check_symbol_exists(strcasecmp  "strings.h" HAVE_STRCASECMP)
+    check_symbol_exists(strncasecmp "strings.h" HAVE_STRNCASECMP)
+endif()
+if (HAVE_STRING_H)
+    check_symbol_exists(strdup      "string.h" HAVE_STRDUP)
+    check_symbol_exists(strerror    "string.h" HAVE_STRERROR)
+endif()
+if (HAVE_SYSLOG_H)
+    check_symbol_exists(vsyslog     "syslog.h" HAVE_VSYSLOG)
+endif()
+if (HAVE_SYS_RESOURCE_H)
+    check_symbol_exists(getrusage   "sys/resource.h" HAVE_GETRUSAGE)
+endif()
+
+check_symbol_exists(strtoll     "stdlib.h" HAVE_STRTOLL)
+check_symbol_exists(strtoull    "stdlib.h" HAVE_STRTOULL)
+
+set(json_c_strtoll "strtoll")
+if (NOT HAVE_STRTOLL)
+# Use _strtoi64 if strtoll is not available.
+check_symbol_exists(_strtoi64 "stdlib.h" __have_strtoi64)
+if (__have_strtoi64)
+    #set(HAVE_STRTOLL 1)
+    set(json_c_strtoll "_strtoi64")
+endif()
+endif()
+
+set(json_c_strtoull "strtoull")
+if (NOT HAVE_STRTOULL)
+# Use _strtoui64 if strtoull is not available.
+check_symbol_exists(_strtoui64 "stdlib.h" __have_strtoui64)
+if (__have_strtoui64)
+    #set(HAVE_STRTOULL 1)
+    set(json_c_strtoull "_strtoui64")
+endif()
+endif()
+
+
+check_type_size(int                 SIZEOF_INT)
+check_type_size(int64_t             SIZEOF_INT64_T)
+check_type_size(long                SIZEOF_LONG)
+check_type_size("long long"         SIZEOF_LONG_LONG)
+check_type_size("size_t"            SIZEOF_SIZE_T)
+if (MSVC)
+list(APPEND CMAKE_EXTRA_INCLUDE_FILES BaseTsd.h)
+check_type_size("SSIZE_T"           SIZEOF_SSIZE_T)
+else()
+check_type_size("ssize_t"           SIZEOF_SSIZE_T)
+endif()
+
+check_c_source_compiles(
+[=[
+extern void json_object_get();
+__asm__(".section .gnu.json_object_get\\n\\t.ascii \\"Please link against libjson-c instead of libjson\\"\\n\\t.text");
+int main(int c, char *v) { return 0;}
+]=]
+HAS_GNU_WARNING_LONG)
+
+check_c_source_compiles(
+  "int main() { int i, x = 0; i = __sync_add_and_fetch(&x,1); return x; }"
+  HAVE_ATOMIC_BUILTINS)
+
+if (NOT DISABLE_THREAD_LOCAL_STORAGE)
+  check_c_source_compiles(
+    "__thread int x = 0; int main() { return 0; }"
+    HAVE___THREAD)
+
+  if (HAVE___THREAD)
+      set(SPEC___THREAD __thread)
+  elseif (MSVC)
+      set(SPEC___THREAD __declspec(thread))
+  endif()
+endif()
+
+# Hardware random number is not available on Windows? Says, config.h.win32. Best to preserve compatibility.
+if (WIN32)
+    set(ENABLE_RDRAND 0)
+endif()
+
+# Once we've done basic symbol/header searches let's add them in.
+configure_file(${PROJECT_SOURCE_DIR}/cmake/config.h.in        ${PROJECT_BINARY_DIR}/config.h)
+message(STATUS "Wrote ${PROJECT_BINARY_DIR}/config.h")
+configure_file(${PROJECT_SOURCE_DIR}/cmake/json_config.h.in   ${PROJECT_BINARY_DIR}/json_config.h)
+message(STATUS "Wrote ${PROJECT_BINARY_DIR}/json_config.h")
+
+if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} -ffunction-sections -fdata-sections")
+	if ("${DISABLE_WERROR}" STREQUAL "OFF")
+	    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} -Werror")
+	endif()
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} -Wall")
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} -Wcast-qual")
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} -Wno-error=deprecated-declarations")
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} -Wextra")
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} -Wwrite-strings")
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} -Wno-unused-parameter")
+    if (NOT WIN32)
+        set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} -Wstrict-prototypes")
+    endif()
+
+    add_definitions(-D_GNU_SOURCE)
+elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} /DEBUG")
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} /wd4100")
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} /wd4996")
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} /wd4244")
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} /wd4706")
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} /wd4702")
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} /wd4127")
+    set(CMAKE_C_FLAGS           "${CMAKE_C_FLAGS} /wd4701")
+endif()
+
+if (NOT ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC"))
+	check_c_source_compiles(
+	[=[
+	/* uClibc toolchains without threading barf when _REENTRANT is defined */
+	#define _REENTRANT 1
+	#include <sys/types.h>
+	int main (void)
+	{
+	  return 0;
+	}
+	]=]
+	REENTRANT_WORKS
+	)
+	if (REENTRANT_WORKS)
+		add_compile_options("-D_REENTRANT")
+	endif()
+
+	# OSX Mach-O doesn't support linking with '-Bsymbolic-functions'.
+	# Others may not support it, too.
+	list(APPEND CMAKE_REQUIRED_LIBRARIES "-Wl,-Bsymbolic-functions")
+	check_c_source_compiles(
+	[=[
+	int main (void)
+	{
+	  return 0;
+	}
+	]=]
+	BSYMBOLIC_WORKS
+	)
+	list(REMOVE_ITEM CMAKE_REQUIRED_LIBRARIES "-Wl,-Bsymbolic-functions")
+	if (DISABLE_BSYMBOLIC STREQUAL "OFF" AND BSYMBOLIC_WORKS)
+		set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-Bsymbolic-functions")
+		# XXX need cmake>=3.13 for this:
+		#add_link_options("-Wl,-Bsymbolic-functions")
+	endif()
+endif()
+
+if ($ENV{VALGRIND})
+	# Build so that valgrind doesn't complain about linkhash.c
+    add_definitions(-DVALGRIND=1)
+endif()
 
 set(JSON_C_PUBLIC_HEADERS
-    ./json.h
-    ${CMAKE_CURRENT_BINARY_DIR}/include/config.h
-    ${CMAKE_CURRENT_BINARY_DIR}/include/json_config.h
-    ./arraylist.h
-    ./debug.h
-    ./json_c_version.h
-    ./json_inttypes.h
-    ./json_object.h
-    ./json_pointer.h
-    ./json_tokener.h
-    ./json_util.h
-    ./linkhash.h
-    ./printbuf.h
+    # Note: config.h is _not_ included here
+    ${PROJECT_BINARY_DIR}/json_config.h
+
+    ${PROJECT_SOURCE_DIR}/json.h
+    ${PROJECT_SOURCE_DIR}/arraylist.h
+    ${PROJECT_SOURCE_DIR}/debug.h
+    ${PROJECT_SOURCE_DIR}/json_c_version.h
+    ${PROJECT_SOURCE_DIR}/json_inttypes.h
+    ${PROJECT_SOURCE_DIR}/json_object.h
+    ${PROJECT_SOURCE_DIR}/json_object_iterator.h
+    ${PROJECT_SOURCE_DIR}/json_pointer.h
+    ${PROJECT_SOURCE_DIR}/json_tokener.h
+    ${PROJECT_SOURCE_DIR}/json_types.h
+    ${PROJECT_SOURCE_DIR}/json_util.h
+    ${PROJECT_SOURCE_DIR}/json_visit.h
+    ${PROJECT_SOURCE_DIR}/linkhash.h
+    ${PROJECT_SOURCE_DIR}/printbuf.h
 )
+
 set(JSON_C_HEADERS
     ${JSON_C_PUBLIC_HEADERS}
-    ./json_object_private.h
-    ./random_seed.h
-    ./strerror_override.h
-    ./strerror_override_private.h
-    ./math_compat.h
-    ./snprintf_compat.h
-    ./strdup_compat.h
-    ./vasprintf_compat.h
+    ${PROJECT_SOURCE_DIR}/json_object_private.h
+    ${PROJECT_SOURCE_DIR}/random_seed.h
+    ${PROJECT_SOURCE_DIR}/strerror_override.h
+    ${PROJECT_SOURCE_DIR}/strerror_override_private.h
+    ${PROJECT_SOURCE_DIR}/math_compat.h
+    ${PROJECT_SOURCE_DIR}/snprintf_compat.h
+    ${PROJECT_SOURCE_DIR}/strdup_compat.h
+    ${PROJECT_SOURCE_DIR}/vasprintf_compat.h
 )
 
 set(JSON_C_SOURCES
-    ./arraylist.c
-    ./debug.c
-    ./json_c_version.c
-    ./json_object.c
-    ./json_object_iterator.c
-    ./json_pointer.c
-    ./json_tokener.c
-    ./json_util.c
-    ./json_visit.c
-    ./linkhash.c
-    ./printbuf.c
-    ./random_seed.c
-    ./strerror_override.c
+    ${PROJECT_SOURCE_DIR}/arraylist.c
+    ${PROJECT_SOURCE_DIR}/debug.c
+    ${PROJECT_SOURCE_DIR}/json_c_version.c
+    ${PROJECT_SOURCE_DIR}/json_object.c
+    ${PROJECT_SOURCE_DIR}/json_object_iterator.c
+    ${PROJECT_SOURCE_DIR}/json_pointer.c
+    ${PROJECT_SOURCE_DIR}/json_tokener.c
+    ${PROJECT_SOURCE_DIR}/json_util.c
+    ${PROJECT_SOURCE_DIR}/json_visit.c
+    ${PROJECT_SOURCE_DIR}/linkhash.c
+    ${PROJECT_SOURCE_DIR}/printbuf.c
+    ${PROJECT_SOURCE_DIR}/random_seed.c
+    ${PROJECT_SOURCE_DIR}/strerror_override.c
 )
 
-add_library(json-c
-    SHARED
+include_directories(${PROJECT_SOURCE_DIR})
+include_directories(${PROJECT_BINARY_DIR})
+
+add_subdirectory(doc)
+
+# uninstall
+add_custom_target(uninstall
+  COMMAND cat ${PROJECT_BINARY_DIR}/install_manifest.txt | xargs rm
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+# XXX for a normal full distribution we'll need to figure out
+# XXX how to build both shared and static libraries.
+# Probably leverage that to build a local VALGRIND=1 library for testing too.
+add_library(${PROJECT_NAME}
     ${JSON_C_SOURCES}
     ${JSON_C_HEADERS}
 )
-
-add_library(json-c-static
-    STATIC
-    ${JSON_C_SOURCES}
-    ${JSON_C_HEADERS}
+set_target_properties(${PROJECT_NAME} PROPERTIES
+    VERSION 5.0.0
+    SOVERSION 5)
+list(APPEND CMAKE_TARGETS ${PROJECT_NAME})
+# If json-c is used as subroject it set to target correct interface -I flags and allow
+# to build external target without extra include_directories(...)
+target_include_directories(${PROJECT_NAME}
+    PUBLIC
+        $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
+        $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>
 )
 
-set_property(TARGET json-c PROPERTY C_STANDARD 99)
-set_property(TARGET json-c-static PROPERTY C_STANDARD 99)
-set_target_properties(json-c-static PROPERTIES OUTPUT_NAME json-c)
+# Allow to build static and shared libraries at the same time
+if (BUILD_STATIC_LIBS AND BUILD_SHARED_LIBS)
+    set(STATIC_LIB ${PROJECT_NAME}-static)
+    add_library(${STATIC_LIB} STATIC
+        ${JSON_C_SOURCES}
+        ${JSON_C_HEADERS}
+    )
 
-install(TARGETS json-c json-c-static
-    RUNTIME DESTINATION bin
-    LIBRARY DESTINATION lib
-    ARCHIVE DESTINATION lib
-)
-
-install(FILES ${JSON_C_PUBLIC_HEADERS} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/json-c )
-
-if (UNIX)
-	set(prefix ${CMAKE_INSTALL_PREFIX})
-	set(exec_prefix ${CMAKE_INSTALL_PREFIX}/bin)
-	set(libdir ${CMAKE_INSTALL_PREFIX}/lib)
-	set(includedir ${CMAKE_INSTALL_PREFIX}/include)
-	set(VERSION ${PROJECT_VERSION})
-	configure_file(json-c.pc.in json-c.pc @ONLY)
-	set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_PREFIX}/lib/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files")
-	install(FILES ${CMAKE_BINARY_DIR}/json-c.pc DESTINATION "${INSTALL_PKGCONFIG_DIR}")
+    # rename the static library
+    if (NOT MSVC)
+    set_target_properties(${STATIC_LIB} PROPERTIES
+        OUTPUT_NAME ${PROJECT_NAME}
+    )
+    endif()
+    list(APPEND CMAKE_TARGETS ${STATIC_LIB})
 endif ()
+
+# Always create new install dirs with 0755 permissions, regardless of umask
+set(CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS
+	OWNER_READ
+	OWNER_WRITE
+	OWNER_EXECUTE
+	GROUP_READ
+	GROUP_EXECUTE
+	WORLD_READ
+	WORLD_EXECUTE
+   )
+
+install(TARGETS ${CMAKE_TARGETS}
+    EXPORT ${PROJECT_NAME}-targets
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
+
+install(EXPORT ${PROJECT_NAME}-targets
+    FILE ${PROJECT_NAME}-targets.cmake
+    NAMESPACE ${PROJECT_NAME}::
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
+)
+
+configure_package_config_file(
+    "cmake/Config.cmake.in"
+    ${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config.cmake
+    INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
+)
+
+install(
+    FILES ${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
+)
+
+if (UNIX OR MINGW OR CYGWIN)
+    SET(prefix ${CMAKE_INSTALL_PREFIX})
+    # exec_prefix is prefix by default and CMake does not have the
+    # concept.
+    SET(exec_prefix ${CMAKE_INSTALL_PREFIX})
+    SET(libdir ${CMAKE_INSTALL_FULL_LIBDIR})
+    SET(includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR})
+    SET(VERSION ${PROJECT_VERSION})
+    configure_file(json-c.pc.in json-c.pc @ONLY)
+    set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_LIBDIR}/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files")
+    install(FILES ${PROJECT_BINARY_DIR}/json-c.pc DESTINATION "${INSTALL_PKGCONFIG_DIR}")
+endif ()
+
+install(FILES ${JSON_C_PUBLIC_HEADERS} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/json-c)

ChangeLog

@@ -1,4 +1,120 @@
 
+Next Release 0.15
+=====================
+
+Deprecated and removed features:
+--------------------------------
+...none yet...
+
+Other changes
+--------------
+* Add a json_parse binary, for use in testing changes (not installed).
+* Issue #471: always create directories with mode 0755, regardless of umask.
+* Added a JSON_TOKENER_ALLOW_TRAILING_CHARS flag to allow multiple objects
+  to be parsed even when JSON_TOKENER_STRICT is set.
+* Split the internal json_object structure into several sub-types, one for
+   each json_type (json_object_object, json_object_string, etc...).
+  This improves memory usage and speed, with the benchmark under
+   bench/ report 5.8% faster test time and 6%(max RSS)-12%(peak heap)
+   less memory usage.
+  Memory used just for json_object structures decreased 27%, so use cases
+   with fewer arrays and/or strings would benefit more.
+
+
+***
+
+0.14 (up to commit 9ed00a6, 2020/04/14)
+=========================================
+
+Deprecated and removed features:
+--------------------------------
+* bits.h has been removed
+* lh_abort() has been removed
+* lh_table_lookup() has been removed, use lh_table_lookup_ex() instead.
+* Remove TRUE and FALSE defines, use 1 and 0 instead.
+
+Build changes:
+--------------
+## Deprecated and removed features:
+* bits.h has been removed
+* lh_abort() has been removed
+* lh_table_lookup() has been removed, use lh_table_lookup_ex() instead.
+* Remove TRUE and FALSE defines, use 1 and 0 instead.
+* autoconf support, including autogen.sh, has been removed.  See details about cmake, below.
+* With the addition of json_tokener_get_parse_end(), access to internal fields of json_tokener, as well as use of many other symbols and types in json_tokener.h, is deprecated now.
+* The use of Android.configure.mk to build for Android no longer works, and it is unknown how (or if) the new cmake-based build machinery can be used.
+    * Reports of success, or pull requests to correct issues are welcome.
+
+## Notable improvements and new features
+
+### Builds and documentation
+* Build machinery has been switched to CMake.  See README.md for details about how to build.
+    * TL;DR: `mkdir build ; cd build ; cmake -DCMAKE_INSTALL_PREFIX=/some/path ../json-c ; make all test install`
+    * To ease the transition, there is a `cmake-configure` wrapper that emulates the old autoconf-based configure script.
+    * This has enabled improvements to the build on Windows system; also all public functions have been fixed to be properly exported.  For best results, use Visual Studio 2015 or newer.
+* The json-c style guide has been updated to specify the use of clang-format, and all code has been reformatted.
+    * Since many lines of code have trivial changes now, when using git blame, be sure to specify -w
+* Numerous improvements have been made to the documentation including function effects on refcounts, when passing a NULL is safe, and so on.
+
+### json_tokener changes
+* Added a json_tokener_get_parse_end() function to replace direct access of tok->char_offset.
+    * The char_offset field, and the rest of the json_tokener structure remain exposed for now, but expect a future release to hide it like is done with json_object_private.h
+* json_tokener_parse_ex() now accepts a new JSON_TOKENER_VALIDATE_UTF8 flag to validate that input is UTF8.
+    * If validation fails, json_tokener_get_error(tok) will return json_tokener_error_parse_utf8_string (see enum json_tokener_error).
+
+### Other changes and additions
+* Add support for unsigned 64-bit integers, uint64_t, to gain one extra bit of magnitude for positive ints.
+    * json_tokener will now parse values up to UINT64_MAX (18446744073709551615)
+    * Existing methods returning int32_t or int64_t will cap out-of-range values at INT32_MAX or INT64_MAX, preserving existing behavior.
+    * The implementation includes the possibility of easily extending this to larger sizes in the future.
+* A total of 7 new functions were added:
+    * json_object_get_uint64 ( struct json_object const* jso )
+    * json_object_new_uint64 ( uint64_t i )
+    * json_object_set_uint64 ( struct json_object* jso, uint64_t new_value )
+    * json_parse_uint64 ( char const* buf, uint64_t* retval )
+        * See description of uint64 support, above.
+    * json_tokener_get_parse_end ( struct json_tokener* tok )
+        * See details under "json_tokener changes", above.
+    * json_object_from_fd_ex ( int fd, int in_depth )
+        * Allows the max nesting depth to be specified.
+    * json_object_new_null ( )
+        * Simply returns NULL.  Its use is not recommended.
+* The size of struct json_object has decreased from 96 bytes to 88 bytes.
+
+### Testing
+* Many updates were made to test cases, increasing code coverage.
+* There is now a quick way (JSONC_TEST_TRACE=1) to turn on shell tracing in tests.
+* To run tests, use `make test`; the old "check" target no longer exists.
+
+## Significant bug fixes
+For the full list of issues and pull requests since the previous release, please see issues_closed_for_0.14.md
+
+* [Issue #389](https://github.com/json-c/json-c/issues/389): Add an assert to explicitly crash when _ref_count is corrupted, instead of a later "double free" error.
+* [Issue #407](https://github.com/json-c/json-c/issues/407): fix incorrect casts in calls to ctype functions (isdigit and isspace) so we don't crash when asserts are enabled on certain platforms and characters > 128 are parsed.
+* [Issue #418](https://github.com/json-c/json-c/issues/418): Fix docs for json_util_from_fd and json_util_from_file to say that they return NULL on failures.
+* [Issue #422](https://github.com/json-c/json-c/issues/422): json_object.c:set errno in json_object_get_double() when called on a json_type_string object with bad content.
+* [Issue #453](https://github.com/json-c/json-c/issues/453): Fixed misalignment in JSON serialization when JSON_C_TO_STRING_SPACED and JSON_C_TO_STRING_PRETTY are used together.
+* [Issue #463](https://github.com/json-c/json-c/issues/463): fix newlocale() call to use LC_NUMERIC_MASK instead of LC_NUMERIC, and remove incorrect comment.
+* [Issue #486](https://github.com/json-c/json-c/issues/486): append a missing ".0" to negative double values to ensure they are serialized as floating point numbers.
+* [Issue #488](https://github.com/json-c/json-c/issues/488): use JSON_EXPORT on functions so they are properly exported on Windows.
+* [Issue #539](https://github.com/json-c/json-c/issues/539): use an internal-only serializer function in json_object_new_double_s() to avoid potential conflicts with user code that uses the json_object_userdata_to_json_string serializer.
+
+***
+
+0.13.1 (up to commit 0f814e5, 2018/03/04)
+=========================================
+
+* Bump the major version of the .so library generated up to 4.0 to avoid
+  conflicts because some downstream packagers of json-c had already done
+  their own bump to ".so.3" for a much older 0.12 release.
+* Add const size_t json_c_object_sizeof()
+* Avoid invalid free (and thus a segfault) when ref_count gets < 0
+* PR#394: fix handling of custom double formats that include a ".0"
+* Avoid uninitialized variable warnings in json_object_object_foreach
+* Issue #396: fix build for certain uClibc based systems.
+* Add a top level fuzz directory for fuzzers run by OSS-Fuzz
+
+
 0.13 (up to commit 5dae561, 2017/11/29)
 =================================
 
@@ -13,7 +129,7 @@ See issues_closed_for_0.13.md for a complete list.
 Deprecated and removed features:
 --------------------------------
 * All internal use of bits.h has been eliminated.  The file will be removed.
-	Do not use: hexdigit(), error_ptr(), error_descrition() and it_error() 
+	Do not use: hexdigit(), error_ptr(), error_descrition() and it_error()
 * lh_abort() is deprecated.  It will be removed.
 
 Behavior changes:
@@ -156,11 +272,11 @@ List of new functions added:
   * Make the json_tokener_errors array local.  It has been deprecated for
      a while, and json_tokener_error_desc() should be used instead.
 
-  * change the floating point output format to %.17g so values with 
+  * change the floating point output format to %.17g so values with
      more than 6 digits show up in the output.
 
   * Remove the old libjson.so name compatibility support.  The library is
-      only created as libjson-c.so now and headers are only installed 
+      only created as libjson-c.so now and headers are only installed
       into the ${prefix}/json-c directory.
 
   * When supported by the linker, add the -Bsymbolic-functions flag.
@@ -226,7 +342,7 @@ List of new functions added:
   * Allow json_tokener_parse_ex() to be re-used to parse multiple object.
      Also, fix some parsing issues with capitalized hexadecimal numbers and
      number in E notation.
-  * Add json_tokener_get_error() and json_tokener_error_desc() to better 
+  * Add json_tokener_get_error() and json_tokener_error_desc() to better
      encapsulate the process of retrieving errors while parsing.
   * Various improvements to the documentation of many functions.
   * Add new json_object_array_sort() function.
@@ -273,7 +389,7 @@ List of new functions added:
     Brent Miller, bdmiller at yahoo dash inc dot com
   * Disable REFCOUNT_DEBUG by default in json_object.c
   * Don't use this as a variable, so we can compile with a C++ compiler
-  * Add casts from void* to type of assignment when using malloc 
+  * Add casts from void* to type of assignment when using malloc
   * Add #ifdef __cplusplus guards to all of the headers
   * Add typedefs for json_object, json_tokener, array_list, printbuf, lh_table
     Michael Clark, <michael@metaparadigm.com>
@@ -309,7 +425,7 @@ List of new functions added:
 0.6
 ===
   * Fix bug in escaping of control characters
-    Johan Bj<EFBFBD>rklund, johbjo09 at kth dot se
+    Johan Björklund, johbjo09 at kth dot se
   * Remove include "config.h" from headers (should only
     be included from .c files)
     Michael Clark <michael@metaparadigm.com>
@@ -357,13 +473,13 @@ List of new functions added:
     Added a Win32/Win64 compliant implementation of strndup
   * json_util.c - C. Watford (christopher.watford@gmail.com)
     Added cast and mask to suffice size_t v. unsigned int conversion
-    correctness 
+    correctness
   * json_tokener.c - sign reversal issue on error info for nested object parse
-    spotted by Johan Bj<EFBFBD>rklund (johbjo09 at kth.se)
+    spotted by Johan Björklund (johbjo09 at kth.se)
   * json_object.c - escape " in json_escape_str
   * Change to automake and libtool to build shared and static library
     Michael Clark <michael@metaparadigm.com>
-	
+
 0.1
 ===
   * initial release

INSTALL

@@ -1,3 +1,2 @@
 
 See README.md for installation instructions.
-

Makefile.am

@@ -1,118 +0,0 @@
-EXTRA_DIST = README.md README.html
-EXTRA_DIST += config.h.win32
-EXTRA_DIST += Doxyfile
-EXTRA_DIST += issues_closed_for_0.13.md
-
-dist-hook:
-	test -d "$(distdir)/doc" || mkdir "$(distdir)/doc"
-	chmod -R u+w "$(distdir)/doc"
-	cd "$(distdir)" && doxygen
-
-SUBDIRS = . tests
-
-lib_LTLIBRARIES = libjson-c.la
-
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = json-c.pc
-
-libjson_cincludedir = $(includedir)/json-c
-libjson_cinclude_HEADERS = \
-	arraylist.h \
-	bits.h \
-	debug.h \
-	json.h \
-	json_c_version.h \
-	json_config.h \
-	json_inttypes.h \
-	json_object.h \
-	json_object_iterator.h \
-	json_pointer.h \
-	json_tokener.h \
-	json_util.h \
-	json_visit.h \
-	linkhash.h \
-	printbuf.h
-
-noinst_HEADERS=\
-	json_object_private.h \
-	math_compat.h \
-	strdup_compat.h \
-	snprintf_compat.h \
-	vasprintf_compat.h \
-	random_seed.h \
-	strerror_override.h
-
-libjson_c_la_LDFLAGS = -version-info 3:0:0 -no-undefined @JSON_BSYMBOLIC_LDFLAGS@
-
-libjson_c_la_SOURCES = \
-	arraylist.c \
-	debug.c \
-	json_c_version.c \
-	json_object.c \
-	json_object_iterator.c \
-	json_pointer.c \
-	json_tokener.c \
-	json_util.c \
-	json_visit.c \
-	linkhash.c \
-	printbuf.c \
-	random_seed.c \
-	strerror_override.c \
-	strerror_override_private.h
-
-
-DISTCLEANFILES=
-DISTCLEANFILES+= \
-	config.h \
-	json-c-uninstalled.pc \
-	json-c.pc \
-	json_config.h
-
-distclean-local:
-	-rm -rf $(testsubdir)
-
-JSON_CLEANFILES=
-JSON_CLEANFILES+= \
-	Makefile.in \
-	aclocal.m4 \
-	autom4te.cache/ \
-	compile \
-	config.guess \
-	config.h.in \
-	config.sub \
-	configure \
-	depcomp \
-	install-sh \
-	ltmain.sh \
-	missing \
-	test-driver \
-	tests/Makefile.in
-JSON_CLEANFILES+= \
-	libtool \
-	stamp-h1 \
-	stamp-h2
-
-# There's no built-in way to remove these after all the other
-# maintainer-clean steps happen, so do it explicitly here.
-really-clean:
-	$(MAKE) maintainer-clean
-	rm -rf ${JSON_CLEANFILES}
-
-uninstall-local:
-	rm -rf "$(DESTDIR)@includedir@/json-c"
-	rm -f "$(DESTDIR)@includedir@/json"
-
-ANDROID_CFLAGS = -I$(top_srcdir) -DHAVE_CONFIG_H
-
-Android.mk: Makefile.am
-	androgenizer -:PROJECT json-c \
-		-:SHARED libjson-c \
-		-:TAGS eng debug \
-		-:REL_TOP $(top_srcdir) -:ABS_TOP $(abs_top_srcdir) \
-		-:SOURCES $(libjson_c_la_SOURCES) $(nodist_libjson_c_la_SOURCES) \
-		-:CFLAGS $(DEFS) $(ANDROID_CFLAGS) $(libjson_c_la_CFLAGS) \
-		-:LDFLAGS $(libjson_c_la_LDFLAGS) $(libjson_c_la_LIBADD) \
-		-:HEADER_TARGET json-c \
-		-:HEADERS $(libjson_cinclude_HEADERS) \
-		-:PASSTHROUGH LOCAL_ARM_MODE:=arm \
-	> $@

README.html

@@ -8,8 +8,8 @@
 		<h2>JSON-C - A JSON implementation in C</h2>
 
 		<h3>Overview</h3>
-		<p>JSON-C implements a reference counting object model that allows you to easily 
-		construct JSON objects in C, output them as JSON formatted strings and parse 
+		<p>JSON-C implements a reference counting object model that allows you to easily
+		construct JSON objects in C, output them as JSON formatted strings and parse
 		JSON formatted strings back into the C representation of JSON objects.
 		It aims to conform to <a href="https://tools.ietf.org/html/rfc7159">RFC 7159</a>.
 		</p>
@@ -26,8 +26,7 @@
 		</ul>
 
 		<h3>Documentation</h3>
-		<P>Doxygen generated documentation exists <a href="doc/html/json__object_8h.html">here</a>
-		and Win32 specific notes can be found <a href="README-WIN32.html">here</a>.</P>
+		<P>Doxygen generated documentation exists <a href="http://json-c.github.io/json-c/">here</a>.</P>
 
 		<h3><a href="https://github.com/json-c/json-c">GIT Reposository</a></h3>
 		<p><strong><code>git clone https://github.com/json-c/json-c.git</code></strong></p>

README.json_object-split.md

@@ -0,0 +1,15 @@
+
+This branch implements the changes briefly described at:
+
+https://github.com/json-c/json-c/wiki/Proposal:-struct-json_object-split
+
+These were originally mentioned in:
+Issue #535 - short string optimization: excessive array length
+
+The changes are expected to impact and possibly invalidate:
+Issue #552 - Some anlysis about memory allocator in json-c
+
+and will likely cause notable conflicts in any other significant un-merged
+changes, such as PR#620 - Introduce json_object_new_string_{ext,noalloc}()
+
+

README.md

@@ -1,12 +1,15 @@
-`json-c`                       {#mainpage}
+`json-c`
 ========
 
 1. [Overview and Build Status](#overview)
 2. [Building on Unix](#buildunix)
-3. [Install Prerequisites](#installprereq)
-4. [Building with partial threading support](#buildthreaded)
-5. [Linking to libjson-c](#linking)
-6. [Using json-c](#using)
+    * [Prerequisites](#installprereq)
+    * [Build commands](#buildcmds)
+3. [CMake options](#CMake)
+4. [Testing](#testing)
+5. [Building with `vcpkg`](#buildvcpkg)
+6. [Linking to libjson-c](#linking)
+7. [Using json-c](#using)
 
 JSON-C - A JSON implementation in C <a name="overview"></a>
 -----------------------------------
@@ -15,126 +18,193 @@ Build Status
 * [AppVeyor Build](https://ci.appveyor.com/project/hawicz/json-c) ![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/github/json-c/json-c?branch=master&svg=true)
 * [Travis Build](https://travis-ci.org/json-c/json-c) ![Travis Build Status](https://travis-ci.org/json-c/json-c.svg?branch=master)
 
-JSON-C implements a reference counting object model that allows you to easily 
-construct JSON objects in C, output them as JSON formatted strings and parse 
+Test Status
+* [Coveralls](https://coveralls.io/github/json-c/json-c?branch=master) [![Coverage Status](https://coveralls.io/repos/github/json-c/json-c/badge.svg?branch=master)](https://coveralls.io/github/json-c/json-c?branch=master)
+
+JSON-C implements a reference counting object model that allows you to easily
+construct JSON objects in C, output them as JSON formatted strings and parse
 JSON formatted strings back into the C representation of JSON objects.
 It aims to conform to [RFC 7159](https://tools.ietf.org/html/rfc7159).
 
-
-Building on Unix with `git`, `gcc` and `autotools` <a name="buildunix"></a>
+Building on Unix with `git`, `gcc` and `cmake` <a name="buildunix"></a>
 --------------------------------------------------
 
 Home page for json-c: https://github.com/json-c/json-c/wiki
 
-### Prerequisites:
-
-See also the "Installing prerequisites" section below.
+### Prerequisites: <a name="installprereq"></a>
 
  - `gcc`, `clang`, or another C compiler
- - `libtool>=2.2.6b`
 
-If you're not using a release tarball, you'll also need:
+ - cmake>=2.8, >=3.16 recommended
 
- - `autoconf>=2.64` (`autoreconf`)
- - `automake>=1.13`
-
-Make sure you have a complete `libtool` install, including `libtoolize`.
-
-To generate docs (e.g. as part of make distcheck) you'll also need:
+To generate docs you'll also need:
  - `doxygen>=1.8.13`
 
-### Build instructions:
+If you are on a relatively modern system, you'll likely be able to install
+the prerequisites using your OS's packaging system.
+
+### Install using apt (e.g. Ubuntu 16.04.2 LTS)
+```sh
+sudo apt install git
+sudo apt install cmake
+sudo apt install doxygen  # optional
+sudo apt install valgrind # optional
+```
+
+### Build instructions:  <a name="buildcmds"></a>
 
 `json-c` GitHub repo: https://github.com/json-c/json-c
 
 ```sh
 $ git clone https://github.com/json-c/json-c.git
-$ cd json-c
-$ sh autogen.sh
+$ mkdir json-c-build
+$ cd json-c-build
+$ cmake ../json-c   # See CMake section below for custom arguments
 ```
 
-followed by
+Note: it's also possible to put your build directory inside the json-c
+source directory, or even not use a separate build directory at all, but
+certain things might not work quite right (notably, `make distcheck`)
+
+Then:
 
 ```sh
-$ ./configure  # --enable-threading
 $ make
+$ make test
+$ make USE_VALGRIND=0 test   # optionally skip using valgrind
 $ make install
 ```
 
-To build and run the test programs:
+
+### Generating documentation with Doxygen:
+
+The libray documentation can be generated directly from the source codes using Doxygen tool:
 
 ```sh
-$ make check
-$ make USE_VALGRIND=0 check   # optionally skip using valgrind
-```
-
-Install prerequisites <a name="installprereq"></a>
------------------------
-
-If you are on a relatively modern system, you'll likely be able to install
-the prerequisites using your OS's packaging system.  
-
-### Install using apt (e.g. Ubuntu 16.04.2 LTS)
-```sh
-sudo apt install git
-sudo apt install autoconf automake libtool
-sudo apt install valgrind # optional
-```
-
-Then start from the "git clone" command, above.
-
-### Manually install and build autoconf, automake and libtool
-
-For older OS's that don't have up-to-date version of the packages will
-require a bit more work. For example, CentOS release 5.11, etc...
-
-```sh
-curl -O http://ftp.gnu.org/gnu/autoconf/autoconf-2.69.tar.gz
-curl -O http://ftp.gnu.org/gnu/automake/automake-1.15.tar.gz
-curl -O http://ftp.gnu.org/gnu/libtool/libtool-2.2.6b.tar.gz
-
-tar xzf autoconf-2.69.tar.gz
-tar xzf automake-1.15.tar.gz
-tar xzf libtool-2.2.6b.tar.gz
-
-export PATH=${HOME}/ac_install/bin:$PATH
-
-(cd autoconf-2.69 && \
-  ./configure --prefix ${HOME}/ac_install && \
-  make && \
-  make install)
-
-(cd automake-1.15 && \
-  ./configure --prefix ${HOME}/ac_install && \
-  make && \
-  make install)
-
-(cd libtool-2.2.6b && \
-  ./configure --prefix ${HOME}/ac_install && \
-  make && \
-  make install)
+# in build directory
+make doc
+google-chrome doc/html/index.html
 ```
 
 
-Building with partial threading support <a name="buildthreaded"></a>
-----------------------------------------
+CMake Options <a name="CMake"></a>
+--------------------
+
+The json-c library is built with [CMake](https://cmake.org/cmake-tutorial/),
+which can take a few options.
+
+Variable                     | Type   | Description
+-----------------------------|--------|--------------
+CMAKE_INSTALL_PREFIX         | String | The install location.
+CMAKE_BUILD_TYPE             | String | Defaults to "debug".
+BUILD_SHARED_LIBS            | Bool   | The default build generates a dynamic (dll/so) library.  Set this to OFF to create a static library only.
+BUILD_STATIC_LIBS            | Bool   | The default build generates a static (lib/a) library.  Set this to OFF to create a shared library only.
+DISABLE_BSYMBOLIC            | Bool   | Disable use of -Bsymbolic-functions.
+DISABLE_THREAD_LOCAL_STORAGE | Bool   | Disable use of Thread-Local Storage (HAVE___THREAD).
+DISABLE_WERROR               | Bool   | Disable use of -Werror.
+ENABLE_RDRAND                | Bool   | Enable RDRAND Hardware RNG Hash Seed.
+ENABLE_THREADING             | Bool   | Enable partial threading support.
+
+Pass these options as `-D` on CMake's command-line.
+
+```sh
+# build a static library only
+cmake -DBUILD_SHARED_LIBS=OFF ..
+```
+
+### Building with partial threading support
 
 Although json-c does not support fully multi-threaded access to
-object trees, it has some code to help make use in threaded programs
+object trees, it has some code to help make its use in threaded programs
 a bit safer.  Currently, this is limited to using atomic operations for
 json_object_get() and json_object_put().
 
 Since this may have a performance impact, of at least 3x slower
 according to https://stackoverflow.com/a/11609063, it is disabled by
-default.  You may turn it on by adjusting your configure command with:
-   --enable-threading
+default.  You may turn it on by adjusting your cmake command with:
+   -DENABLE_THREADING=ON
 
 Separately, the default hash function used for object field keys,
-lh_char_hash, uses a compare-and-swap operation to ensure the randomly
+lh_char_hash, uses a compare-and-swap operation to ensure the random
 seed is only generated once.  Because this is a one-time operation, it
 is always compiled in when the compare-and-swap operation is available.
 
 
+### cmake-configure wrapper script
+
+For those familiar with the old autoconf/autogen.sh/configure method,
+there is a `cmake-configure` wrapper script to ease the transition to cmake.
+
+```sh
+mkdir build
+cd build
+../cmake-configure --prefix=/some/install/path
+make
+```
+
+cmake-configure can take a few options.
+
+| options | Description|
+| ---- | ---- |
+| prefix=PREFIX |  install architecture-independent files in PREFIX |
+| enable-threading |  Enable code to support partly multi-threaded use |
+| enable-rdrand | Enable RDRAND Hardware RNG Hash Seed generation on supported x86/x64 platforms. |
+| enable-shared  |  build shared libraries [default=yes] |
+| enable-static  |  build static libraries [default=yes] |
+| disable-Bsymbolic |  Avoid linking with -Bsymbolic-function |
+| disable-werror |  Avoid treating compiler warnings as fatal errors |
+
+
+Testing:  <a name="testing"></a>
+----------
+
+By default, if valgrind is available running tests uses it.
+That can slow the tests down considerably, so to disable it use:
+```sh
+export USE_VALGRIND=0
+```
+
+To run tests a separate build directory is recommended:
+```sh
+mkdir build-test
+cd build-test
+# VALGRIND=1 causes -DVALGRIND=1 to be passed when compiling code
+# which uses slightly slower, but valgrind-safe code.
+VALGRIND=1 cmake ..
+make
+
+make test
+# By default, if valgrind is available running tests uses it.
+make USE_VALGRIND=0 test   # optionally skip using valgrind
+```
+
+If a test fails, check `Testing/Temporary/LastTest.log`,
+`tests/testSubDir/${testname}/${testname}.vg.out`, and other similar files.
+If there is insufficient output try:
+```sh
+VERBOSE=1 make test
+```
+or
+```sh
+JSONC_TEST_TRACE=1 make test
+```
+and check the log files again.
+
+
+Building on Unix and Windows with `vcpkg` <a name="buildvcpkg"></a>
+--------------------------------------------------
+
+You can download and install JSON-C using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    vcpkg install json-c
+
+The JSON-C port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
+
+
 Linking to `libjson-c` <a name="linking">
 ----------------------
 
@@ -169,5 +239,4 @@ following more specific header files:
 * json_visit.h   - Methods for walking a tree of json-c objects.
 * json_util.h    - Miscelleanous utility functions.
 
-For a full list of headers see [files.html](files.html)
-
+For a full list of headers see [files.html](http://json-c.github.io/json-c/json-c-0.13.1/doc/html/files.html)

RELEASE_CHECKLIST.txt

@@ -1,73 +1,96 @@
 
-Release checklist:
+# Release checklist:
 
-release=0.12
-git clone https://github.com/json-c/json-c json-c-${release}
-cd json-c-${release}
+## Pre-release tasks
+
+* Figure out whether a release is worthwhile to do.
+* Analyze the previous release branch to see if anything should have been
+  applied to master.
+* Collect changes and assemble tentative release notes.
+    * Identify previous release branch point
+    * Check commit logs between previous branch point and now for
+       notable changes worth mentioning
+    * Create a new issues_closed_for_X.Y.md file
+        * Include notable entries from here in the release notes.
+    * Analyze APIs between previous release branch and master to produce list of
+      changes (added/removed/updated funcs, etc...), and detect backwards compat
+      issues.
+        * https://github.com/lvc/abi-compliance-checker
+        * If the new release is not backwards compatible, then this is a MAJOR release.
+        * Mention removed features in ChangeLog
+    * Update the AUTHORS file
+    * Exclude mentioning changes that have already been included in a point 
+      release of the previous release branch.
+
+* Update ChangeLog with relevant notes before branching.
+
+* Check that the compile works on Linux - automatic through Travis
+* Check that the compile works on NetBSD
+* Check that the compile works on Windows - automatic through AppVeyor
+
+## Release creation
+
+Start creating the new release:
+    release=0.15
+    git clone https://github.com/json-c/json-c json-c-${release}
+
+    mkdir distcheck
+    cd distcheck
+    # Note, the build directory *must* be entirely separate from
+    # the source tree for distcheck to work properly.
+    cmake ../json-c-${release}
+    make distcheck
+    cd ..
 
-Check that the compile works on Linux
-Check that the compile works on NetBSD
-Check that the compile works on Windows
-Run "make distcheck" and fix any problems
-	 (e.g. adding new files to SOURCES variables in Makefile.am)
-Check ChangeLog to see if anything should be added.
 Make any fixes/changes *before* branching.
 
-  git branch json-c-${release}
-  git checkout json-c-${release}
+    cd json-c-${release}
+    git branch json-c-${release}
+    git checkout json-c-${release}
 
 ------------
 
-Update the version in json_c_version.h
-Update the version in Doxyfile
-Update the version in configure.ac
-Update the version in CMakeLists.txt
-	Use ${release}.
+Using ${release}:
+	Update the version in json_c_version.h
+	Update the version in CMakeLists.txt (VERSION in the project(...) line)
+	Update the version in config.h.win32 (several places)
 
-Update the libjson_la_LDFLAGS line in Makefile.am to the new version.
-	Generally, unless we're doing a major release, change:
-		-version-info x:y:z
-	to
-		-version-info x:y+1:z
+Update the set_target_properties() line in CmakeLists.txt to set the shared
+library version.  Generally, unless we're doing a major release, change:
+	VERSION x.y.z
+to
+	VERSION x.y+1.z
 
-------------
-
-Generate the configure script and other files:
-  sh autogen.sh
-  git add -f Makefile.in aclocal.m4 config.guess config.h.in \
-       config.sub configure depcomp install-sh \
-       ltmain.sh missing tests/Makefile.in \
-       INSTALL
-
-  # check for anything else to be added:
-  git status --ignored
-  git commit
+    git commit -a -m "Bump version to ${release}"
 
 ------------
 
 Generate the doxygen documentation:
-  doxygen
-  git add -f doc
-  git commit doc
+
+    doxygen
+    git add -f doc
+    git commit doc
 
 ------------
 
-cd ..
-echo .git > excludes
-echo autom4te.cache >> excludes
-tar -czf json-c-${release}.tar.gz -X excludes json-c-${release}
+Create the release tarballs:
 
-echo doc >> excludes
-tar -czf json-c-${release}-nodoc.tar.gz -X excludes json-c-${release}
+    cd ..
+    echo .git > excludes
+    tar -czf json-c-${release}.tar.gz -X excludes json-c-${release}
+
+    echo doc >> excludes
+    tar -czf json-c-${release}-nodoc.tar.gz -X excludes json-c-${release}
 
 ------------
 
 Tag the branch:
-cd json-c-${release}
-git tag -a json-c-${release}-$(date +%Y%m%d) -m "Release json-c-${release}"
 
-git push origin json-c-${release}
-git push --tags
+    cd json-c-${release}
+    git tag -a json-c-${release}-$(date +%Y%m%d) -m "Release json-c-${release}"
+
+    git push origin json-c-${release}
+    git push --tags
 
 ------------
 
@@ -75,7 +98,7 @@ Go to Amazon S3 service at:
     https://console.aws.amazon.com/s3/
 
 Upload the two tarballs in the json-c_releases folder.
-	When uploading, use "Reduced Redundancy", and make the uploaded files publicly accessible.
+	When uploading, use "Standard" storage class, and make the uploaded files publicly accessible.
 
 Logout of Amazon S3, and verify that the files are visible.
     https://s3.amazonaws.com/json-c_releases/releases/index.html
@@ -84,48 +107,51 @@ Logout of Amazon S3, and verify that the files are visible.
 
 Post-release checklist:
 
-git checkout master
-Add new section to ChangeLog
-Update the version in json_c_version.h
-Update the version in Doxyfile
-Update the version in configure.ac
-Update the version in CMakeLists.txt
-    Use ${release}.99 to indicate a version "newer" than anything on the branch.
+    git checkout master
 
-Leave the libjson_la_LDFLAGS line in Makefile.am alone.
-	For more details see:
-	http://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
+Add new section to ChangeLog for ${release}+1
+
+Use ${release}.99 to indicate a version "newer" than anything on the branch:
+	Update the version in json_c_version.h
+	Update the version in CMakeLists.txt
+	Update the version in config.h.win32
+
+Update RELEASE_CHECKLIST.txt, set release=${release}+1
+
+Update the set_target_properties() line in CmakeLists.txt to match the release branch.
+
+    git commit -a -m "Update the master branch to version 0.${release}.99"
+    git push
 
 ------------
 
 Update the gh-pages branch with new docs:
 
-cd json-c-${release}
-git checkout json-c-${release}
-cd ..
+    cd json-c-${release}
+    git checkout json-c-${release}
+    cd ..
 
-git clone -b gh-pages https://github.com/json-c/json-c json-c-pages
-cd json-c-pages
-mkdir json-c-${release}
-cp -R ../json-c-${release}/doc json-c-${release}/.
-cp ../json-c-${release}/README-WIN32.html json-c-${release}/.
-git add json-c-${release}
-git commit
+    git clone -b gh-pages https://github.com/json-c/json-c json-c-pages
+    cd json-c-pages
+    mkdir json-c-${release}
+    cp -R ../json-c-${release}/doc json-c-${release}/.
+    git add json-c-${release}
+    git commit -a -m "Add the ${release} docs."
 
-vi index.html
-    Add/change links to current release.
+    vi index.html
+    # Add/change links to current release.
 
-git commit index.html
+    git commit -a -m "Update the doc links to point at ${release}"
 
-git push
+    git push
 
 ------------
 
 Update checksums on wiki page.
 
-cd ..
-openssl sha -sha256 json-c*gz
-openssl md5 json-c*gz
+    cd ..
+    openssl sha -sha256 json-c*gz
+    openssl md5 json-c*gz
 
 Copy and paste this output into the wiki page at:
 	https://github.com/json-c/json-c/wiki
@@ -133,4 +159,3 @@ Copy and paste this output into the wiki page at:
 ------------
 
 Send an email to the mailing list.
-

STYLE.txt

@@ -1,31 +1,31 @@
-In general:
-For minor changes to a function, copy the existing formatting.
-When changing the style, commit that separately from other changes.
-For new code and major changes to a function, switch to the official json-c style.
-
-Official json-c style:
-Aim for readability, not strict conformance to fixed style rules.
-These rules are not comprehensive.  Look to existing code for guidelines.
-Indentation is tab based, with continuations of long lines starting with tabs then spaces for alignment.
-Try to line up components of continuation lines with corresponding part of the line above (i.e. "indent -lp" effect), but avoid excessive identation tha causes extra line wraps. 
- e.g. (T=tab, S=space):
-TTTTsome_long_func_call(arg1, arg2,
-TTTTSSSSSSSSSSSSSSSSSSSarg3, arg4);
-TTTTsome_reallly_really_long_func_name(arg1,
-TTTTTarg2, arg3, arg4);
-There should be a space between "if"/"while" and the following parenthesis.
-"case" lines are indented at the same level as the "switch" statement.
-Commas are followed by a single space.
-Include spaces around most non-unary, non-postfix operators, "=", "==', "&", "||", etc...
-Function calls have no space between the name and the parenthesis.
-Curly braces go on their own line.
-Curly braces may be omitted.
-
-Naming:
-Words within function and variable names are separated with underscores.  Avoid camel case.
-Prefer longer, more descriptive names, but not excessively so.  No single letter variable names.
-
-Other:
-Variables should be defined for the smallest scope needed.
-Functions should be defined static when possible.
-When possible, avoid exposing internals in the public API.
+In general:
+For minor changes to a function, copy the existing formatting.
+When changing the style, commit that separately from other changes.
+For new code and major changes to a function, switch to the official json-c style.
+
+Official json-c style:
+
+Aim for readability, not strict conformance to fixed style rules.
+Formatting is tab based; previous attempts at proper alignment with
+spaces for continuation lines have been abandoned in favor of the
+convenience of using clang-format.
+Refer to the .clang-format file for details, and run the tool before commit:
+
+    clang-format -i somefile.c foo.h
+
+For sections of code that would be significantly negatively impacted, surround
+them with magic comments to disable formatting:
+
+    /* clang-format off */
+    ...code...
+    /* clang-format on */
+
+
+Naming:
+Words within function and variable names are separated with underscores.  Avoid camel case.
+Prefer longer, more descriptive names, but not excessively so.  No single letter variable names.
+
+Other:
+Variables should be defined for the smallest scope needed.
+Functions should be defined static when possible.
+When possible, avoid exposing internals in the public API.

apps/CMakeLists.txt

@@ -0,0 +1,122 @@
+
+cmake_minimum_required(VERSION 2.8)  # see ../CMakeLists.txt for why 2.8
+
+if(POLICY CMP0075)
+    cmake_policy(SET CMP0075 NEW)
+endif()
+
+include(CheckSymbolExists)
+include(CheckIncludeFile)
+include(CMakePackageConfigHelpers)
+
+# First, sort out whether we're running inside a json-c build,
+#  or standalone, such as part of a benchmark build.
+
+if ("${PROJECT_NAME}" STREQUAL "json-c")
+# Part of an overall json-c build
+set(APPS_LINK_LIBS "${PROJECT_NAME}")
+
+# We know we have this in our current sources:
+set(HAVE_JSON_TOKENER_GET_PARSE_END)
+
+else()
+
+# Standalone mode, using an already installed json-c library, somewhere.
+# The path to the json-c install must be specified with -DCMAKE_PREFIX_PATH=...
+
+project(apps)
+find_package(PkgConfig)
+
+# PkgConfig is supposed to include CMAKE_PREFIX_PATH in the PKG_CONFIG_PATH
+#  that's used when running pkg-config, but it just doesn't work :(
+# https://gitlab.kitware.com/cmake/cmake/issues/18150
+#set(PKG_CONFIG_USE_CMAKE_PREFIX_PATH True)
+
+# Instead, we handle it explicitly here and update PKG_CONFIG_PATH ourselves.
+if (NOT CMAKE_PREFIX_PATH)
+	message(FATAL_ERROR "Please specify -DCMAKE_PREFIX_PATH=... when running cmake.")
+endif()
+
+# Note: find_file isn't recursive :(
+find_file(PC_FILE_PATH "json-c.pc"
+	PATHS "${CMAKE_PREFIX_PATH}/lib64" "${CMAKE_PREFIX_PATH}/lib"
+	PATH_SUFFIXES "pkgconfig"
+	NO_DEFAULT_PATH)
+get_filename_component(PC_DIR_PATH "${PC_FILE_PATH}" DIRECTORY)
+set(ENV{PKG_CONFIG_PATH} "$ENV{PKG_CONFIG_PATH}:${PC_DIR_PATH}")
+message(STATUS "PC_FILE_PATH=${PC_FILE_PATH}")
+message(STATUS "PC_DIR_PATH=${PC_DIR_PATH}")
+
+pkg_check_modules(PC_JSONC json-c)
+if (PC_JSONC_FOUND)
+	message(STATUS "Found json-c using pkg-config: ${PC_JSONC_PREFIX}")
+	message(STATUS " PC_JSONC_INCLUDE_DIRS=${PC_JSONC_INCLUDE_DIRS}")
+	message(STATUS " PC_JSONC_LIBRARIES=${PC_JSONC_LIBRARIES}")
+	message(STATUS " PC_JSONC_LIBRARY_DIRS=${PC_JSONC_LIBRARY_DIRS}")
+	link_directories(${PC_JSONC_LIBRARY_DIRS})
+	include_directories(${PC_JSONC_INCLUDE_DIRS})
+	# for target_link_libraries(...)
+	set(APPS_INCLUDE_DIRS ${PC_JSONC_INCLUDE_DIRS})
+	set(APPS_LINK_DIRS ${PC_JSONC_LIBRARY_DIRS})
+	set(APPS_LINK_LIBS ${PC_JSONC_LIBRARIES})
+else()
+	message(STATUS "Using find_package to locate json-c")
+
+	# Note: find_package needs CMAKE_PREFIX_PATH set appropriately.
+	# XXX json-c's installed cmake files don't actually set up what's
+	#  needed to use find_package() by itself, so we're just using it
+	#  to confirm the top of the install location.
+	find_package(json-c CONFIG)  # sets json-c_DIR
+
+	# Assume json-c-config.cmake is in lib64/cmake/json-c/
+	get_filename_component(json-c_TOP "${json-c_DIR}/../../.." ABSOLUTE)
+	get_filename_component(json-c_LIBDIR "${json-c_DIR}/../.." ABSOLUTE)
+
+	message(STATUS " json-c_TOP=${json-c_TOP}")
+	message(STATUS " json-c_DIR=${json-c_DIR}")
+	message(STATUS " json-c_LIBDIR=${json-c_LIBDIR}")
+
+	link_directories(${json-c_LIBDIR})
+	include_directories(${json-c_TOP}/include)
+	include_directories(${json-c_TOP}/include/json-c)
+	set(APPS_LINK_DIRS "${json-c_LIBDIR}")
+	set(APPS_INCLUDE_DIRS "${json-c_TOP}/include;${json-c_TOP}/include/json-c")
+
+	set(APPS_LINK_LIBS json-c)
+endif()
+
+set(CMAKE_REQUIRED_LINK_OPTIONS "-L${APPS_LINK_DIRS}")
+set(CMAKE_REQUIRED_LIBRARIES ${APPS_LINK_LIBS})
+set(CMAKE_REQUIRED_INCLUDES ${APPS_INCLUDE_DIRS})
+check_symbol_exists(json_tokener_get_parse_end "json_tokener.h" HAVE_JSON_TOKENER_GET_PARSE_END)
+
+endif() # end "standalone mode" block
+
+# ---------------------------------
+
+check_include_file(sys/resource.h   HAVE_SYS_RESOURCE_H) # for getrusage
+if (HAVE_SYS_RESOURCE_H)
+    check_symbol_exists(getrusage   "sys/resource.h" HAVE_GETRUSAGE)
+endif()
+
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/apps_config.h.in
+               ${PROJECT_BINARY_DIR}/apps_config.h)
+message(STATUS "Wrote ${PROJECT_BINARY_DIR}/apps_config.h")
+
+# ---------------------------------
+
+include_directories(PUBLIC ${CMAKE_SOURCE_DIR})
+include_directories(${PROJECT_SOURCE_DIR})
+include_directories(${PROJECT_BINARY_DIR})
+
+# ---------------------------------
+
+# Now, finally, the actual executables we're building:
+
+add_executable(json_parse json_parse.c)
+target_link_libraries(json_parse PRIVATE ${APPS_LINK_LIBS})
+
+# Note: it is intentional that there are no install instructions here yet.
+# When/if the interface of the app(s) listed here settles down enough to
+# publish as part of a regular build that will be added.
+

apps/cmake/apps_config.h.in

@@ -0,0 +1,8 @@
+
+/* Define to 1 if you have the <sys/resource.h> header file. */
+#cmakedefine HAVE_SYS_RESOURCE_H
+
+/* Define if you have the `getrusage' function. */
+#cmakedefine HAVE_GETRUSAGE
+
+#cmakedefine HAVE_JSON_TOKENER_GET_PARSE_END

apps/json_parse.c

@@ -0,0 +1,187 @@
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "apps_config.h"
+
+/* XXX for a regular program, these should be <json-c/foo.h>
+ * but that's inconvenient when building in the json-c source tree.
+ */
+#include "json_object.h"
+#include "json_tokener.h"
+#include "json_util.h"
+
+#ifdef HAVE_SYS_RESOURCE_H
+#include <sys/resource.h>
+#include <sys/time.h>
+#endif
+
+static int formatted_output = 0;
+static int show_output = 1;
+static int strict_mode = 0;
+static const char *fname = NULL;
+
+#ifndef HAVE_JSON_TOKENER_GET_PARSE_END
+#define json_tokener_get_parse_end(tok) ((tok)->char_offset)
+#endif
+
+static void usage(const char *argv0, int exitval, const char *errmsg);
+static void showmem(void);
+static int parseit(int fd, int (*callback)(struct json_object *));
+static int showobj(struct json_object *new_obj);
+
+static void showmem(void)
+{
+#ifdef HAVE_GETRUSAGE
+	struct rusage rusage;
+	memset(&rusage, 0, sizeof(rusage));
+	getrusage(RUSAGE_SELF, &rusage);
+	printf("maxrss: %ld KB\n", rusage.ru_maxrss);
+#endif
+}
+
+static int parseit(int fd, int (*callback)(struct json_object *))
+{
+	struct json_object *obj;
+	char buf[32768];
+	int ret;
+	int depth = JSON_TOKENER_DEFAULT_DEPTH;
+	json_tokener *tok;
+
+	tok = json_tokener_new_ex(depth);
+	if (!tok)
+	{
+		fprintf(stderr, "unable to allocate json_tokener: %s\n", strerror(errno));
+		return 1;
+	}
+	json_tokener_set_flags(tok, JSON_TOKENER_STRICT
+#ifdef JSON_TOKENER_ALLOW_TRAILING_CHARS
+		 | JSON_TOKENER_ALLOW_TRAILING_CHARS
+#endif
+	);
+
+	// XXX push this into some kind of json_tokener_parse_fd API?
+	//  json_object_from_fd isn't flexible enough, and mirroring
+	//   everything you can do with a tokener into json_util.c seems
+	//   like the wrong approach.
+	size_t total_read = 0;
+	while ((ret = read(fd, buf, sizeof(buf))) > 0)
+	{
+		total_read += ret;
+		int start_pos = 0;
+		while (start_pos != ret)
+		{
+			obj = json_tokener_parse_ex(tok, &buf[start_pos], ret - start_pos);
+			enum json_tokener_error jerr = json_tokener_get_error(tok);
+			int parse_end = json_tokener_get_parse_end(tok);
+			if (obj == NULL && jerr != json_tokener_continue)
+			{
+				char *aterr = &buf[start_pos + parse_end];
+				fflush(stdout);
+				int fail_offset = total_read - ret + start_pos + parse_end;
+				fprintf(stderr, "Failed at offset %d: %s %c\n", fail_offset,
+				        json_tokener_error_desc(jerr), aterr[0]);
+				json_tokener_free(tok);
+				return 1;
+			}
+			if (obj != NULL)
+			{
+				int cb_ret = callback(obj);
+				json_object_put(obj);
+				if (cb_ret != 0)
+				{
+					json_tokener_free(tok);
+					return 1;
+				}
+			}
+			start_pos += json_tokener_get_parse_end(tok);
+			assert(start_pos <= ret);
+		}
+	}
+	if (ret < 0)
+	{
+		fprintf(stderr, "error reading fd %d: %s\n", fd, strerror(errno));
+	}
+
+	json_tokener_free(tok);
+	return 0;
+}
+
+static int showobj(struct json_object *new_obj)
+{
+	if (new_obj == NULL)
+	{
+		fprintf(stderr, "%s: Failed to parse\n", fname);
+		return 1;
+	}
+
+	printf("Successfully parsed object from %s\n", fname);
+
+	if (show_output)
+	{
+		const char *output;
+		if (formatted_output)
+			output = json_object_to_json_string(new_obj);
+		else
+			output = json_object_to_json_string_ext(new_obj, JSON_C_TO_STRING_PRETTY);
+		printf("%s\n", output);
+	}
+
+	showmem();
+	return 0;
+}
+
+static void usage(const char *argv0, int exitval, const char *errmsg)
+{
+	FILE *fp = stdout;
+	if (exitval != 0)
+		fp = stderr;
+	if (errmsg != NULL)
+		fprintf(fp, "ERROR: %s\n\n", errmsg);
+	fprintf(fp, "Usage: %s [-f] [-n] [-s]\n", argv0);
+	fprintf(fp, "  -f - Format the output with JSON_C_TO_STRING_PRETTY\n");
+	fprintf(fp, "  -n - No output\n");
+	fprintf(fp, "  -s - Parse in strict mode, flags:\n");
+	fprintf(fp, "       JSON_TOKENER_STRICT|JSON_TOKENER_ALLOW_TRAILING_CHARS\n");
+
+	fprintf(fp, "\nWARNING WARNING WARNING\n");
+	fprintf(fp, "This is a prototype, it may change or be removed at any time!\n");
+	exit(exitval);
+}
+
+int main(int argc, char **argv)
+{
+	json_object *new_obj;
+	int opt;
+
+	while ((opt = getopt(argc, argv, "fhns")) != -1)
+	{
+		switch (opt)
+		{
+		case 'f': formatted_output = 1; break;
+		case 'n': show_output = 0; break;
+		case 's': strict_mode = 1; break;
+		case 'h': usage(argv[0], 0, NULL);
+		default: /* '?' */ usage(argv[0], EXIT_FAILURE, "Unknown arguments");
+		}
+	}
+	if (optind >= argc)
+	{
+		usage(argv[0], EXIT_FAILURE, "Expected argument after options");
+	}
+	fname = argv[optind];
+
+	int fd = open(argv[optind], O_RDONLY, 0);
+	showmem();
+	if (parseit(fd, showobj) != 0)
+		exit(EXIT_FAILURE);
+	showmem();
+
+	exit(EXIT_SUCCESS);
+}

appveyor.yml

@@ -1,39 +1,37 @@
-version: '{branch}.{build}'
-os: Windows Server 2012 R2
-
-configuration:
-- Debug
-- Release
-platform: x64
-environment:
-  matrix:
-  - PlatformToolset: v140
-  - PlatformToolset: v120
-  - PlatformToolset: Windows7.1SDK
-
-build_script:
-- cmake .
-- >
-  msbuild "json-c.vcxproj" /m /verbosity:normal
-  /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
-  /p:PlatformToolset=%PlatformToolset% /p:OutDir=lib\
-
-after_build:
-- md include\json-c
-- copy json.h include\json-c\*
-- copy debug.h include\json-c\*
-- copy linkhash.h include\json-c\*
-- copy arraylist.h include\json-c\*
-- copy json_util.h include\json-c\*
-- copy json_object.h include\json-c\*
-- copy json_tokener.h include\json-c\*
-- copy json_object_iterator.h include\json-c\*
-- copy json_c_version.h include\json-c\*
-- copy json_inttypes.h include\json-c\*
-- copy include\json_config.h include\json-c\*
-- copy json_object_private.h include\json-c\*
-- 7z a json-c.lib.zip lib\json-c.dll include\json-c\*.h
-
-artifacts:
-- path: json-c.lib.zip
-  name: json-c.lib.zip
+version: '{branch}.{build}'
+os: Windows Server 2012 R2
+
+platform: x64
+
+# There should be a better way to set-up a build matrix.
+environment:
+  matrix:
+    - b_toolset: Windows7.1SDK
+      b_config: Debug
+
+    - b_toolset: Windows7.1SDK
+      b_config: Release
+
+    - b_toolset: v120
+      b_config: Debug
+
+    - b_toolset: v120
+      b_config: Release
+
+    - b_toolset: v140
+      b_config: Debug
+
+    - b_toolset: v140
+      b_config: Release
+
+build_script:
+- cmake -T %b_toolset% -DCMAKE_BUILD_TYPE=%b_config% -DCMAKE_INSTALL_PREFIX=t_install .
+- cmake --build . --target install
+
+after_build:
+- cd t_install
+- 7z a ../json-c.win32.%b_toolset%.%b_config%.zip *
+
+artifacts:
+- path: json-c.win32.%b_toolset%.%b_config%.zip
+  name: json-c.win32.%b_toolset%.%b_config%.zip

arraylist.c

@@ -14,12 +14,12 @@
 #include <limits.h>
 
 #ifdef STDC_HEADERS
-# include <stdlib.h>
-# include <string.h>
+#include <stdlib.h>
+#include <string.h>
 #endif /* STDC_HEADERS */
 
 #if defined(HAVE_STRINGS_H) && !defined(_STRING_H) && !defined(__USE_BSD)
-# include <strings.h>
+#include <strings.h>
 #endif /* HAVE_STRINGS_H */
 
 #ifndef SIZE_T_MAX
@@ -36,111 +36,139 @@
 
 #include "arraylist.h"
 
-struct array_list*
-array_list_new(array_list_free_fn *free_fn)
+struct array_list *array_list_new(array_list_free_fn *free_fn)
 {
-  struct array_list *arr;
+	struct array_list *arr;
 
-  arr = (struct array_list*)calloc(1, sizeof(struct array_list));
-  if(!arr) return NULL;
-  arr->size = ARRAY_LIST_DEFAULT_SIZE;
-  arr->length = 0;
-  arr->free_fn = free_fn;
-  if(!(arr->array = (void**)calloc(sizeof(void*), arr->size))) {
-    free(arr);
-    return NULL;
-  }
-  return arr;
+	arr = (struct array_list *)malloc(sizeof(struct array_list));
+	if (!arr)
+		return NULL;
+	arr->size = ARRAY_LIST_DEFAULT_SIZE;
+	arr->length = 0;
+	arr->free_fn = free_fn;
+	if (!(arr->array = (void **)malloc(arr->size * sizeof(void *))))
+	{
+		free(arr);
+		return NULL;
+	}
+	return arr;
 }
 
-extern void
-array_list_free(struct array_list *arr)
+extern void array_list_free(struct array_list *arr)
 {
-  size_t i;
-  for(i = 0; i < arr->length; i++)
-    if(arr->array[i]) arr->free_fn(arr->array[i]);
-  free(arr->array);
-  free(arr);
+	size_t i;
+	for (i = 0; i < arr->length; i++)
+		if (arr->array[i])
+			arr->free_fn(arr->array[i]);
+	free(arr->array);
+	free(arr);
 }
 
-void*
-array_list_get_idx(struct array_list *arr, size_t i)
+void *array_list_get_idx(struct array_list *arr, size_t i)
 {
-  if(i >= arr->length) return NULL;
-  return arr->array[i];
+	if (i >= arr->length)
+		return NULL;
+	return arr->array[i];
 }
 
 static int array_list_expand_internal(struct array_list *arr, size_t max)
 {
-  void *t;
-  size_t new_size;
+	void *t;
+	size_t new_size;
 
-  if(max < arr->size) return 0;
-  /* Avoid undefined behaviour on size_t overflow */
-  if( arr->size >= SIZE_T_MAX / 2 )
-    new_size = max;
-  else
-  {
-    new_size = arr->size << 1;
-    if (new_size < max)
-      new_size = max;
-  }
-  if (new_size > (~((size_t)0)) / sizeof(void*)) return -1;
-  if (!(t = realloc(arr->array, new_size*sizeof(void*)))) return -1;
-  arr->array = (void**)t;
-  (void)memset(arr->array + arr->size, 0, (new_size-arr->size)*sizeof(void*));
-  arr->size = new_size;
-  return 0;
+	if (max < arr->size)
+		return 0;
+	/* Avoid undefined behaviour on size_t overflow */
+	if (arr->size >= SIZE_T_MAX / 2)
+		new_size = max;
+	else
+	{
+		new_size = arr->size << 1;
+		if (new_size < max)
+			new_size = max;
+	}
+	if (new_size > (~((size_t)0)) / sizeof(void *))
+		return -1;
+	if (!(t = realloc(arr->array, new_size * sizeof(void *))))
+		return -1;
+	arr->array = (void **)t;
+	arr->size = new_size;
+	return 0;
 }
 
-int
-array_list_put_idx(struct array_list *arr, size_t idx, void *data)
+//static inline int _array_list_put_idx(struct array_list *arr, size_t idx, void *data)
+int array_list_put_idx(struct array_list *arr, size_t idx, void *data)
 {
-  if (idx > SIZE_T_MAX - 1 ) return -1;
-  if(array_list_expand_internal(arr, idx+1)) return -1;
-  if(idx < arr->length && arr->array[idx])
-    arr->free_fn(arr->array[idx]);
-  arr->array[idx] = data;
-  if(arr->length <= idx) arr->length = idx + 1;
-  return 0;
+	if (idx > SIZE_T_MAX - 1)
+		return -1;
+	if (array_list_expand_internal(arr, idx + 1))
+		return -1;
+	if (idx < arr->length && arr->array[idx])
+		arr->free_fn(arr->array[idx]);
+	arr->array[idx] = data;
+	if (idx > arr->length)
+	{
+		/* Zero out the arraylist slots in between the old length
+		   and the newly added entry so we know those entries are
+		   empty.
+		   e.g. when setting array[7] in an array that used to be 
+		   only 5 elements longs, array[5] and array[6] need to be
+		   set to 0.
+		 */
+		memset(arr->array + arr->length, 0, (idx - arr->length) * sizeof(void *));
+	}
+	if (arr->length <= idx)
+		arr->length = idx + 1;
+	return 0;
 }
 
-int
-array_list_add(struct array_list *arr, void *data)
+int array_list_add(struct array_list *arr, void *data)
 {
-  return array_list_put_idx(arr, arr->length, data);
+	/* Repeat some of array_list_put_idx() so we can skip several
+	   checks that we know are unnecessary when appending at the end
+	 */
+	size_t idx = arr->length;
+	if (idx > SIZE_T_MAX - 1)
+		return -1;
+	if (array_list_expand_internal(arr, idx + 1))
+		return -1;
+	arr->array[idx] = data;
+	arr->length++;
+	return 0;
 }
 
-void
-array_list_sort(struct array_list *arr, int(*sort_fn)(const void *, const void *))
+void array_list_sort(struct array_list *arr, int (*compar)(const void *, const void *))
 {
-  qsort(arr->array, arr->length, sizeof(arr->array[0]), sort_fn);
+	qsort(arr->array, arr->length, sizeof(arr->array[0]), compar);
 }
 
-void* array_list_bsearch(const void **key, struct array_list *arr,
-		int (*sort_fn)(const void *, const void *))
+void *array_list_bsearch(const void **key, struct array_list *arr,
+                         int (*compar)(const void *, const void *))
 {
-	return bsearch(key, arr->array, arr->length, sizeof(arr->array[0]),
-			sort_fn);
+	return bsearch(key, arr->array, arr->length, sizeof(arr->array[0]), compar);
 }
 
-size_t
-array_list_length(struct array_list *arr)
+size_t array_list_length(struct array_list *arr)
 {
-  return arr->length;
+	return arr->length;
 }
 
-int
-array_list_del_idx( struct array_list *arr, size_t idx, size_t count )
+int array_list_del_idx(struct array_list *arr, size_t idx, size_t count)
 {
 	size_t i, stop;
 
+	/* Avoid overflow in calculation with large indices. */
+	if (idx > SIZE_T_MAX - count)
+		return -1;
 	stop = idx + count;
-	if ( idx >= arr->length || stop > arr->length ) return -1;
-	for ( i = idx; i < stop; ++i ) {
-		if ( arr->array[i] ) arr->free_fn( arr->array[i] );
+	if (idx >= arr->length || stop > arr->length)
+		return -1;
+	for (i = idx; i < stop; ++i)
+	{
+		if (arr->array[i])
+			arr->free_fn(arr->array[i]);
 	}
-	memmove( arr->array + idx, arr->array + stop, (arr->length - stop) * sizeof(void*) );
+	memmove(arr->array + idx, arr->array + stop, (arr->length - stop) * sizeof(void *));
 	arr->length -= count;
 	return 0;
 }

arraylist.h

@@ -22,46 +22,39 @@
 extern "C" {
 #endif
 
+#include <stddef.h>
+
 #define ARRAY_LIST_DEFAULT_SIZE 32
 
-typedef void (array_list_free_fn) (void *data);
+typedef void(array_list_free_fn)(void *data);
 
 struct array_list
 {
-  void **array;
-  size_t length;
-  size_t size;
-  array_list_free_fn *free_fn;
+	void **array;
+	size_t length;
+	size_t size;
+	array_list_free_fn *free_fn;
 };
 typedef struct array_list array_list;
 
-extern struct array_list*
-array_list_new(array_list_free_fn *free_fn);
+extern struct array_list *array_list_new(array_list_free_fn *free_fn);
 
-extern void
-array_list_free(struct array_list *al);
+extern void array_list_free(struct array_list *al);
 
-extern void*
-array_list_get_idx(struct array_list *al, size_t i);
+extern void *array_list_get_idx(struct array_list *al, size_t i);
 
-extern int
-array_list_put_idx(struct array_list *al, size_t i, void *data);
+extern int array_list_put_idx(struct array_list *al, size_t i, void *data);
 
-extern int
-array_list_add(struct array_list *al, void *data);
+extern int array_list_add(struct array_list *al, void *data);
 
-extern size_t
-array_list_length(struct array_list *al);
+extern size_t array_list_length(struct array_list *al);
 
-extern void
-array_list_sort(struct array_list *arr, int(*compar)(const void *, const void *));
+extern void array_list_sort(struct array_list *arr, int (*compar)(const void *, const void *));
 
-extern void* array_list_bsearch(const void **key,
-		struct array_list *arr,
-		int (*sort_fn)(const void *, const void *));
+extern void *array_list_bsearch(const void **key, struct array_list *arr,
+                                int (*compar)(const void *, const void *));
 
-extern int 
-array_list_del_idx(struct array_list *arr, size_t idx, size_t count);
+extern int array_list_del_idx(struct array_list *arr, size_t idx, size_t count);
 
 #ifdef __cplusplus
 }

autoconf-archive/README.txt

@@ -1,8 +0,0 @@
-
-Autoconf Archive fetched from:
-
-http://gnu.mirror.iweb.com/autoconf-archive/autoconf-archive-2015.09.25.tar.xz
-
-Grabbed the minimum files needed for the AX_APPEND_COMPILE_FLAGS and
-AX_COMPILE_CHECK_SIZEOF macros.
-

autoconf-archive/m4/ax_append_compile_flags.m4

@@ -1,65 +0,0 @@
-# ===========================================================================
-#  http://www.gnu.org/software/autoconf-archive/ax_append_compile_flags.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-#   AX_APPEND_COMPILE_FLAGS([FLAG1 FLAG2 ...], [FLAGS-VARIABLE], [EXTRA-FLAGS])
-#
-# DESCRIPTION
-#
-#   For every FLAG1, FLAG2 it is checked whether the compiler works with the
-#   flag.  If it does, the flag is added FLAGS-VARIABLE
-#
-#   If FLAGS-VARIABLE is not specified, the current language's flags (e.g.
-#   CFLAGS) is used.  During the check the flag is always added to the
-#   current language's flags.
-#
-#   If EXTRA-FLAGS is defined, it is added to the current language's default
-#   flags (e.g. CFLAGS) when the check is done.  The check is thus made with
-#   the flags: "CFLAGS EXTRA-FLAGS FLAG".  This can for example be used to
-#   force the compiler to issue an error when a bad flag is given.
-#
-#   NOTE: This macro depends on the AX_APPEND_FLAG and
-#   AX_CHECK_COMPILE_FLAG. Please keep this macro in sync with
-#   AX_APPEND_LINK_FLAGS.
-#
-# LICENSE
-#
-#   Copyright (c) 2011 Maarten Bosmans <mkbosmans@gmail.com>
-#
-#   This program is free software: you can redistribute it and/or modify it
-#   under the terms of the GNU General Public License as published by the
-#   Free Software Foundation, either version 3 of the License, or (at your
-#   option) any later version.
-#
-#   This program is distributed in the hope that it will be useful, but
-#   WITHOUT ANY WARRANTY; without even the implied warranty of
-#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
-#   Public License for more details.
-#
-#   You should have received a copy of the GNU General Public License along
-#   with this program. If not, see <http://www.gnu.org/licenses/>.
-#
-#   As a special exception, the respective Autoconf Macro's copyright owner
-#   gives unlimited permission to copy, distribute and modify the configure
-#   scripts that are the output of Autoconf when processing the Macro. You
-#   need not follow the terms of the GNU General Public License when using
-#   or distributing such scripts, even though portions of the text of the
-#   Macro appear in them. The GNU General Public License (GPL) does govern
-#   all other use of the material that constitutes the Autoconf Macro.
-#
-#   This special exception to the GPL applies to versions of the Autoconf
-#   Macro released by the Autoconf Archive. When you make and distribute a
-#   modified version of the Autoconf Macro, you may extend this special
-#   exception to the GPL to apply to your modified version as well.
-
-#serial 4
-
-AC_DEFUN([AX_APPEND_COMPILE_FLAGS],
-[AX_REQUIRE_DEFINED([AX_CHECK_COMPILE_FLAG])
-AX_REQUIRE_DEFINED([AX_APPEND_FLAG])
-for flag in $1; do
-  AX_CHECK_COMPILE_FLAG([$flag], [AX_APPEND_FLAG([$flag], [$2])], [], [$3])
-done
-])dnl AX_APPEND_COMPILE_FLAGS

autoconf-archive/m4/ax_append_flag.m4

@@ -1,71 +0,0 @@
-# ===========================================================================
-#      http://www.gnu.org/software/autoconf-archive/ax_append_flag.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-#   AX_APPEND_FLAG(FLAG, [FLAGS-VARIABLE])
-#
-# DESCRIPTION
-#
-#   FLAG is appended to the FLAGS-VARIABLE shell variable, with a space
-#   added in between.
-#
-#   If FLAGS-VARIABLE is not specified, the current language's flags (e.g.
-#   CFLAGS) is used.  FLAGS-VARIABLE is not changed if it already contains
-#   FLAG.  If FLAGS-VARIABLE is unset in the shell, it is set to exactly
-#   FLAG.
-#
-#   NOTE: Implementation based on AX_CFLAGS_GCC_OPTION.
-#
-# LICENSE
-#
-#   Copyright (c) 2008 Guido U. Draheim <guidod@gmx.de>
-#   Copyright (c) 2011 Maarten Bosmans <mkbosmans@gmail.com>
-#
-#   This program is free software: you can redistribute it and/or modify it
-#   under the terms of the GNU General Public License as published by the
-#   Free Software Foundation, either version 3 of the License, or (at your
-#   option) any later version.
-#
-#   This program is distributed in the hope that it will be useful, but
-#   WITHOUT ANY WARRANTY; without even the implied warranty of
-#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
-#   Public License for more details.
-#
-#   You should have received a copy of the GNU General Public License along
-#   with this program. If not, see <http://www.gnu.org/licenses/>.
-#
-#   As a special exception, the respective Autoconf Macro's copyright owner
-#   gives unlimited permission to copy, distribute and modify the configure
-#   scripts that are the output of Autoconf when processing the Macro. You
-#   need not follow the terms of the GNU General Public License when using
-#   or distributing such scripts, even though portions of the text of the
-#   Macro appear in them. The GNU General Public License (GPL) does govern
-#   all other use of the material that constitutes the Autoconf Macro.
-#
-#   This special exception to the GPL applies to versions of the Autoconf
-#   Macro released by the Autoconf Archive. When you make and distribute a
-#   modified version of the Autoconf Macro, you may extend this special
-#   exception to the GPL to apply to your modified version as well.
-
-#serial 6
-
-AC_DEFUN([AX_APPEND_FLAG],
-[dnl
-AC_PREREQ(2.64)dnl for _AC_LANG_PREFIX and AS_VAR_SET_IF
-AS_VAR_PUSHDEF([FLAGS], [m4_default($2,_AC_LANG_PREFIX[FLAGS])])
-AS_VAR_SET_IF(FLAGS,[
-  AS_CASE([" AS_VAR_GET(FLAGS) "],
-    [*" $1 "*], [AC_RUN_LOG([: FLAGS already contains $1])],
-    [
-     AS_VAR_APPEND(FLAGS,[" $1"])
-     AC_RUN_LOG([: FLAGS="$FLAGS"])
-    ])
-  ],
-  [
-  AS_VAR_SET(FLAGS,[$1])
-  AC_RUN_LOG([: FLAGS="$FLAGS"])
-  ])
-AS_VAR_POPDEF([FLAGS])dnl
-])dnl AX_APPEND_FLAG

autoconf-archive/m4/ax_check_compile_flag.m4

@@ -1,74 +0,0 @@
-# ===========================================================================
-#   http://www.gnu.org/software/autoconf-archive/ax_check_compile_flag.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-#   AX_CHECK_COMPILE_FLAG(FLAG, [ACTION-SUCCESS], [ACTION-FAILURE], [EXTRA-FLAGS], [INPUT])
-#
-# DESCRIPTION
-#
-#   Check whether the given FLAG works with the current language's compiler
-#   or gives an error.  (Warnings, however, are ignored)
-#
-#   ACTION-SUCCESS/ACTION-FAILURE are shell commands to execute on
-#   success/failure.
-#
-#   If EXTRA-FLAGS is defined, it is added to the current language's default
-#   flags (e.g. CFLAGS) when the check is done.  The check is thus made with
-#   the flags: "CFLAGS EXTRA-FLAGS FLAG".  This can for example be used to
-#   force the compiler to issue an error when a bad flag is given.
-#
-#   INPUT gives an alternative input source to AC_COMPILE_IFELSE.
-#
-#   NOTE: Implementation based on AX_CFLAGS_GCC_OPTION. Please keep this
-#   macro in sync with AX_CHECK_{PREPROC,LINK}_FLAG.
-#
-# LICENSE
-#
-#   Copyright (c) 2008 Guido U. Draheim <guidod@gmx.de>
-#   Copyright (c) 2011 Maarten Bosmans <mkbosmans@gmail.com>
-#
-#   This program is free software: you can redistribute it and/or modify it
-#   under the terms of the GNU General Public License as published by the
-#   Free Software Foundation, either version 3 of the License, or (at your
-#   option) any later version.
-#
-#   This program is distributed in the hope that it will be useful, but
-#   WITHOUT ANY WARRANTY; without even the implied warranty of
-#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
-#   Public License for more details.
-#
-#   You should have received a copy of the GNU General Public License along
-#   with this program. If not, see <http://www.gnu.org/licenses/>.
-#
-#   As a special exception, the respective Autoconf Macro's copyright owner
-#   gives unlimited permission to copy, distribute and modify the configure
-#   scripts that are the output of Autoconf when processing the Macro. You
-#   need not follow the terms of the GNU General Public License when using
-#   or distributing such scripts, even though portions of the text of the
-#   Macro appear in them. The GNU General Public License (GPL) does govern
-#   all other use of the material that constitutes the Autoconf Macro.
-#
-#   This special exception to the GPL applies to versions of the Autoconf
-#   Macro released by the Autoconf Archive. When you make and distribute a
-#   modified version of the Autoconf Macro, you may extend this special
-#   exception to the GPL to apply to your modified version as well.
-
-#serial 4
-
-AC_DEFUN([AX_CHECK_COMPILE_FLAG],
-[AC_PREREQ(2.64)dnl for _AC_LANG_PREFIX and AS_VAR_IF
-AS_VAR_PUSHDEF([CACHEVAR],[ax_cv_check_[]_AC_LANG_ABBREV[]flags_$4_$1])dnl
-AC_CACHE_CHECK([whether _AC_LANG compiler accepts $1], CACHEVAR, [
-  ax_check_save_flags=$[]_AC_LANG_PREFIX[]FLAGS
-  _AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS $4 $1"
-  AC_COMPILE_IFELSE([m4_default([$5],[AC_LANG_PROGRAM()])],
-    [AS_VAR_SET(CACHEVAR,[yes])],
-    [AS_VAR_SET(CACHEVAR,[no])])
-  _AC_LANG_PREFIX[]FLAGS=$ax_check_save_flags])
-AS_VAR_IF(CACHEVAR,yes,
-  [m4_default([$2], :)],
-  [m4_default([$3], :)])
-AS_VAR_POPDEF([CACHEVAR])dnl
-])dnl AX_CHECK_COMPILE_FLAGS

autoconf-archive/m4/ax_compile_check_sizeof.m4

@@ -1,114 +0,0 @@
-# ===========================================================================
-#  http://www.gnu.org/software/autoconf-archive/ax_compile_check_sizeof.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-#   AX_COMPILE_CHECK_SIZEOF(TYPE [, HEADERS [, EXTRA_SIZES...]])
-#
-# DESCRIPTION
-#
-#   This macro checks for the size of TYPE using compile checks, not run
-#   checks. You can supply extra HEADERS to look into. the check will cycle
-#   through 1 2 4 8 16 and any EXTRA_SIZES the user supplies. If a match is
-#   found, it will #define SIZEOF_`TYPE' to that value. Otherwise it will
-#   emit a configure time error indicating the size of the type could not be
-#   determined.
-#
-#   The trick is that C will not allow duplicate case labels. While this is
-#   valid C code:
-#
-#     switch (0) case 0: case 1:;
-#
-#   The following is not:
-#
-#     switch (0) case 0: case 0:;
-#
-#   Thus, the AC_TRY_COMPILE will fail if the currently tried size does not
-#   match.
-#
-#   Here is an example skeleton configure.in script, demonstrating the
-#   macro's usage:
-#
-#     AC_PROG_CC
-#     AC_CHECK_HEADERS(stddef.h unistd.h)
-#     AC_TYPE_SIZE_T
-#     AC_CHECK_TYPE(ssize_t, int)
-#
-#     headers='#ifdef HAVE_STDDEF_H
-#     #include <stddef.h>
-#     #endif
-#     #ifdef HAVE_UNISTD_H
-#     #include <unistd.h>
-#     #endif
-#     '
-#
-#     AX_COMPILE_CHECK_SIZEOF(char)
-#     AX_COMPILE_CHECK_SIZEOF(short)
-#     AX_COMPILE_CHECK_SIZEOF(int)
-#     AX_COMPILE_CHECK_SIZEOF(long)
-#     AX_COMPILE_CHECK_SIZEOF(unsigned char *)
-#     AX_COMPILE_CHECK_SIZEOF(void *)
-#     AX_COMPILE_CHECK_SIZEOF(size_t, $headers)
-#     AX_COMPILE_CHECK_SIZEOF(ssize_t, $headers)
-#     AX_COMPILE_CHECK_SIZEOF(ptrdiff_t, $headers)
-#     AX_COMPILE_CHECK_SIZEOF(off_t, $headers)
-#
-# LICENSE
-#
-#   Copyright (c) 2008 Kaveh Ghazi <ghazi@caip.rutgers.edu>
-#
-#   This program is free software: you can redistribute it and/or modify it
-#   under the terms of the GNU General Public License as published by the
-#   Free Software Foundation, either version 3 of the License, or (at your
-#   option) any later version.
-#
-#   This program is distributed in the hope that it will be useful, but
-#   WITHOUT ANY WARRANTY; without even the implied warranty of
-#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
-#   Public License for more details.
-#
-#   You should have received a copy of the GNU General Public License along
-#   with this program. If not, see <http://www.gnu.org/licenses/>.
-#
-#   As a special exception, the respective Autoconf Macro's copyright owner
-#   gives unlimited permission to copy, distribute and modify the configure
-#   scripts that are the output of Autoconf when processing the Macro. You
-#   need not follow the terms of the GNU General Public License when using
-#   or distributing such scripts, even though portions of the text of the
-#   Macro appear in them. The GNU General Public License (GPL) does govern
-#   all other use of the material that constitutes the Autoconf Macro.
-#
-#   This special exception to the GPL applies to versions of the Autoconf
-#   Macro released by the Autoconf Archive. When you make and distribute a
-#   modified version of the Autoconf Macro, you may extend this special
-#   exception to the GPL to apply to your modified version as well.
-
-#serial 5
-
-AU_ALIAS([AC_COMPILE_CHECK_SIZEOF], [AX_COMPILE_CHECK_SIZEOF])
-AC_DEFUN([AX_COMPILE_CHECK_SIZEOF],
-[changequote(<<, >>)dnl
-dnl The name to #define.
-define(<<AC_TYPE_NAME>>, translit(sizeof_$1, [a-z *], [A-Z_P]))dnl
-dnl The cache variable name.
-define(<<AC_CV_NAME>>, translit(ac_cv_sizeof_$1, [ *], [_p]))dnl
-changequote([, ])dnl
-AC_MSG_CHECKING(size of $1)
-AC_CACHE_VAL(AC_CV_NAME,
-[for ac_size in 4 8 1 2 16 $3 ; do # List sizes in rough order of prevalence.
-  AC_TRY_COMPILE([#include "confdefs.h"
-#include <sys/types.h>
-$2
-], [switch (0) case 0: case (sizeof ($1) == $ac_size):;], AC_CV_NAME=$ac_size)
-  if test x$AC_CV_NAME != x ; then break; fi
-done
-])
-if test x$AC_CV_NAME = x ; then
-  AC_MSG_ERROR([cannot determine a size for $1])
-fi
-AC_MSG_RESULT($AC_CV_NAME)
-AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME, [The number of bytes in type $1])
-undefine([AC_TYPE_NAME])dnl
-undefine([AC_CV_NAME])dnl
-])

autoconf-archive/m4/ax_require_defined.m4

@@ -1,37 +0,0 @@
-# ===========================================================================
-#    http://www.gnu.org/software/autoconf-archive/ax_require_defined.html
-# ===========================================================================
-#
-# SYNOPSIS
-#
-#   AX_REQUIRE_DEFINED(MACRO)
-#
-# DESCRIPTION
-#
-#   AX_REQUIRE_DEFINED is a simple helper for making sure other macros have
-#   been defined and thus are available for use.  This avoids random issues
-#   where a macro isn't expanded.  Instead the configure script emits a
-#   non-fatal:
-#
-#     ./configure: line 1673: AX_CFLAGS_WARN_ALL: command not found
-#
-#   It's like AC_REQUIRE except it doesn't expand the required macro.
-#
-#   Here's an example:
-#
-#     AX_REQUIRE_DEFINED([AX_CHECK_LINK_FLAG])
-#
-# LICENSE
-#
-#   Copyright (c) 2014 Mike Frysinger <vapier@gentoo.org>
-#
-#   Copying and distribution of this file, with or without modification, are
-#   permitted in any medium without royalty provided the copyright notice
-#   and this notice are preserved. This file is offered as-is, without any
-#   warranty.
-
-#serial 1
-
-AC_DEFUN([AX_REQUIRE_DEFINED], [dnl
-  m4_ifndef([$1], [m4_fatal([macro ]$1[ is not defined; is a m4 file missing?])])
-])dnl AX_REQUIRE_DEFINED

autogen.sh

@@ -1,13 +0,0 @@
-#!/bin/sh
-autoreconf -v --install || exit 1
-
-# If there are any options, assume the user wants to run configure.
-# To run configure w/o any options, use ./autogen.sh --configure
-if [ $# -gt 0 ] ; then
-	case "$1" in
-	--conf*)
-		shift 1
-		;;
-	esac
-    exec ./configure  "$@"
-fi

bench/README.bench.md

@@ -0,0 +1,80 @@
+
+Benchmark tests for json-c
+
+General strategy:
+-------------------
+
+* Identify "after" commit hash
+    * Use provided directory
+    * Use provided commit hash
+    * Local changes in current working directory
+    * ${cur_branch}
+* Identify "before" commit hash, in order of preference
+    * Use provided directory
+    * Use provided commit hash
+    * Use origin/${cur_branch}, if different from ${after_commit}
+    * Use previous release
+
+* If not using existing dir, clone to src-${after_commit}
+    * or, checkout appropriate commit in existing src-${after_commit}
+* Create build & install dirs for ${after_commit}
+* Build & install ${after_commit}
+* Compile benchmark programs against install-${after_commit}
+
+* If not using existing dir, clone to src-${before_commit}
+    * or, checkout appropriate commit in existing src-${before_commit}
+* Create build & install dirs for ${before_commit}
+* Build & install ${before_commit}
+* Compile benchmark programs against install-${before_commit}
+
+* Run benchmark in each location
+* Compare results
+
+heaptrack memory profiler
+---------------------------
+
+https://milianw.de/blog/heaptrack-a-heap-memory-profiler-for-linux.html
+
+
+```
+yum install libdwarf-devel elfutils boost-devel libunwind-devel
+
+git clone git://anongit.kde.org/heaptrack
+cd heaptrack
+mkdir build
+cd build
+cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo \
+	-DCMAKE_INSTALL_PREFIX=$HOME/heaptrack-install ..
+make install
+```
+
+
+Issues
+--------
+
+* jc-bench.sh is incomplete.
+
+* valgrind massif misreports "extra-heap" bytes?
+
+    "json_parse -n canada.json" shows 38640 KB maxrss.
+
+    Using valgrind --tool=massif, a large amount of memory is listed as
+     wasted "extra-heap" bytes.  (~5.6MB)
+
+    ```
+    valgrind --tool=massif --massif-out-file=massif.out ./json_parse -n ~/canada.json
+    ms_print massif.out
+    ```
+
+
+    Using heaptrack, and analyzing the histogram, only shows ~2.6MB
+    ```
+    heaptrack ./json_parse -n canada.json
+    heaptrack --analyze heaptrack*gz -H histgram.out
+    awk ' { s=$1; count=$2; ru=(int((s+ 15) / 16)) * 16; wasted = ((ru-s)*count); print s, count, ru-s, wasted; total=total+wasted} END { print "Total: ", total }' histogram.out
+    ```
+
+ With the (unreleased) arraylist trimming changes, maxrss reported by
+  getrusage() goes down, but massif claims *more* total usage, and a HUGE 
+  extra-heap amount (50% of total).
+

bench/jc-bench.sh

@@ -0,0 +1,284 @@
+#!/bin/sh
+#
+# Benchmarking harness for json-c
+#
+# Use this to compare the behavior of two different versions of the library,
+# such as json-c-0.14 release vs master, master vs local changes, etc...
+#
+
+set -e
+
+trap 'echo "FAILED!"' EXIT
+
+RUNDIR=$(dirname "$0")
+RUNDIR=$(cd "$RUNDIR" && pwd)
+
+TOP=$(cd "$RUNDIR/.." && pwd)
+
+usage()
+{
+	exitval=$1
+	errmsg=$2
+	if [ $exitval -ne 0 ] ; then
+		exec 1>&2
+	fi
+	if [ ! -z "$errmsg" ] ; then
+		echo "ERROR: $errmsg" 1>&2
+	fi
+	cat <<EOF
+Usage: $0 [-h] [-v] [--build] [--run] [--compare] ...XAX...
+EOF
+
+	exit $extival
+}
+
+before_arg=
+after_arg=
+do_all=1
+do_build=0
+do_run=0
+do_compare=0
+
+while [ $# -gt 0 ] ; do
+	case "$1" in
+	--before)
+		before_arg=$2
+		shift
+		;;
+	--after)
+		after_arg=$2
+		shift
+		;;
+	--build)
+		do_all=0
+		do_build=1
+		;;
+	--run)
+		do_all=0
+		do_run=1
+		;;
+	--compare)
+		do_all=0
+		do_compare=1
+		;;
+	-h)
+		usage 0 ""
+		;;
+	-v)
+		set -x
+		;;
+	*)
+		usage 1 "Unknown args: $*"
+		;;
+	esac
+	shift
+done
+
+WORK="${RUNDIR}/work"
+mkdir -p "${WORK}"
+
+DATA="${RUNDIR}/data"
+mkdir -p "${DATA}"
+
+for file in citm_catalog.json twitter.json canada.json ; do
+	if [ ! -r "${DATA}/${file}" ] ; then
+		echo "Fetching ${file} from github.com/mloskot/json_benchmark"
+		URL="https://github.com/mloskot/json_benchmark/raw/master/data/${file}"
+		curl -s -L -o "${DATA}/${file}" "$URL"
+	fi
+done
+echo
+
+# Identify "after" commit hash, in order of preference
+if [ ! -z "$after_arg" -a -d "$after_arg" ] ; then
+	# Use provided directory
+	after_src_dir="$after_arg"
+	after_commit=
+	echo "Using provided directory [$after_arg] as 'after'"
+else
+	_commit=
+	if [ ! -z "$after_arg" ] ; then
+		# Use provided commit hash
+		_commit=$(git rev-parse --verify "$after_arg")
+	fi
+	if [ ! -z "$_commit" ] ;then
+		after_src_dir=  # i.e. current tree
+		after_commit="$_commit"
+		echo "Using provided commit [$after_arg => $_commit] as 'after'"
+	else
+		# Local changes in current working directory
+		# ${cur_branch}
+		after_src_dir=$TOP
+		after_commit=
+		echo "Using local changes in $TOP as 'after'"
+	fi
+fi
+
+# Identify "before" commit hash, in order of preference
+if [ ! -z "$before_arg" -a -d "$before_arg" ] ; then
+   	# Use provided directory
+	before_src_dir="$before_arg"
+	before_commit=
+	echo "Using provided directory [$before_arg] as 'before'"
+else
+	_commit=
+	if [ ! -z "$before_arg" ] ; then
+		# Use provided commit hash
+		_commit=$(git rev-parse --verify "$before_arg")
+	fi
+	if [ ! -z "$_commit" ] ;then
+		before_src_dir=  # i.e. current tree
+		before_commit="$_commit"
+		echo "Using provided commit [$before_arg => $_commit] as 'before'"
+	else
+		# Use origin/${cur_branch}, if different from ${after_commit}
+		_cur_branch=$(git rev-parse --abbrev-ref HEAD)
+		_commit=
+		if [ ! -z "${_cur_branch}" ] ; then
+			_commit=$(git rev-parse --verify "origin/${_cur_branch}")
+			echo "Using origin/${_cur_branch} [$_commit] as 'before'"
+		fi
+		if [ "$_commit" = "${after_commit}" ] ; then
+			_commit=
+		fi
+	fi
+
+	if [ ! -z "$_commit" ] ; then
+		before_src_dir=  # i.e. current tree
+		before_commit="$_commit"
+	else
+		# Use previous release
+		before_src_dir=  # i.e. current tree
+		before_commit="$(git tag | sort | tail -1)"
+		echo "Using previous release [$before_commit] as 'before'"
+	fi
+fi
+
+echo
+
+compile_benchmark()
+{
+	local bname=$1
+	local src_dir="$2"
+	local src_commit="$3"
+
+	local build_dir="${WORK}/$bname/build"
+	local inst_dir="${WORK}/$bname/install"
+	local bench_dir="${WORK}/$bname/bench"
+
+	echo
+	echo "=========== $bname ==========="
+	echo
+
+	mkdir -p "${build_dir}"
+	mkdir -p "${inst_dir}"
+	mkdir -p "${bench_dir}"
+
+	if [ ! -z "$src_commit" ] ; then
+		# Resolve the short hash, tag or branch name to full hash
+		src_commit=$(git rev-parse $src_commit)
+	fi
+
+	# No src dir specified, clone and checkout $src_commit
+	if [ -z "$src_dir" ] ; then
+		src_dir="${WORK}/$bname/src"
+		echo "=== Using sources in $src_dir"
+		mkdir -p "$src_dir"
+		at_commit=$(git --git-dir="$src_dir/.git" rev-parse HEAD 2> /dev/null || true)
+		echo "at_commit: $at_commit"
+		if [ -z "$at_commit" ] ; then
+			# Assume it's an empty dir
+			git clone -n "$TOP" "$src_dir"
+		fi
+		git -C "$src_dir" --git-dir="$src_dir/.git" checkout "$src_commit"
+	fi
+	# else, use the provided $src_dir
+
+	if [ -e "${src_dir}/CMakeLists.txt" ] ; then
+		cd "${build_dir}"
+		cmake -DCMAKE_INSTALL_PREFIX="${inst_dir}" "${src_dir}"
+	else
+		# Old versions of json-c used automake/autoconf
+		cd "${src_dir}"
+		sh autogen.sh   # always run it, configure doesn't always work
+		cd "${build_dir}"
+		"${src_dir}/configure" --prefix="${inst_dir}"
+	fi
+	make all install
+
+	cd "${bench_dir}"
+	cmake -DCMAKE_PREFIX_PATH="${inst_dir}" "${TOP}/apps"
+	make all
+}
+
+# XXX TODO: name "after" and "before" uniquely using the dir & commit
+
+if [ $do_all -ne 0 -o $do_build -ne 0 ] ; then
+	sleep 5   # Wait slightly, to allow the human to read the message
+	          #  about what exactly we're doing to benchmark.
+	compile_benchmark "after" "${after_src_dir}" "${after_commit}"
+	compile_benchmark "before" "${before_src_dir}" "${before_commit}"
+fi
+
+run_benchmark()
+{
+	local bname=$1
+	local inst_dir="${WORK}/$bname/install"
+	local bench_dir="${WORK}/$bname/bench"
+
+	local INPUT=${DATA}/canada.json
+
+	cd "${bench_dir}"
+	mkdir -p results
+	(time ./json_parse -n "${INPUT}") > results/basic_timing.out 2>&1
+	valgrind --tool=massif --massif-out-file=massif.out ./json_parse -n "${INPUT}"
+	ms_print massif.out > results/ms_print.out
+	heaptrack -o heaptrack_out ./json_parse -n "${INPUT}"
+	heaptrack --analyze heaptrack_out.gz -H histogram.out > results/heaptrack.out
+	awk ' { s=$1; count=$2; ru=(int((s+ 15) / 16)) * 16; wasted = ((ru-s)*count); print s, count, ru-s, wasted; total=total+wasted} END { print "Total: ", total }' histogram.out > results/histogram2.out
+
+	# XXX stamp some info about what was built & run into ./results/.
+
+	echo "DONE with $bname"
+}
+
+if [ $do_all -ne 0 -o $do_run -ne 0 ] ; then
+	run_benchmark "after"
+	run_benchmark "before"
+fi
+
+if [ $do_compare -ne 0 ] ; then
+	# XXX this needs better analysis
+	cd "${WORK}"
+	diff -udr before/bench/results after/bench/results || true
+else
+	echo "To compare results, run:"
+	echo "$0 --compare"
+fi
+
+trap '' EXIT
+
+:<<=cut
+
+Benchmarks to run:
+
+* Parse JSON strings, of various sizes and characteristics
+    * Flags: STRICT vs. non-STRICT, validate UTF8
+
+* Serialization time
+    * plain, spaces, pretty
+
+* json_c_visit tests
+* JSON pointer tests
+
+Things to record and compare:
+
+* Running time
+* Peak memory usage
+* Useful bytes vs. overhead for memory allocations
+* Total number of allocations
+* Average allocation size
+* Log of all allocation sizes
+
+=cut
+

bits.h

@@ -1,36 +0,0 @@
-/**
- * @file
- * @brief Do not use, only contains deprecated defines.
- * @deprecated Use json_util.h instead.
- *
- * $Id: bits.h,v 1.10 2006/01/30 23:07:57 mclark Exp $
- *
- * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd.
- * Michael Clark <michael@metaparadigm.com>
- *
- * This library is free software; you can redistribute it and/or modify
- * it under the terms of the MIT license. See COPYING for details.
- *
- */
-
-#ifndef _bits_h_
-#define _bits_h_
-
-/**
- * @deprecated
- */
-#define hexdigit(x) (((x) <= '9') ? (x) - '0' : ((x) & 7) + 9)
-/**
- * @deprecated
- */
-#define error_ptr(error) ((void*)error)
-/**
- * @deprecated
- */
-#define error_description(error)  (json_tokener_get_error(error))
-/**
- * @deprecated
- */
-#define is_error(ptr) (ptr == NULL)
-
-#endif

cmake-configure

@@ -0,0 +1,90 @@
+#!/bin/bash
+
+# Wrapper around cmake to emulate useful options
+# from the previous autoconf-based configure script.
+
+RUNDIR=$(dirname "$0")
+RUNDIR=$(cd "$RUNDIR" && pwd)
+CURDIR=$(pwd)
+
+FLAGS=()
+
+usage()
+{
+	exitval="$1"
+	errmsg="$2"
+
+	if [ $exitval -ne 0 ] ; then
+		exec 1>&2
+	fi
+	if [ ! -z "$errmsg" ] ; then
+		echo "ERROR: $errmsg" 1>&2
+	fi
+	cat <<EOF
+$0 [<configure_options>] [-- [<cmake options>]]
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+  --enable-threading      Enable code to support partly multi-threaded use
+  --enable-rdrand         Enable RDRAND Hardware RNG Hash Seed generation on
+                          supported x86/x64 platforms.
+  --enable-shared         build shared libraries [default=yes]
+  --enable-static         build static libraries [default=yes]
+  --disable-Bsymbolic     Avoid linking with -Bsymbolic-function
+  --disable-werror        Avoid treating compiler warnings as fatal errors
+
+EOF
+	exit
+}
+
+if [ "$CURDIR" = "$RUNDIR" ] ; then
+	usage 1 "Please mkdir some other build directory, and run this script from there."
+fi
+
+if ! cmake --version ; then
+	usage 1 "Unable to find a working cmake, please be sure you have it installed and on your PATH"
+fi
+
+while [ $# -gt 0 ] ; do
+	case "$1" in
+	-h|--help)
+		usage 0
+		;;
+	--prefix)
+		FLAGS+=(-DCMAKE_INSTALL_PREFIX="$2")
+		shift
+		;;
+	--prefix=*)
+		FLAGS+=(-DCMAKE_INSTALL_PREFIX="${1##--prefix=}")
+		;;
+	--enable-threading)
+		FLAGS+=(-DENABLE_THREADING=ON)
+		;;
+	--enable-rdrand)
+		FLAGS+=(-DENABLE_RDRAND=ON)
+		;;
+	--enable-shared)
+		FLAGS+=(-DBUILD_SHARED_LIBS=ON)
+		;;
+	--enable-static)
+		FLAGS+=(-DBUILD_STATIC_LIBS=ON)
+		;;
+	--disable-Bsymbolic)
+		FLAGS+=(-DDISABLE_BSYMBOLIC=ON)
+		;;
+	--disable-werror)
+		FLAGS+=(-DDISABLE_WERROR=ON)
+		;;
+	--)
+		shift
+		break
+		;;
+	-*)
+		usage 1 "Unknown arguments: $*"
+		;;
+	*)
+		break
+		;;
+	esac
+	shift
+done
+
+exec cmake "${FLAGS[@]}" "$@" "${RUNDIR}"

cmake/Config.cmake.in

@@ -0,0 +1,4 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@-targets.cmake")
+check_required_components("@PROJECT_NAME@")

cmake/config.h.in

@@ -0,0 +1,213 @@
+
+/* Enable RDRAND Hardware RNG Hash Seed */
+#cmakedefine ENABLE_RDRAND "@ENABLE_RDRAND@"
+
+/* Enable partial threading support */
+#cmakedefine ENABLE_THREADING "@@"
+
+/* Define if .gnu.warning accepts long strings. */
+#cmakedefine HAS_GNU_WARNING_LONG "@@"
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#cmakedefine HAVE_DLFCN_H
+
+/* Define to 1 if you have the <endian.h> header file. */
+#cmakedefine HAVE_ENDIAN_H
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+#cmakedefine HAVE_FCNTL_H
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#cmakedefine HAVE_INTTYPES_H
+
+/* Define to 1 if you have the <limits.h> header file. */
+#cmakedefine HAVE_LIMITS_H
+
+/* Define to 1 if you have the <locale.h> header file. */
+#cmakedefine HAVE_LOCALE_H
+
+/* Define to 1 if you have the <memory.h> header file. */
+#cmakedefine HAVE_MEMORY_H
+
+/* Define to 1 if you have the <stdarg.h> header file. */
+#cmakedefine HAVE_STDARG_H
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#cmakedefine HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#cmakedefine HAVE_STDLIB_H
+
+/* Define to 1 if you have the <strings.h> header file. */
+#cmakedefine HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#cmakedefine HAVE_STRING_H
+
+/* Define to 1 if you have the <syslog.h> header file. */
+#cmakedefine HAVE_SYSLOG_H @HAVE_SYSLOG_H@
+
+/* Define to 1 if you have the <sys/cdefs.h> header file. */
+#cmakedefine HAVE_SYS_CDEFS_H
+
+/* Define to 1 if you have the <sys/param.h> header file. */
+#cmakedefine HAVE_SYS_PARAM_H @HAVE_SYS_PARAM_H@
+
+/* Define to 1 if you have the <sys/resource.h> header file. */
+#cmakedefine HAVE_SYS_RESOURCE_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#cmakedefine HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#cmakedefine HAVE_SYS_TYPES_H @HAVE_SYS_TYPES_H@
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#cmakedefine HAVE_UNISTD_H @HAVE_UNISTD_H@
+
+/* Define to 1 if you have the <xlocale.h> header file. */
+#cmakedefine HAVE_XLOCALE_H
+
+/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */
+#cmakedefine HAVE_DOPRNT
+
+/* Has atomic builtins */
+#cmakedefine HAVE_ATOMIC_BUILTINS
+
+/* Define to 1 if you have the declaration of `INFINITY', and to 0 if you
+   don't. */
+#cmakedefine HAVE_DECL_INFINITY
+
+/* Define to 1 if you have the declaration of `isinf', and to 0 if you don't.
+   */
+#cmakedefine HAVE_DECL_ISINF
+
+/* Define to 1 if you have the declaration of `isnan', and to 0 if you don't.
+   */
+#cmakedefine HAVE_DECL_ISNAN
+
+/* Define to 1 if you have the declaration of `nan', and to 0 if you don't. */
+#cmakedefine HAVE_DECL_NAN
+
+/* Define to 1 if you have the declaration of `_finite', and to 0 if you
+   don't. */
+#cmakedefine HAVE_DECL__FINITE
+
+/* Define to 1 if you have the declaration of `_isnan', and to 0 if you don't.
+   */
+#cmakedefine HAVE_DECL__ISNAN
+
+/* Define to 1 if you have the `open' function. */
+#cmakedefine HAVE_OPEN
+
+/* Define to 1 if you have the `realloc' function. */
+#cmakedefine HAVE_REALLOC
+
+/* Define to 1 if you have the `setlocale' function. */
+#cmakedefine HAVE_SETLOCALE
+
+/* Define to 1 if you have the `snprintf' function. */
+#cmakedefine HAVE_SNPRINTF
+
+
+/* Define to 1 if you have the `strcasecmp' function. */
+#cmakedefine HAVE_STRCASECMP @HAVE_STRCASECMP@
+
+/* Define to 1 if you have the `strdup' function. */
+#cmakedefine HAVE_STRDUP
+
+/* Define to 1 if you have the `strerror' function. */
+#cmakedefine HAVE_STRERROR
+
+/* Define to 1 if you have the `strncasecmp' function. */
+#cmakedefine HAVE_STRNCASECMP @HAVE_STRNCASECMP@
+
+/* Define to 1 if you have the `uselocale' function. */
+#cmakedefine HAVE_USELOCALE
+
+/* Define to 1 if you have the `vasprintf' function. */
+#cmakedefine HAVE_VASPRINTF
+
+/* Define to 1 if you have the `vprintf' function. */
+#cmakedefine HAVE_VPRINTF
+
+/* Define to 1 if you have the `vsnprintf' function. */
+#cmakedefine HAVE_VSNPRINTF
+
+/* Define to 1 if you have the `vsyslog' function. */
+#cmakedefine HAVE_VSYSLOG @HAVE_VSYSLOG@
+
+/* Define if you have the `getrusage' function. */
+#cmakedefine HAVE_GETRUSAGE
+
+#cmakedefine HAVE_STRTOLL
+#if !defined(HAVE_STRTOLL)
+#define strtoll @json_c_strtoll@
+/* #cmakedefine json_c_strtoll @json_c_strtoll@*/
+#endif
+
+#cmakedefine HAVE_STRTOULL
+#if !defined(HAVE_STRTOULL)
+#define strtoull @json_c_strtoull@
+/* #cmakedefine json_c_strtoull @json_c_strtoull@ */
+#endif
+
+/* Have __thread */
+#cmakedefine HAVE___THREAD
+
+/* Public define for json_inttypes.h */
+#cmakedefine JSON_C_HAVE_INTTYPES_H @JSON_C_HAVE_INTTYPES_H@
+
+/* Name of package */
+#define PACKAGE "@PROJECT_NAME@"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "@JSON_C_BUGREPORT@"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "@PROJECT_NAME@"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "@PROJECT_NAME@ @CPACK_PACKAGE_VERSION_MAJOR@.@CPACK_PACKAGE_VERSION_MINOR@.@CPACK_PACKAGE_VERSION_PATCH@"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "@PROJECT_NAME@"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL "https://github.com/json-c/json-c"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "@CPACK_PACKAGE_VERSION_MAJOR@.@CPACK_PACKAGE_VERSION_MINOR@.@CPACK_PACKAGE_VERSION_PATCH@"
+
+/* The number of bytes in type int */
+#cmakedefine SIZEOF_INT @SIZEOF_INT@
+
+/* The number of bytes in type int64_t */
+#cmakedefine SIZEOF_INT64_T @SIZEOF_INT64_T@
+
+/* The number of bytes in type long */
+#cmakedefine SIZEOF_LONG @SIZEOF_LONG@
+
+/* The number of bytes in type long long */
+#cmakedefine SIZEOF_LONG_LONG @SIZEOF_LONG_LONG@
+
+/* The number of bytes in type size_t */
+#cmakedefine SIZEOF_SIZE_T @SIZEOF_SIZE_T@
+
+/* The number of bytes in type ssize_t */
+#cmakedefine SIZEOF_SSIZE_T @SIZEOF_SSIZE_T@
+
+/* Specifier for __thread */
+#cmakedefine SPEC___THREAD @SPEC___THREAD@
+
+/* Define to 1 if you have the ANSI C header files. */
+#cmakedefine STDC_HEADERS
+
+/* Version number of package */
+#define VERSION "@CPACK_PACKAGE_VERSION_MAJOR@.@CPACK_PACKAGE_VERSION_MINOR@.@CPACK_PACKAGE_VERSION_PATCH@"
+
+/* Define to empty if `const' does not conform to ANSI C. */
+#cmakedefine const
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+#cmakedefine size_t

cmake/json_config.h.in

@@ -0,0 +1,2 @@
+/* Define to 1 if you have the <inttypes.h> header file. */
+#cmakedefine JSON_C_HAVE_INTTYPES_H @JSON_C_HAVE_INTTYPES_H@

config.h.win32

@@ -1,205 +1,207 @@
-/* config.h.in.  Generated from configure.ac by autoheader.  */
-
-/* Enable RDRANR Hardware RNG Hash Seed */
-#undef ENABLE_RDRAND
-
-/* Define if .gnu.warning accepts long strings. */
-#undef HAS_GNU_WARNING_LONG
-
-/* Define to 1 if you have the declaration of `INFINITY', and to 0 if you
-   don't. */
-#if (defined(_MSC_VER) && _MSC_VER >= 1800) || defined(__MINGW32__)
-#define HAVE_DECL_INFINITY 1
-#endif
-
-/* Define to 1 if you have the declaration of `isinf', and to 0 if you don't.
-   */
-#if (defined(_MSC_VER) && _MSC_VER >= 1800) || defined(__MINGW32__)
-#define HAVE_DECL_ISINF 1
-#endif
-
-/* Define to 1 if you have the declaration of `isnan', and to 0 if you don't.
-   */
-#if (defined(_MSC_VER) && _MSC_VER >= 1800) || defined(__MINGW32__)
-#define HAVE_DECL_ISNAN 1
-#endif
-
-/* Define to 1 if you have the declaration of `nan', and to 0 if you don't. */
-#if (defined(_MSC_VER) && _MSC_VER >= 1800) || defined(__MINGW32__)
-#define HAVE_DECL_NAN 1
-#endif
-
-/* Define to 1 if you have the declaration of `_finite', and to 0 if you
-   don't. */
-#define HAVE_DECL__FINITE 1
-
-/* Define to 1 if you have the declaration of `_isnan', and to 0 if you don't.
-   */
-#define HAVE_DECL__ISNAN 1
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#define HAVE_DLFCN_H 1
-
-/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */
-#define HAVE_DOPRNT 1
-
-/* Define to 1 if you have the <endian.h> header file. */
-#undef HAVE_ENDIAN_H
-
-/* Define to 1 if you have the <fcntl.h> header file. */
-#define HAVE_FCNTL_H 1
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#define HAVE_INTTYPES_H 1
-
-/* Define to 1 if you have the <limits.h> header file. */
-#define HAVE_LIMITS_H 1
-
-/* Define to 1 if you have the <locale.h> header file. */
-#define HAVE_LOCALE_H 1
-
-/* Define to 1 if your system has a GNU libc compatible `malloc' function, and
-   to 0 otherwise. */
-#define HAVE_MALLOC 1
-
-/* Define to 1 if you have the <memory.h> header file. */
-#define HAVE_MEMORY_H 1
-
-/* Define to 1 if you have the `open' function. */
-#define HAVE_OPEN 1
-
-/* Define to 1 if your system has a GNU libc compatible `realloc' function,
-   and to 0 otherwise. */
-#define HAVE_REALLOC 1
-
-/* Define to 1 if you have the `setlocale' function. */
-#define HAVE_SETLOCALE 1
-
-/* Define to 1 if you have the `snprintf' function. */
-#if defined(__MINGW32__)
-#define HAVE_SNPRINTF 1
-#else
-#undef HAVE_SNPRINTF
-#endif
-
-/* Define to 1 if you have the <stdarg.h> header file. */
-#define HAVE_STDARG_H 1
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#define HAVE_STDINT_H 1
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#define HAVE_STDLIB_H 1
-
-/* Define to 1 if you have the `strcasecmp' function. */
-#define HAVE_STRCASECMP 1
-
-/* Define to 1 if you have the `strdup' function. */
-#define HAVE_STRDUP 0
-
-/* Define to 1 if you have the `strerror' function. */
-#define HAVE_STRERROR 1
-
-/* Define to 1 if you have the <strings.h> header file. */
-#undef HAVE_STRINGS_H
-
-/* Define to 1 if you have the <string.h> header file. */
-#define HAVE_STRING_H 1
-
-/* Define to 1 if you have the `strncasecmp' function. */
-#if defined(__MINGW32__)
-#define HAVE_STRNCASECMP 1
-#else
-#undef HAVE_STRNCASECMP
-#endif
-
-#cmakedefine HAVE_STRTOLL
-#cmakedefine strtoll @cmake_strtoll@
-
-/* Define to 1 if you have the <syslog.h> header file. */
-#undef HAVE_SYSLOG_H
-
-/* Define to 1 if you have the <sys/cdefs.h> header file. */
-#define HAVE_SYS_CDEFS_H 1
-
-/* Define to 1 if you have the <sys/param.h> header file. */
-#if defined(__MINGW32__)
-#define HAVE_SYS_PARAM_H 1
-#else
-#undef HAVE_SYS_PARAM_H
-#endif
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#define HAVE_SYS_STAT_H 1
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#define HAVE_SYS_TYPES_H 1
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#if defined(__MINGW32__)
-#define HAVE_UNISTD_H 1
-#else
-#undef HAVE_UNISTD_H
-#endif
-
-/* Define to 1 if you have the `vasprintf' function. */
-#if defined(__MINGW32__)
-#define HAVE_VASPRINTF 1
-#else
-#undef HAVE_VASPRINTF
-#endif
-
-/* Define to 1 if you have the `vprintf' function. */
-#define HAVE_VPRINTF 1
-
-/* Define to 1 if you have the `vsnprintf' function. */
-#define HAVE_VSNPRINTF 1
-
-/* Define to 1 if you have the `vsyslog' function. */
-#undef HAVE_VSYSLOG
-
-/* Define to the sub-directory in which libtool stores uninstalled libraries.
-   */
-#undef LT_OBJDIR
-
-/* Define to 1 if your C compiler doesn't accept -c and -o together. */
-/* #undef NO_MINUS_C_MINUS_O */
-
-/* Name of package */
-#define PACKAGE "json-c"
-
-/* Define to the address where bug reports for this package should be sent. */
-#define PACKAGE_BUGREPORT "json-c@googlegroups.com"
-
-/* Define to the full name of this package. */
-#define PACKAGE_NAME "JSON C Library"
-
-/* Define to the full name and version of this package. */
-#define PACKAGE_STRING "JSON C Library 0.12.99"
-
-/* Define to the one symbol short name of this package. */
-#define PACKAGE_TARNAME "json-c"
-
-/* Define to the home page for this package. */
-#define PACKAGE_URL "https://github.com/json-c/json-c"
-
-/* Define to the version of this package. */
-#define PACKAGE_VERSION "0.12.99"
-
-/* Define to 1 if you have the ANSI C header files. */
-#define STDC_HEADERS 1
-
-/* Version number of package */
-#define VERSION "0.12.99"
-
-/* Define to empty if `const' does not conform to ANSI C. */
-/* #undef const */
-
-/* Define to rpl_malloc if the replacement function should be used. */
-/* #undef malloc */
-
-/* Define to rpl_realloc if the replacement function should be used. */
-/* #undef realloc */
-
-/* Define to `unsigned int' if <sys/types.h> does not define. */
-/* #undef size_t */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Enable RDRANR Hardware RNG Hash Seed */
+#undef ENABLE_RDRAND
+
+/* Define if .gnu.warning accepts long strings. */
+#undef HAS_GNU_WARNING_LONG
+
+/* Define to 1 if you have the declaration of `INFINITY', and to 0 if you
+   don't. */
+#if (defined(_MSC_VER) && _MSC_VER >= 1800) || defined(__MINGW32__)
+#define HAVE_DECL_INFINITY 1
+#endif
+
+/* Define to 1 if you have the declaration of `isinf', and to 0 if you don't.
+   */
+#if (defined(_MSC_VER) && _MSC_VER >= 1800) || defined(__MINGW32__)
+#define HAVE_DECL_ISINF 1
+#endif
+
+/* Define to 1 if you have the declaration of `isnan', and to 0 if you don't.
+   */
+#if (defined(_MSC_VER) && _MSC_VER >= 1800) || defined(__MINGW32__)
+#define HAVE_DECL_ISNAN 1
+#endif
+
+/* Define to 1 if you have the declaration of `nan', and to 0 if you don't. */
+#if (defined(_MSC_VER) && _MSC_VER >= 1800) || defined(__MINGW32__)
+#define HAVE_DECL_NAN 1
+#endif
+
+/* Define to 1 if you have the declaration of `_finite', and to 0 if you
+   don't. */
+#define HAVE_DECL__FINITE 1
+
+/* Define to 1 if you have the declaration of `_isnan', and to 0 if you don't.
+   */
+#define HAVE_DECL__ISNAN 1
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#define HAVE_DLFCN_H 1
+
+/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */
+#define HAVE_DOPRNT 1
+
+/* Define to 1 if you have the <endian.h> header file. */
+#undef HAVE_ENDIAN_H
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+#define HAVE_FCNTL_H 1
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the <limits.h> header file. */
+#define HAVE_LIMITS_H 1
+
+/* Define to 1 if you have the <locale.h> header file. */
+#define HAVE_LOCALE_H 1
+
+/* Define to 1 if your system has a GNU libc compatible `malloc' function, and
+   to 0 otherwise. */
+#define HAVE_MALLOC 1
+
+/* Define to 1 if you have the <memory.h> header file. */
+#define HAVE_MEMORY_H 1
+
+/* Define to 1 if you have the `open' function. */
+#define HAVE_OPEN 1
+
+/* Define to 1 if your system has a GNU libc compatible `realloc' function,
+   and to 0 otherwise. */
+#define HAVE_REALLOC 1
+
+/* Define to 1 if you have the `setlocale' function. */
+#define HAVE_SETLOCALE 1
+
+/* Define to 1 if you have the `snprintf' function. */
+#if defined(__MINGW32__)
+#define HAVE_SNPRINTF 1
+#else
+#undef HAVE_SNPRINTF
+#endif
+
+/* Define to 1 if you have the <stdarg.h> header file. */
+#define HAVE_STDARG_H 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the `strcasecmp' function. */
+#define HAVE_STRCASECMP 1
+
+/* Define to 1 if you have the `strdup' function. */
+#define HAVE_STRDUP 0
+
+/* Define to 1 if you have the `strerror' function. */
+#define HAVE_STRERROR 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have the `strncasecmp' function. */
+#if defined(__MINGW32__)
+#define HAVE_STRNCASECMP 1
+#else
+#undef HAVE_STRNCASECMP
+#endif
+
+#cmakedefine HAVE_STRTOLL
+#cmakedefine strtoll @cmake_strtoll@
+#cmakedefine HAVE_STRTOULL
+#cmakedefine strtoull @cmake_strtoull@
+
+/* Define to 1 if you have the <syslog.h> header file. */
+#undef HAVE_SYSLOG_H
+
+/* Define to 1 if you have the <sys/cdefs.h> header file. */
+#define HAVE_SYS_CDEFS_H 1
+
+/* Define to 1 if you have the <sys/param.h> header file. */
+#if defined(__MINGW32__)
+#define HAVE_SYS_PARAM_H 1
+#else
+#undef HAVE_SYS_PARAM_H
+#endif
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#define HAVE_SYS_STAT_H 1
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#define HAVE_SYS_TYPES_H 1
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#if defined(__MINGW32__)
+#define HAVE_UNISTD_H 1
+#else
+#undef HAVE_UNISTD_H
+#endif
+
+/* Define to 1 if you have the `vasprintf' function. */
+#if defined(__MINGW32__)
+#define HAVE_VASPRINTF 1
+#else
+#undef HAVE_VASPRINTF
+#endif
+
+/* Define to 1 if you have the `vprintf' function. */
+#define HAVE_VPRINTF 1
+
+/* Define to 1 if you have the `vsnprintf' function. */
+#define HAVE_VSNPRINTF 1
+
+/* Define to 1 if you have the `vsyslog' function. */
+#undef HAVE_VSYSLOG
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+   */
+#undef LT_OBJDIR
+
+/* Define to 1 if your C compiler doesn't accept -c and -o together. */
+/* #undef NO_MINUS_C_MINUS_O */
+
+/* Name of package */
+#define PACKAGE "json-c"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "json-c@googlegroups.com"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "JSON C Library"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "JSON C Library 0.14.99"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "json-c"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL "https://github.com/json-c/json-c"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "0.14.99"
+
+/* Define to 1 if you have the ANSI C header files. */
+#define STDC_HEADERS 1
+
+/* Version number of package */
+#define VERSION "0.14.99"
+
+/* Define to empty if `const' does not conform to ANSI C. */
+/* #undef const */
+
+/* Define to rpl_malloc if the replacement function should be used. */
+/* #undef malloc */
+
+/* Define to rpl_realloc if the replacement function should be used. */
+/* #undef realloc */
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+/* #undef size_t */

configure.ac

@@ -1,186 +0,0 @@
-AC_PREREQ(2.64)
-
-# Process this file with autoconf to produce a configure script.
-AC_INIT([json-c], 0.12.99, [json-c@googlegroups.com])
-
-AM_INIT_AUTOMAKE
-
-AC_CONFIG_MACRO_DIRS([autoconf-archive/m4])
-
-AC_PROG_MAKE_SET
-
-AC_CANONICAL_HOST
-
-AC_ARG_ENABLE(threading,
- AS_HELP_STRING([--enable-threading],
-   [Enable code to support partly multi-threaded use]),
-[if test x$enableval = xyes; then
-  enable_threading=yes
-  AC_DEFINE(ENABLE_THREADING, 1, [Enable partial threading support])
-fi])
-
-if test "x$enable_threading" = "xyes"; then
-  AC_MSG_RESULT([Partial multi-threaded support enabled.])
-else
-  AC_MSG_RESULT([Multi-threaded support disabled. Use --enable-threading to enable.])
-fi
-
-AC_ARG_ENABLE(rdrand,
- AS_HELP_STRING([--enable-rdrand],
-   [Enable RDRAND Hardware RNG Hash Seed generation on supported x86/x64 platforms.]),
-[if test x$enableval = xyes; then
-  enable_rdrand=yes
-  AC_DEFINE(ENABLE_RDRAND, 1, [Enable RDRAND Hardware RNG Hash Seed])
-fi])
-
-if test "x$enable_rdrand" = "xyes"; then
-  AC_MSG_RESULT([RDRAND Hardware RNG Hash Seed enabled on supported x86/x64 platforms])
-else
-  AC_MSG_RESULT([RDRAND Hardware RNG Hash Seed disabled. Use --enable-rdrand to enable])
-fi
-
-# enable silent build by default
-m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
-
-# Checks for programs.
-
-# Checks for libraries.
-
-# Checks for header files.
-AM_PROG_CC_C_O
-AC_PROG_CC_C99
-AC_CONFIG_HEADER(config.h)
-AC_CONFIG_HEADER(json_config.h)
-AC_HEADER_STDC
-AC_CHECK_HEADERS(fcntl.h limits.h strings.h syslog.h unistd.h [sys/cdefs.h] [sys/param.h] stdarg.h locale.h xlocale.h endian.h)
-AC_CHECK_HEADER(inttypes.h,[AC_DEFINE([JSON_C_HAVE_INTTYPES_H],[1],[Public define for json_inttypes.h])])
-
-# Checks for typedefs, structures, and compiler characteristics.
-AC_C_CONST
-AC_TYPE_SIZE_T
-
-AC_CACHE_CHECK([for __thread support], ac_cv___thread, [dnl
-AC_LINK_IFELSE([dnl
-AC_LANG_PROGRAM([[#undef __thread
-static __thread int a; int foo (int b) { return a + b; }]],
-		[[exit (foo (0));]])],
-	       ac_cv___thread=yes, ac_cv___thread=no)
-])
-AS_IF([test "x$ac_cv___thread" != xno],
-[AC_DEFINE(HAVE___THREAD, 1, [Have __thread])
- AC_DEFINE(SPEC___THREAD, [__thread], [Specifier for __thread])]
-)
-
-# Checks for library functions.
-AC_FUNC_VPRINTF
-AC_FUNC_MEMCMP
-AC_CHECK_FUNCS([realloc])
-AC_CHECK_FUNCS(strcasecmp strdup strerror snprintf vsnprintf vasprintf open vsyslog strncasecmp setlocale)
-AC_CHECK_DECLS([INFINITY], [], [], [[#include <math.h>]])
-AC_CHECK_DECLS([nan], [], [], [[#include <math.h>]])
-AC_CHECK_DECLS([isnan], [], [], [[#include <math.h>]])
-AC_CHECK_DECLS([isinf], [], [], [[#include <math.h>]])
-AC_CHECK_DECLS([_isnan], [], [], [[#include <float.h>]])
-AC_CHECK_DECLS([_finite], [], [], [[#include <float.h>]])
-AC_MSG_CHECKING(for GCC atomic builtins)
-AC_LINK_IFELSE(
-[
- AC_LANG_SOURCE([[
-   int main() {
-      volatile unsigned int val = 1;
-      /* Note: __sync_val_compare_and_swap isn't checked here
-       * because it's protected by __GCC_HAVE_SYNC_COMPARE_AND_SWAP_<n>,
-       * which is automatically defined by gcc.
-       */
-      __sync_add_and_fetch(&val, 1);
-      __sync_sub_and_fetch(&val, 1);
-      return 0;
-   }
- ]])
-],
-[
- AC_MSG_RESULT([yes])
- AC_DEFINE([HAVE_ATOMIC_BUILTINS],[1],[Has atomic builtins])
-],
-[
- AC_MSG_RESULT([no])
- AC_MSG_WARN([json-c will be built without atomic refcounts because atomic builtins are missing])
-])
-
-case "${host_os}" in
-	linux*)
-		AC_CHECK_FUNCS([uselocale])
-		;;
-	*)	# Nothing
-		;;
-esac
-
-if test "$ac_cv_have_decl_isnan" = "yes" ; then
-   AC_TRY_LINK([#include <math.h>], [float f = 0.0; return isnan(f)], [], [LIBS="$LIBS -lm"])
-fi
-
-#check if .section.gnu.warning accepts long strings (for __warn_references)
-AC_LANG_PUSH([C])
-
-AC_MSG_CHECKING([if .gnu.warning accepts long strings])
-AC_LINK_IFELSE([AC_LANG_SOURCE([[
-extern void json_object_get();
-__asm__(".section .gnu.json_object_get,\n\t.ascii \"Please link against libjson-c instead of libjson\"\n\t.text");
-
-int main(int c,char* v) {return 0;}
-]])], [
-    AC_DEFINE(HAS_GNU_WARNING_LONG, 1, [Define if .gnu.warning accepts long strings.])
-    AC_MSG_RESULT(yes)
-], [
-   AC_MSG_RESULT(no)
-])
-
-AC_LANG_POP([C])
-
-LT_INIT
-
-# Check for the -Bsymbolic-functions linker flag
-AC_ARG_ENABLE([Bsymbolic],
-              [AS_HELP_STRING([--disable-Bsymbolic], [Avoid linking with -Bsymbolic-function])],
-              [],
-              [enable_Bsymbolic=check])
-
-AS_IF([test "x$enable_Bsymbolic" = "xcheck"],
-      [
-        saved_LDFLAGS="${LDFLAGS}"
-        AC_MSG_CHECKING([for -Bsymbolic-functions linker flag])
-        LDFLAGS=-Wl,-Bsymbolic-functions
-        AC_TRY_LINK([], [int main (void) { return 0; }],
-                    [
-                      AC_MSG_RESULT([yes])
-                      enable_Bsymbolic=yes
-                    ],
-                    [
-                      AC_MSG_RESULT([no])
-                      enable_Bsymbolic=no
-                    ])
-        LDFLAGS="${saved_LDFLAGS}"
-      ])
-
-AS_IF([test "x$enable_Bsymbolic" = "xyes"], [JSON_BSYMBOLIC_LDFLAGS=-Wl[,]-Bsymbolic-functions])
-AC_SUBST(JSON_BSYMBOLIC_LDFLAGS)
-
-AX_APPEND_COMPILE_FLAGS([-Wall -Werror -Wcast-qual -Wno-error=deprecated-declarations])
-AX_APPEND_COMPILE_FLAGS([-Wextra -Wwrite-string -Wno-unused-parameter])
-AX_APPEND_COMPILE_FLAGS([-D_GNU_SOURCE -D_REENTRANT])
-
-AX_COMPILE_CHECK_SIZEOF(int)
-AX_COMPILE_CHECK_SIZEOF(long)
-AX_COMPILE_CHECK_SIZEOF(long long)
-AX_COMPILE_CHECK_SIZEOF(size_t, [#include <stdint.h>])
-AX_COMPILE_CHECK_SIZEOF(int64_t, [#include <stdint.h>])
-
-AC_CONFIG_FILES([
-Makefile
-json-c.pc
-tests/Makefile
-json-c-uninstalled.pc
-])
-
-AC_OUTPUT
-

debug.c

@@ -11,17 +11,17 @@
 
 #include "config.h"
 
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <stdarg.h>
 
 #if HAVE_SYSLOG_H
-# include <syslog.h>
+#include <syslog.h>
 #endif /* HAVE_SYSLOG_H */
 
 #if HAVE_UNISTD_H
-# include <unistd.h>
+#include <unistd.h>
 #endif /* HAVE_UNISTD_H */
 
 #if HAVE_SYS_PARAM_H
@@ -33,51 +33,64 @@
 static int _syslog = 0;
 static int _debug = 0;
 
-void mc_set_debug(int debug) { _debug = debug; }
-int mc_get_debug(void) { return _debug; }
+void mc_set_debug(int debug)
+{
+	_debug = debug;
+}
+int mc_get_debug(void)
+{
+	return _debug;
+}
 
 extern void mc_set_syslog(int syslog)
 {
-  _syslog = syslog;
+	_syslog = syslog;
 }
 
 void mc_debug(const char *msg, ...)
 {
-  va_list ap;
-  if(_debug) {
-    va_start(ap, msg);
+	va_list ap;
+	if (_debug)
+	{
+		va_start(ap, msg);
 #if HAVE_VSYSLOG
-    if(_syslog) {
-		vsyslog(LOG_DEBUG, msg, ap);
-	} else
+		if (_syslog)
+		{
+			vsyslog(LOG_DEBUG, msg, ap);
+		}
+		else
 #endif
-		vprintf(msg, ap);
-    va_end(ap);
-  }
+			vprintf(msg, ap);
+		va_end(ap);
+	}
 }
 
 void mc_error(const char *msg, ...)
 {
-  va_list ap;
-  va_start(ap, msg);
+	va_list ap;
+	va_start(ap, msg);
 #if HAVE_VSYSLOG
-    if(_syslog) {
+	if (_syslog)
+	{
 		vsyslog(LOG_ERR, msg, ap);
-	} else
+	}
+	else
 #endif
 		vfprintf(stderr, msg, ap);
-  va_end(ap);
+	va_end(ap);
 }
 
 void mc_info(const char *msg, ...)
 {
-  va_list ap;
-  va_start(ap, msg);
+	va_list ap;
+	va_start(ap, msg);
 #if HAVE_VSYSLOG
-    if(_syslog) {
+	if (_syslog)
+	{
 		vsyslog(LOG_INFO, msg, ap);
-	} else
+	}
+	else
 #endif
 		vfprintf(stderr, msg, ap);
-  va_end(ap);
+	va_end(ap);
 }

debug.h

@@ -23,14 +23,22 @@
 extern "C" {
 #endif
 
-extern void mc_set_debug(int debug);
-extern int mc_get_debug(void);
+#ifndef JSON_EXPORT
+#if defined(_MSC_VER)
+#define JSON_EXPORT __declspec(dllexport)
+#else
+#define JSON_EXPORT extern
+#endif
+#endif
 
-extern void mc_set_syslog(int syslog);
+JSON_EXPORT void mc_set_debug(int debug);
+JSON_EXPORT int mc_get_debug(void);
 
-extern void mc_debug(const char *msg, ...);
-extern void mc_error(const char *msg, ...);
-extern void mc_info(const char *msg, ...);
+JSON_EXPORT void mc_set_syslog(int syslog);
+
+JSON_EXPORT void mc_debug(const char *msg, ...);
+JSON_EXPORT void mc_error(const char *msg, ...);
+JSON_EXPORT void mc_info(const char *msg, ...);
 
 #ifndef __STRING
 #define __STRING(x) #x
@@ -38,17 +46,24 @@ extern void mc_info(const char *msg, ...);
 
 #ifndef PARSER_BROKEN_FIXED
 
-#define JASSERT(cond) do {} while(0)
+#define JASSERT(cond) \
+	do            \
+	{             \
+	} while (0)
 
 #else
 
-#define JASSERT(cond) do { \
-		if (!(cond)) { \
-			mc_error("cjson assert failure %s:%d : cond \"" __STRING(cond) "failed\n", __FILE__, __LINE__); \
-			*(int *)0 = 1;\
-			abort(); \
-		}\
-	} while(0)
+#define JASSERT(cond)                                                                              \
+	do                                                                                         \
+	{                                                                                          \
+		if (!(cond))                                                                       \
+		{                                                                                  \
+			mc_error("cjson assert failure %s:%d : cond \"" __STRING(cond) "failed\n", \
+			         __FILE__, __LINE__);                                              \
+			*(int *)0 = 1;                                                             \
+			abort();                                                                   \
+		}                                                                                  \
+	} while (0)
 
 #endif
 
@@ -61,11 +76,19 @@ extern void mc_info(const char *msg, ...);
 #define MC_DEBUG(x, ...) mc_debug(x, ##__VA_ARGS__)
 #define MC_INFO(x, ...) mc_info(x, ##__VA_ARGS__)
 #else
-#define MC_SET_DEBUG(x) if (0) mc_set_debug(x)
+#define MC_SET_DEBUG(x) \
+	if (0)          \
+	mc_set_debug(x)
 #define MC_GET_DEBUG() (0)
-#define MC_SET_SYSLOG(x) if (0) mc_set_syslog(x)
-#define MC_DEBUG(x, ...) if (0) mc_debug(x, ##__VA_ARGS__)
-#define MC_INFO(x, ...) if (0) mc_info(x, ##__VA_ARGS__)
+#define MC_SET_SYSLOG(x) \
+	if (0)           \
+	mc_set_syslog(x)
+#define MC_DEBUG(x, ...) \
+	if (0)           \
+	mc_debug(x, ##__VA_ARGS__)
+#define MC_INFO(x, ...) \
+	if (0)          \
+	mc_info(x, ##__VA_ARGS__)
 #endif
 
 #ifdef __cplusplus

doc/CMakeLists.txt

@@ -0,0 +1,16 @@
+# generate doxygen documentation for json-c API
+
+find_package(Doxygen)
+
+if (DOXYGEN_FOUND)
+
+	configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in
+	  ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
+	message(STATUS "Wrote ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile")
+
+	add_custom_target(doc
+	COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
+
+else (DOXYGEN_FOUND)
+	message("Warning: doxygen not found, the 'doc' target will not be included")
+endif(DOXYGEN_FOUND)

doc/Doxyfile.in

@@ -38,7 +38,7 @@ PROJECT_NAME           = json-c
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 0.12.99
+PROJECT_NUMBER         = @PROJECT_VERSION@
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -58,7 +58,7 @@ PROJECT_LOGO           =
 # entered, it will be relative to the location where doxygen was started. If
 # left blank the current directory will be used.
 
-OUTPUT_DIRECTORY       = doc
+OUTPUT_DIRECTORY       = @CMAKE_CURRENT_BINARY_DIR@
 
 # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub-
 # directories (in 2 levels) under the output directory of each output format and
@@ -753,8 +753,7 @@ WARN_LOGFILE           =
 # spaces.
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = README.md \
-                         .
+INPUT                  = @CMAKE_SOURCE_DIR@ @CMAKE_BINARY_DIR@
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -891,7 +890,7 @@ FILTER_SOURCE_PATTERNS =
 # (index.html). This can be useful if you have a project on for instance GitHub
 # and want to reuse the introduction page also for the doxygen output.
 
-USE_MDFILE_AS_MAINPAGE =
+USE_MDFILE_AS_MAINPAGE = README.md
 
 #---------------------------------------------------------------------------
 # Configuration options related to source browsing

fuzz/README.md

@@ -0,0 +1,6 @@
+# Fuzzers
+
+This directory contains fuzzers that
+target [llvm's LibFuzzer](https://llvm.org/docs/LibFuzzer.html). They are built
+and run automatically by
+Google's [OSS-Fuzz](https://github.com/google/oss-fuzz/) infrastructure.

fuzz/build.sh

@@ -0,0 +1,52 @@
+#!/bin/bash -eu
+# Copyright 2018 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+# This should be run from the top of the json-c source tree.
+
+mkdir build
+cd build
+cmake -DBUILD_SHARED_LIBS=OFF ..
+make -j$(nproc)
+
+LIB=$(pwd)/libjson-c.a
+cd ..
+
+# These seem to be set externally, but let's assign defaults to
+# make it possible to at least partially test this standalone.
+: ${SRC:=$(dirname "$0")}
+: ${OUT:=$SRC/out}
+: ${CXX:=gcc}
+: ${CXXFLAGS:=}
+
+[ -d "$OUT" ] || mkdir "$OUT"
+cp $SRC/*.dict $OUT/.
+
+# XXX this doesn't seem to make much sense, since $SRC is presumably
+# the "fuzz" directory, which is _inside_ the json-c repo, rather than
+# the other way around, but I'm just preserving existing behavior. -erh
+INCS=$SRC/json-c
+# Compat when testing standalone
+[ -e "${INCS}" ] || ln -s .. "${INCS}"
+
+set -x
+set -v
+for f in $SRC/*_fuzzer.cc; do
+    fuzzer=$(basename "$f" _fuzzer.cc)
+    $CXX $CXXFLAGS -std=c++11 -I$INCS \
+         $SRC/${fuzzer}_fuzzer.cc -o $OUT/${fuzzer}_fuzzer \
+         -lFuzzingEngine $LIB
+done

fuzz/tokener_parse_ex_fuzzer.cc

@@ -0,0 +1,14 @@
+#include <stdint.h>
+
+#include <json.h>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
+{
+	const char *data1 = reinterpret_cast<const char *>(data);
+	json_tokener *tok = json_tokener_new();
+	json_object *obj = json_tokener_parse_ex(tok, data1, size);
+
+	json_object_put(obj);
+	json_tokener_free(tok);
+	return 0;
+}

fuzz/tokener_parse_ex_fuzzer.dict

@@ -0,0 +1,18 @@
+"{"
+"}"
+","
+"["
+"]"
+","
+":"
+"e"
+"e+"
+"e-"
+"E"
+"E+"
+"E-"
+"\""
+"null"
+"1"
+"1.234"
+"3e4"

issues_closed_for_0.13.md

@@ -1,267 +1,270 @@
 
 This list was created with:
 
+```
 curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2014-04-10+created%3A<2017-12-01&sort=created&order=asc&per_page=400&page=1" > issues1.out
 curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2014-04-10+created%3A<2017-12-01&sort=created&order=asc&per_page=400&page=2" > issues2.out
 curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2014-04-10+created%3A<2017-12-01&sort=created&order=asc&per_page=400&page=3" > issues3.out
 jq -r '.items[] | "[" + .title + "](" + .url + ")" | tostring' issues?.out  > issues.md
+sed -e's,^\[ *\(.*\)\](https://api.github.com/.*/\([0-9].*\)),[Issue #\2](https://github.com/json-c/json-c/issues/\2) - \1,' -i issues.md
 #... manual editing ...
+```
 
 ----
 
 Issues and Pull Requests closed for the 0.13 release
 (since commit f84d9c, the 0.12 branch point, 2014-04-10)
 
-[Make json_object_object_add() indicate success or failure, test fix](https://api.github.com/repos/json-c/json-c/issues/61)
-[Build fixes (make dist and make distcheck)](https://api.github.com/repos/json-c/json-c/issues/113)
-[Fixing build](https://api.github.com/repos/json-c/json-c/issues/124)
-[Fix compile error(variable size set but not used) on g++4.6](https://api.github.com/repos/json-c/json-c/issues/125)
-[Removed unused size variable.](https://api.github.com/repos/json-c/json-c/issues/126)
-[remove unused `size` variable](https://api.github.com/repos/json-c/json-c/issues/127)
-[Remove unused variable from json_tokenizer.c](https://api.github.com/repos/json-c/json-c/issues/128)
-[Failed to compile under Ubuntu 13.10 32bit](https://api.github.com/repos/json-c/json-c/issues/130)
-[undefined symbol: __sync_val_compare_and_swap_4 ](https://api.github.com/repos/json-c/json-c/issues/131)
-[Remove unused variable 'size'](https://api.github.com/repos/json-c/json-c/issues/132)
-[Update and rename README to README.md](https://api.github.com/repos/json-c/json-c/issues/133)
-[Must remove variable size...](https://api.github.com/repos/json-c/json-c/issues/134)
-[bits.h uses removed json_tokener_errors\[error\]](https://api.github.com/repos/json-c/json-c/issues/135)
-[Error when running make check](https://api.github.com/repos/json-c/json-c/issues/136)
-[config.h.in should not be in git](https://api.github.com/repos/json-c/json-c/issues/137)
-[Can't build on RHEL 6.5 due to dependency on automake-1.14](https://api.github.com/repos/json-c/json-c/issues/138)
-[Code bug in random_test.c evaluating same expression twice ](https://api.github.com/repos/json-c/json-c/issues/140)
-[Removed duplicate check in random_seed test - bug #140](https://api.github.com/repos/json-c/json-c/issues/141)
-[Please undeprecate json_object_object_get](https://api.github.com/repos/json-c/json-c/issues/142)
-[Introduce json_object_from_fd](https://api.github.com/repos/json-c/json-c/issues/144)
-[Handle % character properly](https://api.github.com/repos/json-c/json-c/issues/145)
-[TAGS rename](https://api.github.com/repos/json-c/json-c/issues/146)
-[Bump the soname](https://api.github.com/repos/json-c/json-c/issues/148)
-[SONAME bump](https://api.github.com/repos/json-c/json-c/issues/149)
-[Fix build using MinGW.](https://api.github.com/repos/json-c/json-c/issues/150)
-[Remove json_type enum trailing comma](https://api.github.com/repos/json-c/json-c/issues/151)
-[error while compiling json-c library version 0.11](https://api.github.com/repos/json-c/json-c/issues/152)
-[improve doc for json_object_to_json_string()](https://api.github.com/repos/json-c/json-c/issues/153)
-[double precision](https://api.github.com/repos/json-c/json-c/issues/154)
-[add bsearch for arrays](https://api.github.com/repos/json-c/json-c/issues/155)
-[Remove trailing whitespaces](https://api.github.com/repos/json-c/json-c/issues/156)
-[JSON-C shall not exit on calloc fail.](https://api.github.com/repos/json-c/json-c/issues/157)
-[while using json-c 0.11, I am facing strange crash issue in json_object_put.](https://api.github.com/repos/json-c/json-c/issues/158)
-[json_tokener.c compile error](https://api.github.com/repos/json-c/json-c/issues/159)
-[missing header file on windows??](https://api.github.com/repos/json-c/json-c/issues/160)
-[Is there a way to append to file?](https://api.github.com/repos/json-c/json-c/issues/161)
-[json_util: add directory check for POSIX distros](https://api.github.com/repos/json-c/json-c/issues/162)
-[Fix Win32 build problems](https://api.github.com/repos/json-c/json-c/issues/163)
-[made it compile and link on Widnows (as static library)](https://api.github.com/repos/json-c/json-c/issues/164)
-[json_object_to_json_string_ext length](https://api.github.com/repos/json-c/json-c/issues/165)
-[Can't build on Windows with Visual Studio 2010](https://api.github.com/repos/json-c/json-c/issues/167)
-[Tightening the number parsing algorithm](https://api.github.com/repos/json-c/json-c/issues/168)
-[Doesn't compile on ubuntu 14.04, 64bit](https://api.github.com/repos/json-c/json-c/issues/169)
-[Generated files in repository](https://api.github.com/repos/json-c/json-c/issues/170)
-[Update configuration for VS2010 and win64](https://api.github.com/repos/json-c/json-c/issues/171)
-[Adding support for parsing octal numbers](https://api.github.com/repos/json-c/json-c/issues/172)
-[json_parse_int64 doesn't work correctly at illumos](https://api.github.com/repos/json-c/json-c/issues/173)
-[Adding JSON_C_TO_STRING_PRETTY_TAB flag](https://api.github.com/repos/json-c/json-c/issues/174)
-[make check fails 4 tests with overflows when built with ASAN](https://api.github.com/repos/json-c/json-c/issues/175)
-[Possible to delete an array element at a given idx ?](https://api.github.com/repos/json-c/json-c/issues/176)
-[Fix compiler warnings](https://api.github.com/repos/json-c/json-c/issues/177)
-[Unable to compile on CentOS5](https://api.github.com/repos/json-c/json-c/issues/178)
-[Added array_list_del_idx and json_object_array_del_idx](https://api.github.com/repos/json-c/json-c/issues/179)
-[Enable silent build by default](https://api.github.com/repos/json-c/json-c/issues/180)
-[json_tokener_parse_ex accepts invalid JSON](https://api.github.com/repos/json-c/json-c/issues/181)
-[Link against libm when needed](https://api.github.com/repos/json-c/json-c/issues/182)
-[Apply compile warning fix to master branch](https://api.github.com/repos/json-c/json-c/issues/183)
-[Use only GCC-specific flags when compiling with GCC](https://api.github.com/repos/json-c/json-c/issues/184)
-[compile error](https://api.github.com/repos/json-c/json-c/issues/185)
-[Syntax error](https://api.github.com/repos/json-c/json-c/issues/186)
-[array_list_get_idx and negative indexes.](https://api.github.com/repos/json-c/json-c/issues/187)
-[json_object_object_foreach warnings](https://api.github.com/repos/json-c/json-c/issues/188)
-[noisy json_object_from_file: error opening file](https://api.github.com/repos/json-c/json-c/issues/189)
-[warning: initialization discards const qualifier from pointer target type \[enabled by default\]](https://api.github.com/repos/json-c/json-c/issues/190)
-[json_tokener_parse  accepts invalid JSON {"key": "value" ,  }](https://api.github.com/repos/json-c/json-c/issues/192)
-[Make serialization format of doubles configurable](https://api.github.com/repos/json-c/json-c/issues/193)
-[Add utility function for comparing json_objects](https://api.github.com/repos/json-c/json-c/issues/194)
-[Call uselocale instead of setlocale](https://api.github.com/repos/json-c/json-c/issues/195)
-[Performance improvements](https://api.github.com/repos/json-c/json-c/issues/196)
-[Time for a new release?](https://api.github.com/repos/json-c/json-c/issues/197)
-[Fix possible memory leak and remove superfluous NULL checks before free()](https://api.github.com/repos/json-c/json-c/issues/198)
-[Fix build in Visual Studio](https://api.github.com/repos/json-c/json-c/issues/199)
-[Add build scripts for CI platforms](https://api.github.com/repos/json-c/json-c/issues/200)
-[disable forward-slash escaping?](https://api.github.com/repos/json-c/json-c/issues/201)
-[Array with objects support](https://api.github.com/repos/json-c/json-c/issues/202)
-[Add source position/coordinates to API](https://api.github.com/repos/json-c/json-c/issues/203)
-[json-c/json.h not found ](https://api.github.com/repos/json-c/json-c/issues/204)
-[json-c Compiled with Visual Studios](https://api.github.com/repos/json-c/json-c/issues/205)
-[what do i use in place of json_object_object_get?](https://api.github.com/repos/json-c/json-c/issues/206)
-[Add support for property pairs directly added to arrays](https://api.github.com/repos/json-c/json-c/issues/207)
-[Performance enhancements (mainly) to json_object_to_json_string()](https://api.github.com/repos/json-c/json-c/issues/208)
-[fix regression from 2d549662be832da838aa063da2efa78ee3b99668](https://api.github.com/repos/json-c/json-c/issues/209)
-[Use size_t for arrays](https://api.github.com/repos/json-c/json-c/issues/210)
-[Atomic updates for the refcount](https://api.github.com/repos/json-c/json-c/issues/211)
-[Refcount doesn't work between threads](https://api.github.com/repos/json-c/json-c/issues/212)
-[fix to compile with microsoft visual c++ 2010](https://api.github.com/repos/json-c/json-c/issues/213)
-[Some non-GNU systems support __sync_val_compare_and_swap](https://api.github.com/repos/json-c/json-c/issues/214)
-[Build json-c for window 64 bit.](https://api.github.com/repos/json-c/json-c/issues/215)
-[configure: check realloc with AC_CHECK_FUNCS() to fix cross-compilation.](https://api.github.com/repos/json-c/json-c/issues/216)
-[Checking for functions in float.h](https://api.github.com/repos/json-c/json-c/issues/217)
-[Use a macro to indicate C99 to the compiler](https://api.github.com/repos/json-c/json-c/issues/218)
-[Fix various potential null ptr deref and int32 overflows](https://api.github.com/repos/json-c/json-c/issues/219)
-[Add utility function for comparing json_objects](https://api.github.com/repos/json-c/json-c/issues/220)
-[JSON_C_TO_STRING_NOSLASHESCAPE works incorrectly](https://api.github.com/repos/json-c/json-c/issues/221)
-[Fix issue #221: JSON_C_TO_STRING_NOSLASHESCAPE works incorrectly](https://api.github.com/repos/json-c/json-c/issues/222)
-[Clarify json_object_get_string documentation of NULL handling & return](https://api.github.com/repos/json-c/json-c/issues/223)
-[json_tokener.c - all warnings being treated as errors](https://api.github.com/repos/json-c/json-c/issues/224)
-[Hi, will you support clib as a "registry"?](https://api.github.com/repos/json-c/json-c/issues/225)
-[Bump SOVERSION to 3](https://api.github.com/repos/json-c/json-c/issues/227)
-[avoid double slashes from json](https://api.github.com/repos/json-c/json-c/issues/228)
-[configure fails: checking size of size_t... configure: error: cannot determine a size for size_t](https://api.github.com/repos/json-c/json-c/issues/229)
-[Use stdint.h to check for size_t size](https://api.github.com/repos/json-c/json-c/issues/230)
-[Fix size_t size check for first-time builds](https://api.github.com/repos/json-c/json-c/issues/231)
-[tests/tests1: fix printf format for size_t arguments](https://api.github.com/repos/json-c/json-c/issues/232)
-[Include stddef.h in json_object.h](https://api.github.com/repos/json-c/json-c/issues/233)
-[Add public API to use userdata independently of custom serializer](https://api.github.com/repos/json-c/json-c/issues/234)
-[Undefined symbols Error for architecture x86_64 on Mac ](https://api.github.com/repos/json-c/json-c/issues/235)
-[Building a project which uses json-c with flag -Wcast-qual causes compilation errors](https://api.github.com/repos/json-c/json-c/issues/236)
-[handle escaped utf-8](https://api.github.com/repos/json-c/json-c/issues/237)
-[linkhash.c: optimised the table_free path](https://api.github.com/repos/json-c/json-c/issues/238)
-[initialize null terminator of new printbuf](https://api.github.com/repos/json-c/json-c/issues/239)
-[Compile error: Variable set but not used](https://api.github.com/repos/json-c/json-c/issues/240)
-[getting error in date string 19\/07\/2016, fixed for error 19/07/2016](https://api.github.com/repos/json-c/json-c/issues/241)
-[json_tokener_parse error](https://api.github.com/repos/json-c/json-c/issues/242)
-[Fix #165](https://api.github.com/repos/json-c/json-c/issues/243)
-[Error while compiling source from RHEL5, could you please help me to fix this ](https://api.github.com/repos/json-c/json-c/issues/244)
-[json-c compile in window xp](https://api.github.com/repos/json-c/json-c/issues/245)
-[Mac: uselocale failed to build](https://api.github.com/repos/json-c/json-c/issues/246)
-[json_object_array_del_idx function has segment fault error?](https://api.github.com/repos/json-c/json-c/issues/247)
-[Minor changes in C source code](https://api.github.com/repos/json-c/json-c/issues/248)
-[Improving README](https://api.github.com/repos/json-c/json-c/issues/249)
-[Improving .gitignore](https://api.github.com/repos/json-c/json-c/issues/250)
-[Adding a file for EditorConfig](https://api.github.com/repos/json-c/json-c/issues/251)
-[Very minor changes not related to C source code](https://api.github.com/repos/json-c/json-c/issues/252)
-[Adding a test with cppcheck for Travis CI](https://api.github.com/repos/json-c/json-c/issues/253)
-[Very minor changes to some tests](https://api.github.com/repos/json-c/json-c/issues/254)
-[Minor changes in C source code](https://api.github.com/repos/json-c/json-c/issues/255)
-[Mailing list dead?](https://api.github.com/repos/json-c/json-c/issues/256)
-[Defining a coding style](https://api.github.com/repos/json-c/json-c/issues/257)
-[Enable CI services](https://api.github.com/repos/json-c/json-c/issues/258)
-[Fails to parse valid json](https://api.github.com/repos/json-c/json-c/issues/259)
-[Adding an object to itself](https://api.github.com/repos/json-c/json-c/issues/260)
-[Lack of proper documentation](https://api.github.com/repos/json-c/json-c/issues/261)
-[Add Cmakefile and fix compiler warning.](https://api.github.com/repos/json-c/json-c/issues/262)
-[Compiler Warnings with VS2015](https://api.github.com/repos/json-c/json-c/issues/263)
-[successed in simple test   while failed in my project](https://api.github.com/repos/json-c/json-c/issues/264)
-[Conformance report for reference](https://api.github.com/repos/json-c/json-c/issues/265)
-[crash perhaps related to reference counting](https://api.github.com/repos/json-c/json-c/issues/266)
-[Removes me as Win32 maintainer, because I'm not.](https://api.github.com/repos/json-c/json-c/issues/267)
-[Documentation of json_object_to_json_string gives no information about memory management](https://api.github.com/repos/json-c/json-c/issues/268)
-[json_object_<type>_set(json_object *o,<type> value) API for value setting in json object private structure](https://api.github.com/repos/json-c/json-c/issues/269)
-[new API json_object_new_double_f(doubel d,const char * fmt);](https://api.github.com/repos/json-c/json-c/issues/270)
-[Cannot compile using CMake on macOS](https://api.github.com/repos/json-c/json-c/issues/271)
-[fixed wrong object name in json_object_all_values_equal](https://api.github.com/repos/json-c/json-c/issues/273)
-[Support for 64 bit pointers on Windows](https://api.github.com/repos/json-c/json-c/issues/274)
-[Out-of-bounds read in json_tokener_parse_ex](https://api.github.com/repos/json-c/json-c/issues/275)
-[ ./configure for centos release 6.7(final) failure](https://api.github.com/repos/json-c/json-c/issues/276)
-[Json object set xxx](https://api.github.com/repos/json-c/json-c/issues/277)
-[Serialization of double with no fractional component drops trailing zero](https://api.github.com/repos/json-c/json-c/issues/278)
-[Segmentation fault in array_list_length()](https://api.github.com/repos/json-c/json-c/issues/279)
-[Should json_object_array_get_idx  check whether input obj is array? ](https://api.github.com/repos/json-c/json-c/issues/280)
-[how to pretty print json-c? ](https://api.github.com/repos/json-c/json-c/issues/281)
-[ignore temporary files](https://api.github.com/repos/json-c/json-c/issues/282)
-[json_pointer: add first revision based on RFC 6901](https://api.github.com/repos/json-c/json-c/issues/283)
-[Resusing  json_tokener object](https://api.github.com/repos/json-c/json-c/issues/284)
-[Revert "compat/strdup.h: move common compat check for strdup() to own](https://api.github.com/repos/json-c/json-c/issues/285)
-[json_tokener_parse_ex() returns json_tokener_continue on zero-length string](https://api.github.com/repos/json-c/json-c/issues/286)
-[json_pointer: extend setter & getter with printf() style arguments](https://api.github.com/repos/json-c/json-c/issues/287)
-[Fix _GNU_SOURCE define for vasprintf](https://api.github.com/repos/json-c/json-c/issues/288)
-[bugfix: floating point representaion without fractional part ](https://api.github.com/repos/json-c/json-c/issues/289)
-[duplicate an json_object](https://api.github.com/repos/json-c/json-c/issues/290)
-[isspace assert error](https://api.github.com/repos/json-c/json-c/issues/291)
-[configure error  "./configure: line 13121: syntax error near unexpected token `-Wall'"](https://api.github.com/repos/json-c/json-c/issues/292)
-[how to make with bitcode for ios](https://api.github.com/repos/json-c/json-c/issues/293)
-[Adding UTF-8 validation.  Fixes #122](https://api.github.com/repos/json-c/json-c/issues/294)
-[cross compile w/ mingw](https://api.github.com/repos/json-c/json-c/issues/295)
-[Missing functions header in json_object.h](https://api.github.com/repos/json-c/json-c/issues/296)
-[could not parse string to Json object? Like string str=\"helloworld;E\\test\\log\\;end\"](https://api.github.com/repos/json-c/json-c/issues/297)
-[Building using CMake doesn't work](https://api.github.com/repos/json-c/json-c/issues/298)
-[Improve json_object -> string performance](https://api.github.com/repos/json-c/json-c/issues/299)
-[Running tests with MinGW build](https://api.github.com/repos/json-c/json-c/issues/300)
-[How to deep copy  json_object in C++ ?](https://api.github.com/repos/json-c/json-c/issues/301)
-[json_tokener_parse_ex doesn't parse JSON values](https://api.github.com/repos/json-c/json-c/issues/302)
-[fix doc in tokener header file](https://api.github.com/repos/json-c/json-c/issues/303)
-[(.text+0x72846): undefined reference to `is_error'](https://api.github.com/repos/json-c/json-c/issues/304)
-[Fix compilation without C-99 option](https://api.github.com/repos/json-c/json-c/issues/305)
-[./configure: line 12748 -error=deprecated-declarations](https://api.github.com/repos/json-c/json-c/issues/306)
-[Memory leak in json_tokener_parse](https://api.github.com/repos/json-c/json-c/issues/307)
-[AM_PROG_LIBTOOL not found on Linux](https://api.github.com/repos/json-c/json-c/issues/308)
-[GCC 7 reports various -Wimplicit-fallthrough= errors](https://api.github.com/repos/json-c/json-c/issues/309)
-[Add FALLTHRU comment to handle GCC7 warnings.](https://api.github.com/repos/json-c/json-c/issues/310)
-[Fix error C3688 when compiling on Visual Studio 2015](https://api.github.com/repos/json-c/json-c/issues/311)
-[Fix CMake Build process improved for MinGW and MSYS2](https://api.github.com/repos/json-c/json-c/issues/312)
-[VERBOSE=1 make check; tests/test_util_file.test.c and tests/test_util_file.expected out of sync](https://api.github.com/repos/json-c/json-c/issues/313)
-[Passing -1 to json_tokener_parse_ex is possibly unsafe](https://api.github.com/repos/json-c/json-c/issues/315)
-[Memory Returned by json_object_to_json_string not freed](https://api.github.com/repos/json-c/json-c/issues/316)
-[json_object_get_string gives segmentation error](https://api.github.com/repos/json-c/json-c/issues/317)
-[PVS-Studio static analyzer analyze results](https://api.github.com/repos/json-c/json-c/issues/318)
-[Windows: Fix dynamic library build with Visual Studio](https://api.github.com/repos/json-c/json-c/issues/319)
-[Can't compile in Mac OS X El Capitan](https://api.github.com/repos/json-c/json-c/issues/320)
-[build,cmake: fix vasprintf implicit definition and generate both static & shared libs](https://api.github.com/repos/json-c/json-c/issues/321)
-[can not link with libjson-c.a](https://api.github.com/repos/json-c/json-c/issues/322)
-[implicit fallthrough detected by gcc 7.1](https://api.github.com/repos/json-c/json-c/issues/323)
-[JsonPath like function?](https://api.github.com/repos/json-c/json-c/issues/324)
-[Fix stack buffer overflow in json_object_double_to_json_string_format()](https://api.github.com/repos/json-c/json-c/issues/325)
-[why json-c so hard to compile](https://api.github.com/repos/json-c/json-c/issues/327)
-[json_object: implement json_object_deep_copy() function](https://api.github.com/repos/json-c/json-c/issues/328)
-[build,cmake: build,cmake: rename libjson-c-static.a to libjson-c.a](https://api.github.com/repos/json-c/json-c/issues/329)
-[tests: symlink basic tests to a single file that has the common code](https://api.github.com/repos/json-c/json-c/issues/330)
-[Safe use of snprintf() / vsnprintf() for Visual studio, and thread-safety fix](https://api.github.com/repos/json-c/json-c/issues/331)
-[Valgrind: invalid read after json_object_array_del_idx.](https://api.github.com/repos/json-c/json-c/issues/332)
-[Replace obsolete AM_PROG_LIBTOOL](https://api.github.com/repos/json-c/json-c/issues/333)
-[README.md: show build status tag from travis-ci.org](https://api.github.com/repos/json-c/json-c/issues/335)
-[tests: fix tests in travis-ci.org](https://api.github.com/repos/json-c/json-c/issues/336)
-[Synchronize "potentially racy" random seed in lh_char_hash()](https://api.github.com/repos/json-c/json-c/issues/337)
-[implement json_object_int_inc(json_object *, int64_t)](https://api.github.com/repos/json-c/json-c/issues/338)
-[Json schema validation](https://api.github.com/repos/json-c/json-c/issues/339)
-[strerror_override: add extern "C" and JSON_EXPORT specifiers for Visual C++ compilers](https://api.github.com/repos/json-c/json-c/issues/340)
-[character "/" parse as "\/"](https://api.github.com/repos/json-c/json-c/issues/341)
-[ No such file or directory "/usr/include/json.h"](https://api.github.com/repos/json-c/json-c/issues/342)
-[Can't parse json](https://api.github.com/repos/json-c/json-c/issues/343)
-[Fix Mingw build](https://api.github.com/repos/json-c/json-c/issues/344)
-[Fix make dist and make distcheck](https://api.github.com/repos/json-c/json-c/issues/345)
-[Clamp double to int32 when narrowing in json_object_get_int.](https://api.github.com/repos/json-c/json-c/issues/346)
-[MSVC linker error json_c_strerror](https://api.github.com/repos/json-c/json-c/issues/347)
-[why](https://api.github.com/repos/json-c/json-c/issues/348)
-[`missing` is missing?](https://api.github.com/repos/json-c/json-c/issues/349)
-[stderror-override and disable-shared](https://api.github.com/repos/json-c/json-c/issues/350)
-[SIZE_T_MAX redefined from limits.h](https://api.github.com/repos/json-c/json-c/issues/351)
-[`INSTALL` overrides an automake script.](https://api.github.com/repos/json-c/json-c/issues/352)
-[Documentation issues](https://api.github.com/repos/json-c/json-c/issues/353)
-[Fixes #351 #352 #353 ](https://api.github.com/repos/json-c/json-c/issues/354)
-[1.make it can been compiled with Visual Studio 2010 by modify the CMakeList.txt and others](https://api.github.com/repos/json-c/json-c/issues/355)
-[VS2008 test  test_util_file.cpp err!](https://api.github.com/repos/json-c/json-c/issues/356)
-[__json_c_strerror incompatibility with link-time optimization](https://api.github.com/repos/json-c/json-c/issues/357)
-[make issue](https://api.github.com/repos/json-c/json-c/issues/358)
-[update CMakeLists.txt for compile with visual studio at least 2010](https://api.github.com/repos/json-c/json-c/issues/359)
-[Use strtoll() to parse ints](https://api.github.com/repos/json-c/json-c/issues/360)
-[Fix double to int cast overflow in json_object_get_int64.](https://api.github.com/repos/json-c/json-c/issues/361)
-[CMake Package Config](https://api.github.com/repos/json-c/json-c/issues/362)
-[Issue #338, add json_object_add_int functions](https://api.github.com/repos/json-c/json-c/issues/363)
-[Cmake is Errir](https://api.github.com/repos/json-c/json-c/issues/364)
-[added fallthrough for gcc7](https://api.github.com/repos/json-c/json-c/issues/365)
-[how to check  the json string,crash!](https://api.github.com/repos/json-c/json-c/issues/366)
-[Is json-c support "redirect" semantic?](https://api.github.com/repos/json-c/json-c/issues/367)
-[Add examples](https://api.github.com/repos/json-c/json-c/issues/368)
-[How to build json-c library for android?](https://api.github.com/repos/json-c/json-c/issues/369)
-[Compiling using clang-cl](https://api.github.com/repos/json-c/json-c/issues/370)
-[Invalid parsing for Infinity with json-c 0.12](https://api.github.com/repos/json-c/json-c/issues/371)
-[Json-c 0.12: Fixed Infinity bug](https://api.github.com/repos/json-c/json-c/issues/372)
-[build: fix build on appveyor CI](https://api.github.com/repos/json-c/json-c/issues/373)
-[Undefined symbols for architecture x86_64:](https://api.github.com/repos/json-c/json-c/issues/374)
-[what would happened when json_object_object_add add the same key](https://api.github.com/repos/json-c/json-c/issues/375)
-[Eclipse error ](https://api.github.com/repos/json-c/json-c/issues/376)
-[on gcc 7.2.0 on my linux distribution with json-c  2013-04-02 source](https://api.github.com/repos/json-c/json-c/issues/377)
-[ Eclipse: library (libjson-c) not found, but configured](https://api.github.com/repos/json-c/json-c/issues/378)
-[error: this statement may fall through \[-Werror=implicit-fallthrough=\]](https://api.github.com/repos/json-c/json-c/issues/379)
-[Build on Windows](https://api.github.com/repos/json-c/json-c/issues/380)
-[Fix makedist](https://api.github.com/repos/json-c/json-c/issues/381)
-[Memory leak for json_tokener_parse_ex for version 0.12.1](https://api.github.com/repos/json-c/json-c/issues/382)
-[Fix a compiler warning.](https://api.github.com/repos/json-c/json-c/issues/383)
-[Fix a VS 2015 compiler warnings.](https://api.github.com/repos/json-c/json-c/issues/384)
 
+[Issue #61](https://github.com/json-c/json-c/issues/61) - Make json_object_object_add() indicate success or failure, test fix \
+[Issue #113](https://github.com/json-c/json-c/issues/113) - Build fixes (make dist and make distcheck) \
+[Issue #124](https://github.com/json-c/json-c/issues/124) - Fixing build \
+[Issue #125](https://github.com/json-c/json-c/issues/125) - Fix compile error(variable size set but not used) on g++4.6 \
+[Issue #126](https://github.com/json-c/json-c/issues/126) - Removed unused size variable. \
+[Issue #127](https://github.com/json-c/json-c/issues/127) - remove unused `size` variable \
+[Issue #128](https://github.com/json-c/json-c/issues/128) - Remove unused variable from json_tokenizer.c \
+[Issue #130](https://github.com/json-c/json-c/issues/130) - Failed to compile under Ubuntu 13.10 32bit \
+[Issue #131](https://github.com/json-c/json-c/issues/131) - undefined symbol: __sync_val_compare_and_swap_4 \
+[Issue #132](https://github.com/json-c/json-c/issues/132) - Remove unused variable 'size' \
+[Issue #133](https://github.com/json-c/json-c/issues/133) - Update and rename README to README.md \
+[Issue #134](https://github.com/json-c/json-c/issues/134) - Must remove variable size... \
+[Issue #135](https://github.com/json-c/json-c/issues/135) - bits.h uses removed json_tokener_errors\[error\] \
+[Issue #136](https://github.com/json-c/json-c/issues/136) - Error when running make check \
+[Issue #137](https://github.com/json-c/json-c/issues/137) - config.h.in should not be in git \
+[Issue #138](https://github.com/json-c/json-c/issues/138) - Can't build on RHEL 6.5 due to dependency on automake-1.14 \
+[Issue #140](https://github.com/json-c/json-c/issues/140) - Code bug in random_test.c evaluating same expression twice \
+[Issue #141](https://github.com/json-c/json-c/issues/141) - Removed duplicate check in random_seed test - bug #140 \
+[Issue #142](https://github.com/json-c/json-c/issues/142) - Please undeprecate json_object_object_get \
+[Issue #144](https://github.com/json-c/json-c/issues/144) - Introduce json_object_from_fd \
+[Issue #145](https://github.com/json-c/json-c/issues/145) - Handle % character properly \
+[Issue #146](https://github.com/json-c/json-c/issues/146) - TAGS rename \
+[Issue #148](https://github.com/json-c/json-c/issues/148) - Bump the soname \
+[Issue #149](https://github.com/json-c/json-c/issues/149) - SONAME bump \
+[Issue #150](https://github.com/json-c/json-c/issues/150) - Fix build using MinGW. \
+[Issue #151](https://github.com/json-c/json-c/issues/151) - Remove json_type enum trailing comma \
+[Issue #152](https://github.com/json-c/json-c/issues/152) - error while compiling json-c library version 0.11 \
+[Issue #153](https://github.com/json-c/json-c/issues/153) - improve doc for json_object_to_json_string() \
+[Issue #154](https://github.com/json-c/json-c/issues/154) - double precision \
+[Issue #155](https://github.com/json-c/json-c/issues/155) - add bsearch for arrays \
+[Issue #156](https://github.com/json-c/json-c/issues/156) - Remove trailing whitespaces \
+[Issue #157](https://github.com/json-c/json-c/issues/157) - JSON-C shall not exit on calloc fail. \
+[Issue #158](https://github.com/json-c/json-c/issues/158) - while using json-c 0.11, I am facing strange crash issue in json_object_put. \
+[Issue #159](https://github.com/json-c/json-c/issues/159) - json_tokener.c compile error \
+[Issue #160](https://github.com/json-c/json-c/issues/160) - missing header file on windows?? \
+[Issue #161](https://github.com/json-c/json-c/issues/161) - Is there a way to append to file? \
+[Issue #162](https://github.com/json-c/json-c/issues/162) - json_util: add directory check for POSIX distros \
+[Issue #163](https://github.com/json-c/json-c/issues/163) - Fix Win32 build problems \
+[Issue #164](https://github.com/json-c/json-c/issues/164) - made it compile and link on Widnows (as static library) \
+[Issue #165](https://github.com/json-c/json-c/issues/165) - json_object_to_json_string_ext length \
+[Issue #167](https://github.com/json-c/json-c/issues/167) - Can't build on Windows with Visual Studio 2010 \
+[Issue #168](https://github.com/json-c/json-c/issues/168) - Tightening the number parsing algorithm \
+[Issue #169](https://github.com/json-c/json-c/issues/169) - Doesn't compile on ubuntu 14.04, 64bit \
+[Issue #170](https://github.com/json-c/json-c/issues/170) - Generated files in repository \
+[Issue #171](https://github.com/json-c/json-c/issues/171) - Update configuration for VS2010 and win64 \
+[Issue #172](https://github.com/json-c/json-c/issues/172) - Adding support for parsing octal numbers \
+[Issue #173](https://github.com/json-c/json-c/issues/173) - json_parse_int64 doesn't work correctly at illumos \
+[Issue #174](https://github.com/json-c/json-c/issues/174) - Adding JSON_C_TO_STRING_PRETTY_TAB flag \
+[Issue #175](https://github.com/json-c/json-c/issues/175) - make check fails 4 tests with overflows when built with ASAN \
+[Issue #176](https://github.com/json-c/json-c/issues/176) - Possible to delete an array element at a given idx ? \
+[Issue #177](https://github.com/json-c/json-c/issues/177) - Fix compiler warnings \
+[Issue #178](https://github.com/json-c/json-c/issues/178) - Unable to compile on CentOS5 \
+[Issue #179](https://github.com/json-c/json-c/issues/179) - Added array_list_del_idx and json_object_array_del_idx \
+[Issue #180](https://github.com/json-c/json-c/issues/180) - Enable silent build by default \
+[Issue #181](https://github.com/json-c/json-c/issues/181) - json_tokener_parse_ex accepts invalid JSON \
+[Issue #182](https://github.com/json-c/json-c/issues/182) - Link against libm when needed \
+[Issue #183](https://github.com/json-c/json-c/issues/183) - Apply compile warning fix to master branch \
+[Issue #184](https://github.com/json-c/json-c/issues/184) - Use only GCC-specific flags when compiling with GCC \
+[Issue #185](https://github.com/json-c/json-c/issues/185) - compile error \
+[Issue #186](https://github.com/json-c/json-c/issues/186) - Syntax error \
+[Issue #187](https://github.com/json-c/json-c/issues/187) - array_list_get_idx and negative indexes. \
+[Issue #188](https://github.com/json-c/json-c/issues/188) - json_object_object_foreach warnings \
+[Issue #189](https://github.com/json-c/json-c/issues/189) - noisy json_object_from_file: error opening file \
+[Issue #190](https://github.com/json-c/json-c/issues/190) - warning: initialization discards const qualifier from pointer target type \[enabled by default\] \
+[Issue #192](https://github.com/json-c/json-c/issues/192) - json_tokener_parse  accepts invalid JSON {"key": "value" ,  } \
+[Issue #193](https://github.com/json-c/json-c/issues/193) - Make serialization format of doubles configurable \
+[Issue #194](https://github.com/json-c/json-c/issues/194) - Add utility function for comparing json_objects \
+[Issue #195](https://github.com/json-c/json-c/issues/195) - Call uselocale instead of setlocale \
+[Issue #196](https://github.com/json-c/json-c/issues/196) - Performance improvements \
+[Issue #197](https://github.com/json-c/json-c/issues/197) - Time for a new release? \
+[Issue #198](https://github.com/json-c/json-c/issues/198) - Fix possible memory leak and remove superfluous NULL checks before free() \
+[Issue #199](https://github.com/json-c/json-c/issues/199) - Fix build in Visual Studio \
+[Issue #200](https://github.com/json-c/json-c/issues/200) - Add build scripts for CI platforms \
+[Issue #201](https://github.com/json-c/json-c/issues/201) - disable forward-slash escaping? \
+[Issue #202](https://github.com/json-c/json-c/issues/202) - Array with objects support \
+[Issue #203](https://github.com/json-c/json-c/issues/203) - Add source position/coordinates to API \
+[Issue #204](https://github.com/json-c/json-c/issues/204) - json-c/json.h not found \
+[Issue #205](https://github.com/json-c/json-c/issues/205) - json-c Compiled with Visual Studios \
+[Issue #206](https://github.com/json-c/json-c/issues/206) - what do i use in place of json_object_object_get? \
+[Issue #207](https://github.com/json-c/json-c/issues/207) - Add support for property pairs directly added to arrays \
+[Issue #208](https://github.com/json-c/json-c/issues/208) - Performance enhancements (mainly) to json_object_to_json_string() \
+[Issue #209](https://github.com/json-c/json-c/issues/209) - fix regression from 2d549662be832da838aa063da2efa78ee3b99668 \
+[Issue #210](https://github.com/json-c/json-c/issues/210) - Use size_t for arrays \
+[Issue #211](https://github.com/json-c/json-c/issues/211) - Atomic updates for the refcount \
+[Issue #212](https://github.com/json-c/json-c/issues/212) - Refcount doesn't work between threads \
+[Issue #213](https://github.com/json-c/json-c/issues/213) - fix to compile with microsoft visual c++ 2010 \
+[Issue #214](https://github.com/json-c/json-c/issues/214) - Some non-GNU systems support __sync_val_compare_and_swap \
+[Issue #215](https://github.com/json-c/json-c/issues/215) - Build json-c for window 64 bit. \
+[Issue #216](https://github.com/json-c/json-c/issues/216) - configure: check realloc with AC_CHECK_FUNCS() to fix cross-compilation. \
+[Issue #217](https://github.com/json-c/json-c/issues/217) - Checking for functions in float.h \
+[Issue #218](https://github.com/json-c/json-c/issues/218) - Use a macro to indicate C99 to the compiler \
+[Issue #219](https://github.com/json-c/json-c/issues/219) - Fix various potential null ptr deref and int32 overflows \
+[Issue #220](https://github.com/json-c/json-c/issues/220) - Add utility function for comparing json_objects \
+[Issue #221](https://github.com/json-c/json-c/issues/221) - JSON_C_TO_STRING_NOSLASHESCAPE works incorrectly \
+[Issue #222](https://github.com/json-c/json-c/issues/222) - Fix issue #221: JSON_C_TO_STRING_NOSLASHESCAPE works incorrectly \
+[Issue #223](https://github.com/json-c/json-c/issues/223) - Clarify json_object_get_string documentation of NULL handling & return \
+[Issue #224](https://github.com/json-c/json-c/issues/224) - json_tokener.c - all warnings being treated as errors \
+[Issue #225](https://github.com/json-c/json-c/issues/225) - Hi, will you support clib as a "registry"? \
+[Issue #227](https://github.com/json-c/json-c/issues/227) - Bump SOVERSION to 3 \
+[Issue #228](https://github.com/json-c/json-c/issues/228) - avoid double slashes from json \
+[Issue #229](https://github.com/json-c/json-c/issues/229) - configure fails: checking size of size_t... configure: error: cannot determine a size for size_t \
+[Issue #230](https://github.com/json-c/json-c/issues/230) - Use stdint.h to check for size_t size \
+[Issue #231](https://github.com/json-c/json-c/issues/231) - Fix size_t size check for first-time builds \
+[Issue #232](https://github.com/json-c/json-c/issues/232) - tests/tests1: fix printf format for size_t arguments \
+[Issue #233](https://github.com/json-c/json-c/issues/233) - Include stddef.h in json_object.h \
+[Issue #234](https://github.com/json-c/json-c/issues/234) - Add public API to use userdata independently of custom serializer \
+[Issue #235](https://github.com/json-c/json-c/issues/235) - Undefined symbols Error for architecture x86_64 on Mac \
+[Issue #236](https://github.com/json-c/json-c/issues/236) - Building a project which uses json-c with flag -Wcast-qual causes compilation errors \
+[Issue #237](https://github.com/json-c/json-c/issues/237) - handle escaped utf-8 \
+[Issue #238](https://github.com/json-c/json-c/issues/238) - linkhash.c: optimised the table_free path \
+[Issue #239](https://github.com/json-c/json-c/issues/239) - initialize null terminator of new printbuf \
+[Issue #240](https://github.com/json-c/json-c/issues/240) - Compile error: Variable set but not used \
+[Issue #241](https://github.com/json-c/json-c/issues/241) - getting error in date string 19\/07\/2016, fixed for error 19/07/2016 \
+[Issue #242](https://github.com/json-c/json-c/issues/242) - json_tokener_parse error \
+[Issue #243](https://github.com/json-c/json-c/issues/243) - Fix #165 \
+[Issue #244](https://github.com/json-c/json-c/issues/244) - Error while compiling source from RHEL5, could you please help me to fix this \
+[Issue #245](https://github.com/json-c/json-c/issues/245) - json-c compile in window xp \
+[Issue #246](https://github.com/json-c/json-c/issues/246) - Mac: uselocale failed to build \
+[Issue #247](https://github.com/json-c/json-c/issues/247) - json_object_array_del_idx function has segment fault error? \
+[Issue #248](https://github.com/json-c/json-c/issues/248) - Minor changes in C source code \
+[Issue #249](https://github.com/json-c/json-c/issues/249) - Improving README \
+[Issue #250](https://github.com/json-c/json-c/issues/250) - Improving .gitignore \
+[Issue #251](https://github.com/json-c/json-c/issues/251) - Adding a file for EditorConfig \
+[Issue #252](https://github.com/json-c/json-c/issues/252) - Very minor changes not related to C source code \
+[Issue #253](https://github.com/json-c/json-c/issues/253) - Adding a test with cppcheck for Travis CI \
+[Issue #254](https://github.com/json-c/json-c/issues/254) - Very minor changes to some tests \
+[Issue #255](https://github.com/json-c/json-c/issues/255) - Minor changes in C source code \
+[Issue #256](https://github.com/json-c/json-c/issues/256) - Mailing list dead? \
+[Issue #257](https://github.com/json-c/json-c/issues/257) - Defining a coding style \
+[Issue #258](https://github.com/json-c/json-c/issues/258) - Enable CI services \
+[Issue #259](https://github.com/json-c/json-c/issues/259) - Fails to parse valid json \
+[Issue #260](https://github.com/json-c/json-c/issues/260) - Adding an object to itself \
+[Issue #261](https://github.com/json-c/json-c/issues/261) - Lack of proper documentation \
+[Issue #262](https://github.com/json-c/json-c/issues/262) - Add Cmakefile and fix compiler warning. \
+[Issue #263](https://github.com/json-c/json-c/issues/263) - Compiler Warnings with VS2015 \
+[Issue #264](https://github.com/json-c/json-c/issues/264) - successed in simple test   while failed in my project \
+[Issue #265](https://github.com/json-c/json-c/issues/265) - Conformance report for reference \
+[Issue #266](https://github.com/json-c/json-c/issues/266) - crash perhaps related to reference counting \
+[Issue #267](https://github.com/json-c/json-c/issues/267) - Removes me as Win32 maintainer, because I'm not. \
+[Issue #268](https://github.com/json-c/json-c/issues/268) - Documentation of json_object_to_json_string gives no information about memory management \
+[Issue #269](https://github.com/json-c/json-c/issues/269) - json_object_<type>_set(json_object *o,<type> value) API for value setting in json object private structure \
+[Issue #270](https://github.com/json-c/json-c/issues/270) - new API json_object_new_double_f(doubel d,const char * fmt); \
+[Issue #271](https://github.com/json-c/json-c/issues/271) - Cannot compile using CMake on macOS \
+[Issue #273](https://github.com/json-c/json-c/issues/273) - fixed wrong object name in json_object_all_values_equal \
+[Issue #274](https://github.com/json-c/json-c/issues/274) - Support for 64 bit pointers on Windows \
+[Issue #275](https://github.com/json-c/json-c/issues/275) - Out-of-bounds read in json_tokener_parse_ex \
+[Issue #276](https://github.com/json-c/json-c/issues/276) - ./configure for centos release 6.7(final) failure \
+[Issue #277](https://github.com/json-c/json-c/issues/277) - Json object set xxx \
+[Issue #278](https://github.com/json-c/json-c/issues/278) - Serialization of double with no fractional component drops trailing zero \
+[Issue #279](https://github.com/json-c/json-c/issues/279) - Segmentation fault in array_list_length() \
+[Issue #280](https://github.com/json-c/json-c/issues/280) - Should json_object_array_get_idx  check whether input obj is array? \
+[Issue #281](https://github.com/json-c/json-c/issues/281) - how to pretty print json-c? \
+[Issue #282](https://github.com/json-c/json-c/issues/282) - ignore temporary files \
+[Issue #283](https://github.com/json-c/json-c/issues/283) - json_pointer: add first revision based on RFC 6901 \
+[Issue #284](https://github.com/json-c/json-c/issues/284) - Resusing  json_tokener object \
+[Issue #285](https://github.com/json-c/json-c/issues/285) - Revert "compat/strdup.h: move common compat check for strdup() to own \
+[Issue #286](https://github.com/json-c/json-c/issues/286) - json_tokener_parse_ex() returns json_tokener_continue on zero-length string \
+[Issue #287](https://github.com/json-c/json-c/issues/287) - json_pointer: extend setter & getter with printf() style arguments \
+[Issue #288](https://github.com/json-c/json-c/issues/288) - Fix _GNU_SOURCE define for vasprintf \
+[Issue #289](https://github.com/json-c/json-c/issues/289) - bugfix: floating point representaion without fractional part \
+[Issue #290](https://github.com/json-c/json-c/issues/290) - duplicate an json_object \
+[Issue #291](https://github.com/json-c/json-c/issues/291) - isspace assert error \
+[Issue #292](https://github.com/json-c/json-c/issues/292) - configure error  "./configure: line 13121: syntax error near unexpected token `-Wall'" \
+[Issue #293](https://github.com/json-c/json-c/issues/293) - how to make with bitcode for ios \
+[Issue #294](https://github.com/json-c/json-c/issues/294) - Adding UTF-8 validation.  Fixes #122 \
+[Issue #295](https://github.com/json-c/json-c/issues/295) - cross compile w/ mingw \
+[Issue #296](https://github.com/json-c/json-c/issues/296) - Missing functions header in json_object.h \
+[Issue #297](https://github.com/json-c/json-c/issues/297) - could not parse string to Json object? Like string str=\"helloworld;E\\test\\log\\;end\" \
+[Issue #298](https://github.com/json-c/json-c/issues/298) - Building using CMake doesn't work \
+[Issue #299](https://github.com/json-c/json-c/issues/299) - Improve json_object -> string performance \
+[Issue #300](https://github.com/json-c/json-c/issues/300) - Running tests with MinGW build \
+[Issue #301](https://github.com/json-c/json-c/issues/301) - How to deep copy  json_object in C++ ? \
+[Issue #302](https://github.com/json-c/json-c/issues/302) - json_tokener_parse_ex doesn't parse JSON values \
+[Issue #303](https://github.com/json-c/json-c/issues/303) - fix doc in tokener header file \
+[Issue #304](https://github.com/json-c/json-c/issues/304) - (.text+0x72846): undefined reference to `is_error' \
+[Issue #305](https://github.com/json-c/json-c/issues/305) - Fix compilation without C-99 option \
+[Issue #306](https://github.com/json-c/json-c/issues/306) - ./configure: line 12748 -error=deprecated-declarations \
+[Issue #307](https://github.com/json-c/json-c/issues/307) - Memory leak in json_tokener_parse \
+[Issue #308](https://github.com/json-c/json-c/issues/308) - AM_PROG_LIBTOOL not found on Linux \
+[Issue #309](https://github.com/json-c/json-c/issues/309) - GCC 7 reports various -Wimplicit-fallthrough= errors \
+[Issue #310](https://github.com/json-c/json-c/issues/310) - Add FALLTHRU comment to handle GCC7 warnings. \
+[Issue #311](https://github.com/json-c/json-c/issues/311) - Fix error C3688 when compiling on Visual Studio 2015 \
+[Issue #312](https://github.com/json-c/json-c/issues/312) - Fix CMake Build process improved for MinGW and MSYS2 \
+[Issue #313](https://github.com/json-c/json-c/issues/313) - VERBOSE=1 make check; tests/test_util_file.test.c and tests/test_util_file.expected out of sync \
+[Issue #315](https://github.com/json-c/json-c/issues/315) - Passing -1 to json_tokener_parse_ex is possibly unsafe \
+[Issue #316](https://github.com/json-c/json-c/issues/316) - Memory Returned by json_object_to_json_string not freed \
+[Issue #317](https://github.com/json-c/json-c/issues/317) - json_object_get_string gives segmentation error \
+[Issue #318](https://github.com/json-c/json-c/issues/318) - PVS-Studio static analyzer analyze results \
+[Issue #319](https://github.com/json-c/json-c/issues/319) - Windows: Fix dynamic library build with Visual Studio \
+[Issue #320](https://github.com/json-c/json-c/issues/320) - Can't compile in Mac OS X El Capitan \
+[Issue #321](https://github.com/json-c/json-c/issues/321) - build,cmake: fix vasprintf implicit definition and generate both static & shared libs \
+[Issue #322](https://github.com/json-c/json-c/issues/322) - can not link with libjson-c.a \
+[Issue #323](https://github.com/json-c/json-c/issues/323) - implicit fallthrough detected by gcc 7.1 \
+[Issue #324](https://github.com/json-c/json-c/issues/324) - JsonPath like function? \
+[Issue #325](https://github.com/json-c/json-c/issues/325) - Fix stack buffer overflow in json_object_double_to_json_string_format() \
+[Issue #327](https://github.com/json-c/json-c/issues/327) - why json-c so hard to compile \
+[Issue #328](https://github.com/json-c/json-c/issues/328) - json_object: implement json_object_deep_copy() function \
+[Issue #329](https://github.com/json-c/json-c/issues/329) - build,cmake: build,cmake: rename libjson-c-static.a to libjson-c.a \
+[Issue #330](https://github.com/json-c/json-c/issues/330) - tests: symlink basic tests to a single file that has the common code \
+[Issue #331](https://github.com/json-c/json-c/issues/331) - Safe use of snprintf() / vsnprintf() for Visual studio, and thread-safety fix \
+[Issue #332](https://github.com/json-c/json-c/issues/332) - Valgrind: invalid read after json_object_array_del_idx. \
+[Issue #333](https://github.com/json-c/json-c/issues/333) - Replace obsolete AM_PROG_LIBTOOL \
+[Issue #335](https://github.com/json-c/json-c/issues/335) - README.md: show build status tag from travis-ci.org \
+[Issue #336](https://github.com/json-c/json-c/issues/336) - tests: fix tests in travis-ci.org \
+[Issue #337](https://github.com/json-c/json-c/issues/337) - Synchronize "potentially racy" random seed in lh_char_hash() \
+[Issue #338](https://github.com/json-c/json-c/issues/338) - implement json_object_int_inc(json_object *, int64_t) \
+[Issue #339](https://github.com/json-c/json-c/issues/339) - Json schema validation \
+[Issue #340](https://github.com/json-c/json-c/issues/340) - strerror_override: add extern "C" and JSON_EXPORT specifiers for Visual C++ compilers \
+[Issue #341](https://github.com/json-c/json-c/issues/341) - character "/" parse as "\/" \
+[Issue #342](https://github.com/json-c/json-c/issues/342) - No such file or directory "/usr/include/json.h" \
+[Issue #343](https://github.com/json-c/json-c/issues/343) - Can't parse json \
+[Issue #344](https://github.com/json-c/json-c/issues/344) - Fix Mingw build \
+[Issue #345](https://github.com/json-c/json-c/issues/345) - Fix make dist and make distcheck \
+[Issue #346](https://github.com/json-c/json-c/issues/346) - Clamp double to int32 when narrowing in json_object_get_int. \
+[Issue #347](https://github.com/json-c/json-c/issues/347) - MSVC linker error json_c_strerror \
+[Issue #348](https://github.com/json-c/json-c/issues/348) - why \
+[Issue #349](https://github.com/json-c/json-c/issues/349) - `missing` is missing? \
+[Issue #350](https://github.com/json-c/json-c/issues/350) - stderror-override and disable-shared \
+[Issue #351](https://github.com/json-c/json-c/issues/351) - SIZE_T_MAX redefined from limits.h \
+[Issue #352](https://github.com/json-c/json-c/issues/352) - `INSTALL` overrides an automake script. \
+[Issue #353](https://github.com/json-c/json-c/issues/353) - Documentation issues \
+[Issue #354](https://github.com/json-c/json-c/issues/354) - Fixes #351 #352 #353 \
+[Issue #355](https://github.com/json-c/json-c/issues/355) - 1.make it can been compiled with Visual Studio 2010 by modify the CMakeList.txt and others \
+[Issue #356](https://github.com/json-c/json-c/issues/356) - VS2008 test  test_util_file.cpp err! \
+[Issue #357](https://github.com/json-c/json-c/issues/357) - __json_c_strerror incompatibility with link-time optimization \
+[Issue #358](https://github.com/json-c/json-c/issues/358) - make issue \
+[Issue #359](https://github.com/json-c/json-c/issues/359) - update CMakeLists.txt for compile with visual studio at least 2010 \
+[Issue #360](https://github.com/json-c/json-c/issues/360) - Use strtoll() to parse ints \
+[Issue #361](https://github.com/json-c/json-c/issues/361) - Fix double to int cast overflow in json_object_get_int64. \
+[Issue #362](https://github.com/json-c/json-c/issues/362) - CMake Package Config \
+[Issue #363](https://github.com/json-c/json-c/issues/363) - Issue #338, add json_object_add_int functions \
+[Issue #364](https://github.com/json-c/json-c/issues/364) - Cmake is Errir \
+[Issue #365](https://github.com/json-c/json-c/issues/365) - added fallthrough for gcc7 \
+[Issue #366](https://github.com/json-c/json-c/issues/366) - how to check  the json string,crash! \
+[Issue #367](https://github.com/json-c/json-c/issues/367) - Is json-c support "redirect" semantic? \
+[Issue #368](https://github.com/json-c/json-c/issues/368) - Add examples \
+[Issue #369](https://github.com/json-c/json-c/issues/369) - How to build json-c library for android? \
+[Issue #370](https://github.com/json-c/json-c/issues/370) - Compiling using clang-cl \
+[Issue #371](https://github.com/json-c/json-c/issues/371) - Invalid parsing for Infinity with json-c 0.12 \
+[Issue #372](https://github.com/json-c/json-c/issues/372) - Json-c 0.12: Fixed Infinity bug \
+[Issue #373](https://github.com/json-c/json-c/issues/373) - build: fix build on appveyor CI \
+[Issue #374](https://github.com/json-c/json-c/issues/374) - Undefined symbols for architecture x86_64: \
+[Issue #375](https://github.com/json-c/json-c/issues/375) - what would happened when json_object_object_add add the same key \
+[Issue #376](https://github.com/json-c/json-c/issues/376) - Eclipse error \
+[Issue #377](https://github.com/json-c/json-c/issues/377) - on gcc 7.2.0 on my linux distribution with json-c  2013-04-02 source \
+[Issue #378](https://github.com/json-c/json-c/issues/378) - Eclipse: library (libjson-c) not found, but configured \
+[Issue #379](https://github.com/json-c/json-c/issues/379) - error: this statement may fall through \[-Werror=implicit-fallthrough=\] \
+[Issue #380](https://github.com/json-c/json-c/issues/380) - Build on Windows \
+[Issue #381](https://github.com/json-c/json-c/issues/381) - Fix makedist \
+[Issue #382](https://github.com/json-c/json-c/issues/382) - Memory leak for json_tokener_parse_ex for version 0.12.1 \
+[Issue #383](https://github.com/json-c/json-c/issues/383) - Fix a compiler warning. \
+[Issue #384](https://github.com/json-c/json-c/issues/384) - Fix a VS 2015 compiler warnings. \

issues_closed_for_0.14.md

@@ -0,0 +1,202 @@
+This list was created with:
+
+```
+curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2017-12-07+created%3A<2020-04-17&sort=created&order=asc&per_page=400&page=1" > issues1.out
+curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2017-12-07+created%3A<2020-04-17&sort=created&order=asc&per_page=400&page=2" > issues2.out
+curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2017-12-07+created%3A<2020-04-17&sort=created&order=asc&per_page=400&page=3" > issues3.out
+jq -r '.items[] | "[" + .title + "](" + .url + ")" | tostring' issues?.out > issues.md
+sed -e's,^\[ *\(.*\)\](https://api.github.com/.*/\([0-9].*\)),[Issue #\2](https://github.com/json-c/json-c/issues/\2) - \1,' -i issues.md
+#... manual editing ...
+```
+
+----
+
+Issues and Pull Requests closed for the 0.14 release (since commit d582d3a(2017-12-07) to a911439(2020-04-17))
+
+
+[Issue #122](https://github.com/json-c/json-c/issues/122) - Add utf-8 validation when parsing strings. \
+[Issue #139](https://github.com/json-c/json-c/issues/139) - json_object_from_file cannot accept max_depth \
+[Issue #143](https://github.com/json-c/json-c/issues/143) - RFE / enhancement for full 64-bit signed/unsigned support \
+[Issue #147](https://github.com/json-c/json-c/issues/147) - Please introduce soname bump if API changed \
+[Issue #166](https://github.com/json-c/json-c/issues/166) - Need a way to specify nesting depth when opening JSON file \
+[Issue #226](https://github.com/json-c/json-c/issues/226) - There is no json_object_new_null() \
+[Issue #314](https://github.com/json-c/json-c/issues/314) - new release ? \
+[Issue #326](https://github.com/json-c/json-c/issues/326) - Please extend api json_object_get_uint64 \
+[Issue #334](https://github.com/json-c/json-c/issues/334) - Switch json-c builds to use CMake \
+[Issue #386](https://github.com/json-c/json-c/issues/386) - Makefile: Add ACLOCAL_AMFLAGS \
+[Issue #387](https://github.com/json-c/json-c/issues/387) - doc: Use other doxygen feature to specify mainpage \
+[Issue #388](https://github.com/json-c/json-c/issues/388) - json_object: Add size_t json_object_sizeof() \
+[Issue #389](https://github.com/json-c/json-c/issues/389) - json_object: Avoid double free (and thus a segfault) when ref_count gets < 0 \
+[Issue #390](https://github.com/json-c/json-c/issues/390) - json_object: Add const size_t json_c_object_sizeof() \
+[Issue #391](https://github.com/json-c/json-c/issues/391) - Fix non-GNUC define for JSON_C_CONST_FUNCTION \
+[Issue #392](https://github.com/json-c/json-c/issues/392) - json_object: Avoid invalid free (and thus a segfault) when ref_count gets < 0 \
+[Issue #393](https://github.com/json-c/json-c/issues/393) - json_object_private: Use unsigned 32-bit integer type for refcount \
+[Issue #394](https://github.com/json-c/json-c/issues/394) - Problem serializing double \
+[Issue #395](https://github.com/json-c/json-c/issues/395) - Key gets modified if it contains "\" \
+[Issue #396](https://github.com/json-c/json-c/issues/396) - Build failure with no threads uClibc toolchain \
+[Issue #397](https://github.com/json-c/json-c/issues/397) - update json object with key. \
+[Issue #398](https://github.com/json-c/json-c/issues/398) - Build failed. \
+[Issue #399](https://github.com/json-c/json-c/issues/399) - Avoid uninitialized variable warnings \
+[Issue #400](https://github.com/json-c/json-c/issues/400) - How to generate static lib (.a) \
+[Issue #401](https://github.com/json-c/json-c/issues/401) - Warnings with Valgrind \
+[Issue #402](https://github.com/json-c/json-c/issues/402) - Add fuzzers from OSS-Fuzz \
+[Issue #403](https://github.com/json-c/json-c/issues/403) - Segmentation fault when double quotes is used \
+[Issue #404](https://github.com/json-c/json-c/issues/404) - valgrind: memory leak \
+[Issue #405](https://github.com/json-c/json-c/issues/405) - Missing API to determine an object is empty \
+[Issue #406](https://github.com/json-c/json-c/issues/406) - Undefine NDEBUG for tests \
+[Issue #407](https://github.com/json-c/json-c/issues/407) - json_tokener_parse is crash \
+[Issue #408](https://github.com/json-c/json-c/issues/408) - bug in array_list_del_idx when array_list_length()==1 \
+[Issue #410](https://github.com/json-c/json-c/issues/410) - Fixed typos \
+[Issue #411](https://github.com/json-c/json-c/issues/411) - Crash- signal SIGSEGV, Segmentation fault. ../sysdeps/x86_64/strlen.S: No such file or directory. \
+[Issue #412](https://github.com/json-c/json-c/issues/412) - json_type changes during inter process communication. \
+[Issue #413](https://github.com/json-c/json-c/issues/413) - how to read object of type `json_object *` in c++ \
+[Issue #414](https://github.com/json-c/json-c/issues/414) - [Question] How JSON-c stores the serialized data in memory? \
+[Issue #415](https://github.com/json-c/json-c/issues/415) - Resolve windows name conflict \
+[Issue #416](https://github.com/json-c/json-c/issues/416) - segmentation fault  in json_tokener_parse \
+[Issue #417](https://github.com/json-c/json-c/issues/417) - json_tokener_parse  json_object_object_get_ex with string value which is json string \
+[Issue #418](https://github.com/json-c/json-c/issues/418) - json_object_from_* return value documented incorrectly \
+[Issue #419](https://github.com/json-c/json-c/issues/419) - Suggestion: document (and define) that json_object_put() accepts NULL pointer to object \
+[Issue #420](https://github.com/json-c/json-c/issues/420) - arraylist: Fixed names of parameters for callback function \
+[Issue #421](https://github.com/json-c/json-c/issues/421) - install json_object_iterator.h header file \
+[Issue #422](https://github.com/json-c/json-c/issues/422) - json_object_get_double() does not set errno when there is no valid conversion \
+[Issue #423](https://github.com/json-c/json-c/issues/423) - memory leak \
+[Issue #424](https://github.com/json-c/json-c/issues/424) - Parse string contains "\" or "/" errors \
+[Issue #425](https://github.com/json-c/json-c/issues/425) - what this is? \
+[Issue #426](https://github.com/json-c/json-c/issues/426) - __deprecated not supported on clang. \
+[Issue #427](https://github.com/json-c/json-c/issues/427) - CMake: builds involving this target will not be correct \
+[Issue #430](https://github.com/json-c/json-c/issues/430) - json_object_object_del() and Segmentation fault \
+[Issue #431](https://github.com/json-c/json-c/issues/431) - cmake: Bump required version \
+[Issue #432](https://github.com/json-c/json-c/issues/432) - The real CMake support. \
+[Issue #433](https://github.com/json-c/json-c/issues/433) - The real CMake support. \
+[Issue #434](https://github.com/json-c/json-c/issues/434) - The real CMake support \
+[Issue #435](https://github.com/json-c/json-c/issues/435) - json_object_object_del() segmentation fault \
+[Issue #436](https://github.com/json-c/json-c/issues/436) - Improve pkgconfig setting \
+[Issue #437](https://github.com/json-c/json-c/issues/437) - Bad link in README.md \
+[Issue #438](https://github.com/json-c/json-c/issues/438) - Bad link in README.html \
+[Issue #439](https://github.com/json-c/json-c/issues/439) - reserved identifier violation \
+[Issue #440](https://github.com/json-c/json-c/issues/440) - Use of angle brackets around file names for include statements \
+[Issue #441](https://github.com/json-c/json-c/issues/441) - fix c flag loss during cmake building \
+[Issue #442](https://github.com/json-c/json-c/issues/442) - error  in configure file \
+[Issue #443](https://github.com/json-c/json-c/issues/443) - remove pretty spaces when using pretty tabs \
+[Issue #444](https://github.com/json-c/json-c/issues/444) - Document refcount of json_tokener_parse_ex return \
+[Issue #445](https://github.com/json-c/json-c/issues/445) - Add missing "make check" target to cmake config \
+[Issue #446](https://github.com/json-c/json-c/issues/446) - Forward slashes get escaped \
+[Issue #448](https://github.com/json-c/json-c/issues/448) - Buffer overflow in json-c \
+[Issue #449](https://github.com/json-c/json-c/issues/449) - Need of json_type_int64 returned by json_object_get_type() \
+[Issue #450](https://github.com/json-c/json-c/issues/450) - Allow use json-c cmake as subproject \
+[Issue #452](https://github.com/json-c/json-c/issues/452) - Update README.md \
+[Issue #453](https://github.com/json-c/json-c/issues/453) - Fixed misalignment in JSON string due to space after \n being printed... \
+[Issue #454](https://github.com/json-c/json-c/issues/454) - json_object_private: save 8 bytes in struct json_object in 64-bit arc… \
+[Issue #455](https://github.com/json-c/json-c/issues/455) - index.html:fix dead link \
+[Issue #456](https://github.com/json-c/json-c/issues/456) - STYLE.txt:remove executable permissions \
+[Issue #457](https://github.com/json-c/json-c/issues/457) - .gitignore:add build directory \
+[Issue #458](https://github.com/json-c/json-c/issues/458) - README.md:fix dead "file.html" link \
+[Issue #459](https://github.com/json-c/json-c/issues/459) - README.html:fix link to Doxygen docs, remove WIN32 link \
+[Issue #460](https://github.com/json-c/json-c/issues/460) - No docs for json_object_new_string_len() \
+[Issue #461](https://github.com/json-c/json-c/issues/461) - json_object.c:set errno in json_object_get_double() \
+[Issue #462](https://github.com/json-c/json-c/issues/462) - json_object.h:document json_object_new_string_len() \
+[Issue #463](https://github.com/json-c/json-c/issues/463) - please check newlocale api first argument valuse. \
+[Issue #465](https://github.com/json-c/json-c/issues/465) - CMakeLists.txt doesn't contain json_object_iterator.h which json.h includes \
+[Issue #466](https://github.com/json-c/json-c/issues/466) - configure:3610: error: C compiler cannot create executables \
+[Issue #467](https://github.com/json-c/json-c/issues/467) - Fix compiler warnings \
+[Issue #468](https://github.com/json-c/json-c/issues/468) - Fix compiler warnings \
+[Issue #469](https://github.com/json-c/json-c/issues/469) - Build under alpine with pecl install & docker-php-ext-enable? \
+[Issue #470](https://github.com/json-c/json-c/issues/470) - cfuhash_foreach_remove doesn't upate cfuhash_num_entries \
+[Issue #472](https://github.com/json-c/json-c/issues/472) - Segmentation fault in json_object_iter_begin \
+[Issue #473](https://github.com/json-c/json-c/issues/473) - Convert ChangeLog to valid UTF-8 encoding. \
+[Issue #474](https://github.com/json-c/json-c/issues/474) - Installation directories empty with CMake in pkg-config. \
+[Issue #475](https://github.com/json-c/json-c/issues/475) - improvement proposal for json_object_object_foreach \
+[Issue #477](https://github.com/json-c/json-c/issues/477) - Hang/Crash with large strings \
+[Issue #478](https://github.com/json-c/json-c/issues/478) - json_object_get_string_len returns 0 when value is number \
+[Issue #479](https://github.com/json-c/json-c/issues/479) - I want to use it in iOS or Android but I can't compile \
+[Issue #480](https://github.com/json-c/json-c/issues/480) - json-c-0.12.1  failed making from source code \
+[Issue #481](https://github.com/json-c/json-c/issues/481) - error while loading shared libraries: libjson-c.so.4 \
+[Issue #482](https://github.com/json-c/json-c/issues/482) - Error "double free or corruption" after free() \
+[Issue #483](https://github.com/json-c/json-c/issues/483) - compatible with rarely-used Chinese characters in GBK charset \
+[Issue #485](https://github.com/json-c/json-c/issues/485) - Install CMake module files \
+[Issue #486](https://github.com/json-c/json-c/issues/486) - In the case of negative double value, it is formatted without including ".0" \
+[Issue #488](https://github.com/json-c/json-c/issues/488) - Some APIs are not exported when built as shared lib on Win32 \
+[Issue #489](https://github.com/json-c/json-c/issues/489) - Don't use -Werror by default \
+[Issue #490](https://github.com/json-c/json-c/issues/490) - do not compile with -Werror by default \
+[Issue #491](https://github.com/json-c/json-c/issues/491) - build: add option --disable-werror to configure \
+[Issue #492](https://github.com/json-c/json-c/issues/492) - lack some quick usage in readme \
+[Issue #494](https://github.com/json-c/json-c/issues/494) - Code generator? \
+[Issue #495](https://github.com/json-c/json-c/issues/495) - README.md:fix 2 typos \
+[Issue #496](https://github.com/json-c/json-c/issues/496) - json_pointer.h:suggest minor grammar improvement for pointer doc \
+[Issue #497](https://github.com/json-c/json-c/issues/497) - add common header for all tests \
+[Issue #498](https://github.com/json-c/json-c/issues/498) - double_serializer_test fails (with valgrind) \
+[Issue #499](https://github.com/json-c/json-c/issues/499) - .travis.yml:test on more recent clang and gcc versions \
+[Issue #500](https://github.com/json-c/json-c/issues/500) - test/Makefile.am:add missing deps for test1 and test2 \
+[Issue #501](https://github.com/json-c/json-c/issues/501) - undefine NDEBUG for tests \
+[Issue #502](https://github.com/json-c/json-c/issues/502) - configure error \
+[Issue #503](https://github.com/json-c/json-c/issues/503) - json-c retuns OK when Invalid json string is passed \
+[Issue #504](https://github.com/json-c/json-c/issues/504) - json_object_put coredump \
+[Issue #505](https://github.com/json-c/json-c/issues/505) - Add vcpkg installation instructions \
+[Issue #506](https://github.com/json-c/json-c/issues/506) - Cannot parse more than one object \
+[Issue #509](https://github.com/json-c/json-c/issues/509) - Sometimes a double value is not serialized \
+[Issue #510](https://github.com/json-c/json-c/issues/510) - Bump so-name and improve CMake \
+[Issue #511](https://github.com/json-c/json-c/issues/511) - Reduce lines for better optimization \
+[Issue #512](https://github.com/json-c/json-c/issues/512) - Properly append to CMAKE_C_FLAGS string \
+[Issue #513](https://github.com/json-c/json-c/issues/513) - What does `userdata` means?And what is the case we can use it? \
+[Issue #514](https://github.com/json-c/json-c/issues/514) - Json c 0.13 \
+[Issue #515](https://github.com/json-c/json-c/issues/515) - Mies suomesta fixes segfaults and logic errors \
+[Issue #516](https://github.com/json-c/json-c/issues/516) - Lja slight mods \
+[Issue #518](https://github.com/json-c/json-c/issues/518) - Escape character  "\\003\", get unexpected value \
+[Issue #519](https://github.com/json-c/json-c/issues/519) - Add test case obj token \
+[Issue #520](https://github.com/json-c/json-c/issues/520) - Adding type uint64 \
+[Issue #521](https://github.com/json-c/json-c/issues/521) - build cmake windows 10 \
+[Issue #522](https://github.com/json-c/json-c/issues/522) - update json_visit testcase \
+[Issue #523](https://github.com/json-c/json-c/issues/523) - update tsetcase for tokener_c \
+[Issue #524](https://github.com/json-c/json-c/issues/524) - Increase coverage \
+[Issue #525](https://github.com/json-c/json-c/issues/525) - update pointer test case \
+[Issue #526](https://github.com/json-c/json-c/issues/526) - Increased the test coverage of printbuf.c 82% to 92%. \
+[Issue #527](https://github.com/json-c/json-c/issues/527) - Arraylist testcase \
+[Issue #528](https://github.com/json-c/json-c/issues/528) - Solve issue #108. Skip \u0000 while parsing. \
+[Issue #529](https://github.com/json-c/json-c/issues/529) - Increased the test coverage of json_c_version.c 0% to 100%. \
+[Issue #530](https://github.com/json-c/json-c/issues/530) - validate utf-8 string before parse \
+[Issue #531](https://github.com/json-c/json-c/issues/531) - validate utf-8 string \
+[Issue #532](https://github.com/json-c/json-c/issues/532) - json_object_object_get_ex returning the original object \
+[Issue #533](https://github.com/json-c/json-c/issues/533) - Fix "make check" \
+[Issue #535](https://github.com/json-c/json-c/issues/535) - short string optimization: excessive array length \
+[Issue #536](https://github.com/json-c/json-c/issues/536) - add json_object_new_null() \
+[Issue #538](https://github.com/json-c/json-c/issues/538) - update shortstring and arraylist parameters \
+[Issue #539](https://github.com/json-c/json-c/issues/539) - double serializes to the old value after set_double \
+[Issue #541](https://github.com/json-c/json-c/issues/541) - add coveralls auto tool to json-c \
+[Issue #542](https://github.com/json-c/json-c/issues/542) - add uint64 data to json-c \
+[Issue #543](https://github.com/json-c/json-c/issues/543) - Readme \
+[Issue #544](https://github.com/json-c/json-c/issues/544) - Increase distcheck target in cmake \
+[Issue #545](https://github.com/json-c/json-c/issues/545) - add doc target in cmake \
+[Issue #546](https://github.com/json-c/json-c/issues/546) - Add uninstall target in cmake \
+[Issue #547](https://github.com/json-c/json-c/issues/547) - modify json-c default build type, and fix up the assert() errors in t… \
+[Issue #548](https://github.com/json-c/json-c/issues/548) - Solve some problems about cmake build type (debug/release) \
+[Issue #549](https://github.com/json-c/json-c/issues/549) - lib installation issues \
+[Issue #550](https://github.com/json-c/json-c/issues/550) - Format codes with clang-format tool? \
+[Issue #551](https://github.com/json-c/json-c/issues/551) - Allow hexadecimal number format convention parsing \
+[Issue #553](https://github.com/json-c/json-c/issues/553) - Fix/clang ubsan \
+[Issue #554](https://github.com/json-c/json-c/issues/554) - RFC 8259 compatibility mode \
+[Issue #555](https://github.com/json-c/json-c/issues/555) - Format json-c with clang-format tool \
+[Issue #556](https://github.com/json-c/json-c/issues/556) - Fixes various Wreturn-type and Wimplicit-fallthrough errors on Mingw-w64 \
+[Issue #557](https://github.com/json-c/json-c/issues/557) - Add option in CMAKE to not build documentation \
+[Issue #558](https://github.com/json-c/json-c/issues/558) - modify the doc target message \
+[Issue #559](https://github.com/json-c/json-c/issues/559) - json_c_visit() not exported on Windows \
+[Issue #560](https://github.com/json-c/json-c/issues/560) - error: implicit declaration of function '_strtoi64' \
+[Issue #561](https://github.com/json-c/json-c/issues/561) - add the badge in README.md and test the coveralls \
+[Issue #562](https://github.com/json-c/json-c/issues/562) - Bugfix and testcases supplements \
+[Issue #563](https://github.com/json-c/json-c/issues/563) - Changed order of calloc args to match stdlib \
+[Issue #564](https://github.com/json-c/json-c/issues/564) - Remove autogenerated files \
+[Issue #565](https://github.com/json-c/json-c/issues/565) - test the CI and ignore this PR \
+[Issue #566](https://github.com/json-c/json-c/issues/566) - add the json_types.h to Makefile.am \
+[Issue #567](https://github.com/json-c/json-c/issues/567) - Install json_types.h with autotools build as well. \
+[Issue #568](https://github.com/json-c/json-c/issues/568) - Adding better support to MinGW \
+[Issue #569](https://github.com/json-c/json-c/issues/569) - Handling of -Bsymbolic-function in CMakeLists.txt is deficient \
+[Issue #571](https://github.com/json-c/json-c/issues/571) - CMake: Bump SONAME to 5. \
+[Issue #572](https://github.com/json-c/json-c/issues/572) - Small fixes to CMakeLists \
+[Issue #573](https://github.com/json-c/json-c/issues/573) - Fix coveralls submission. \
+[Issue #574](https://github.com/json-c/json-c/issues/574) - autogen.sh missing from repository \
+[Issue #575](https://github.com/json-c/json-c/issues/575) - Small cosmetics. \
+[Issue #576](https://github.com/json-c/json-c/issues/576) - Test coverage for json_c_version. \
+[Issue #577](https://github.com/json-c/json-c/issues/577) - Be verbose on failing json_c_version test. \
+[Issue #578](https://github.com/json-c/json-c/issues/578) - CMake: Install pkgconfig file in proper location by default \
+[Issue #579](https://github.com/json-c/json-c/issues/579) - Enforce strict prototypes. \
+[Issue #580](https://github.com/json-c/json-c/issues/580) - Fix CMake tests for enforced strict prototypes. \
+[Issue #581](https://github.com/json-c/json-c/issues/581) - CMakeLists: do not enforce strict prototypes on Windows. \

json-c-uninstalled.pc.in

@@ -1,11 +0,0 @@
-prefix=
-exec_prefix=
-libdir=@abs_top_builddir@
-includedir=@abs_top_srcdir@
-
-Name: json
-Description: JSON implementation in C
-Version: @VERSION@
-Requires:
-Libs:  -L@abs_top_builddir@ -ljson-c
-Cflags: -I@abs_top_srcdir@

json-c.pc.in

@@ -9,4 +9,4 @@ Version: @VERSION@
 Requires:
 Libs.private: @LIBS@
 Libs: -L${libdir} -ljson-c
-Cflags: -I${includedir}/json-c
+Cflags: -I${includedir} -I${includedir}/json-c

json.h

@@ -21,15 +21,15 @@
 extern "C" {
 #endif
 
-#include "debug.h"
-#include "linkhash.h"
 #include "arraylist.h"
-#include "json_util.h"
+#include "debug.h"
+#include "json_c_version.h"
 #include "json_object.h"
+#include "json_object_iterator.h"
 #include "json_pointer.h"
 #include "json_tokener.h"
-#include "json_object_iterator.h"
-#include "json_c_version.h"
+#include "json_util.h"
+#include "linkhash.h"
 
 #ifdef __cplusplus
 }

json_c_version.c

@@ -17,4 +17,3 @@ int json_c_version_num(void)
 {
 	return JSON_C_VERSION_NUM;
 }
-

json_c_version.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012 Eric Haszlakiewicz
+ * Copyright (c) 2012,2017 Eric Haszlakiewicz
  *
  * This library is free software; you can redistribute it and/or modify
  * it under the terms of the MIT license. See COPYING for details.
@@ -12,19 +12,30 @@
 #ifndef _json_c_version_h_
 #define _json_c_version_h_
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #define JSON_C_MAJOR_VERSION 0
-#define JSON_C_MINOR_VERSION 12
+#define JSON_C_MINOR_VERSION 14
 #define JSON_C_MICRO_VERSION 99
-#define JSON_C_VERSION_NUM ((JSON_C_MAJOR_VERSION << 16) | \
-                            (JSON_C_MINOR_VERSION << 8) | \
-                            JSON_C_MICRO_VERSION)
-#define JSON_C_VERSION "0.12.99"
+#define JSON_C_VERSION_NUM \
+	((JSON_C_MAJOR_VERSION << 16) | (JSON_C_MINOR_VERSION << 8) | JSON_C_MICRO_VERSION)
+#define JSON_C_VERSION "0.14.99"
+
+#ifndef JSON_EXPORT
+#if defined(_MSC_VER)
+#define JSON_EXPORT __declspec(dllexport)
+#else
+#define JSON_EXPORT extern
+#endif
+#endif
 
 /**
  * @see JSON_C_VERSION
  * @return the version of the json-c library as a string
  */
-const char *json_c_version(void); /* Returns JSON_C_VERSION */
+JSON_EXPORT const char *json_c_version(void); /* Returns JSON_C_VERSION */
 
 /**
  * The json-c version encoded into an int, with the low order 8 bits
@@ -35,6 +46,10 @@ const char *json_c_version(void); /* Returns JSON_C_VERSION */
  * @see JSON_C_VERSION_NUM
  * @return the version of the json-c library as an int
  */
-int json_c_version_num(void);     /* Returns JSON_C_VERSION_NUM */
+JSON_EXPORT int json_c_version_num(void); /* Returns JSON_C_VERSION_NUM */
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif

json_inttypes.h

@@ -17,6 +17,7 @@
 
 #define PRId64 "I64d"
 #define SCNd64 "I64d"
+#define PRIu64 "I64u"
 
 #endif
 

json_object.h

@@ -18,7 +18,7 @@
 #define _json_object_h_
 
 #ifdef __GNUC__
-#define THIS_FUNCTION_IS_DEPRECATED(func) func __attribute__ ((deprecated))
+#define THIS_FUNCTION_IS_DEPRECATED(func) func __attribute__((deprecated))
 #elif defined(_MSC_VER)
 #define THIS_FUNCTION_IS_DEPRECATED(func) __declspec(deprecated) func
 #elif defined(__clang__)
@@ -27,16 +27,18 @@
 #define THIS_FUNCTION_IS_DEPRECATED(func) func
 #endif
 
-#if defined(_MSC_VER) 
-#define JSON_EXPORT __declspec(dllexport)
+#ifdef __GNUC__
+#define JSON_C_CONST_FUNCTION(func) func __attribute__((const))
 #else
-#define JSON_EXPORT extern
+#define JSON_C_CONST_FUNCTION(func) func
 #endif
 
-#include <stddef.h>
 #include "json_inttypes.h"
+#include "json_types.h"
 #include "printbuf.h"
 
+#include <stddef.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -48,13 +50,13 @@ extern "C" {
  * json_object_to_file_ext() functions which causes the output
  * to have no extra whitespace or formatting applied.
  */
-#define JSON_C_TO_STRING_PLAIN      0
+#define JSON_C_TO_STRING_PLAIN 0
 /**
  * A flag for the json_object_to_json_string_ext() and
  * json_object_to_file_ext() functions which causes the output to have
  * minimal whitespace inserted to make things slightly more readable.
  */
-#define JSON_C_TO_STRING_SPACED     (1<<0)
+#define JSON_C_TO_STRING_SPACED (1 << 0)
 /**
  * A flag for the json_object_to_json_string_ext() and
  * json_object_to_file_ext() functions which causes
@@ -63,7 +65,7 @@ extern "C" {
  * See the "Two Space Tab" option at http://jsonformatter.curiousconcept.com/
  * for an example of the format.
  */
-#define JSON_C_TO_STRING_PRETTY     (1<<1)
+#define JSON_C_TO_STRING_PRETTY (1 << 1)
 /**
  * A flag for the json_object_to_json_string_ext() and
  * json_object_to_file_ext() functions which causes
@@ -71,28 +73,28 @@ extern "C" {
  *
  * Instead of a "Two Space Tab" this gives a single tab character.
  */
-#define JSON_C_TO_STRING_PRETTY_TAB (1<<3)
+#define JSON_C_TO_STRING_PRETTY_TAB (1 << 3)
 /**
  * A flag to drop trailing zero for float values
  */
-#define JSON_C_TO_STRING_NOZERO     (1<<2)
+#define JSON_C_TO_STRING_NOZERO (1 << 2)
 
 /**
  * Don't escape forward slashes.
  */
-#define JSON_C_TO_STRING_NOSLASHESCAPE (1<<4)
+#define JSON_C_TO_STRING_NOSLASHESCAPE (1 << 4)
 
 /**
  * A flag for the json_object_object_add_ex function which
  * causes the value to be added without a check if it already exists.
- * Note: it is the responsibilty of the caller to ensure that no
+ * Note: it is the responsibility of the caller to ensure that no
  * key is added multiple times. If this is done, results are
  * unpredictable. While this option is somewhat dangerous, it
  * permits potentially large performance savings in code that
  * knows for sure the key values are unique (e.g. because the
  * code adds a well-known set of constant key values).
  */
-#define JSON_C_OBJECT_ADD_KEY_IS_NEW (1<<1)
+#define JSON_C_OBJECT_ADD_KEY_IS_NEW (1 << 1)
 /**
  * A flag for the json_object_object_add_ex function which
  * flags the key as being constant memory. This means that
@@ -110,13 +112,7 @@ extern "C" {
  *   json_object_object_add_ex(obj, "ip", json,
  *       JSON_C_OBJECT_KEY_IS_CONSTANT);
  */
-#define JSON_C_OBJECT_KEY_IS_CONSTANT (1<<2)
-
-#undef FALSE
-#define FALSE ((json_bool)0)
-
-#undef TRUE
-#define TRUE ((json_bool)1)
+#define JSON_C_OBJECT_KEY_IS_CONSTANT (1 << 2)
 
 /**
  * Set the global value of an option, which will apply to all
@@ -134,51 +130,6 @@ extern "C" {
  */
 #define JSON_C_OPTION_THREAD (1)
 
-/**
- * A structure to use with json_object_object_foreachC() loops.
- * Contains key, val and entry members.
- */
-struct json_object_iter
-{
-	char *key;
-	struct json_object *val;
-	struct lh_entry *entry;
-};
-typedef struct json_object_iter json_object_iter;
-
-typedef int json_bool;
-
-/**
- * @brief The core type for all type of JSON objects handled by json-c
- */
-typedef struct json_object json_object;
-
-/**
- * Type of custom user delete functions.  See json_object_set_serializer.
- */
-typedef void (json_object_delete_fn)(struct json_object *jso, void *userdata);
-
-/**
- * Type of a custom serialization function.  See json_object_set_serializer.
- */
-typedef int (json_object_to_json_string_fn)(struct json_object *jso,
-						struct printbuf *pb,
-						int level,
-						int flags);
-
-/* supported object types */
-
-typedef enum json_type {
-  /* If you change this, be sure to update json_type_to_name() too */
-  json_type_null,
-  json_type_boolean,
-  json_type_double,
-  json_type_int,
-  json_type_object,
-  json_type_array,
-  json_type_string
-} json_type;
-
 /* reference counting functions */
 
 /**
@@ -187,12 +138,13 @@ typedef enum json_type {
  *
  * @param obj the json_object instance
  */
-JSON_EXPORT struct json_object* json_object_get(struct json_object *obj);
+JSON_EXPORT struct json_object *json_object_get(struct json_object *obj);
 
 /**
  * Decrement the reference count of json_object and free if it reaches zero.
  * You must have ownership of obj prior to doing this or you will cause an
  * imbalance in the reference count.
+ * An obj of NULL may be passed; in that case this call is a no-op.
  *
  * @param obj the json_object instance
  * @returns 1 if the object was freed.
@@ -229,7 +181,6 @@ JSON_EXPORT int json_object_is_type(const struct json_object *obj, enum json_typ
  */
 JSON_EXPORT enum json_type json_object_get_type(const struct json_object *obj);
 
-
 /** Stringify object to json format.
  * Equivalent to json_object_to_json_string_ext(obj, JSON_C_TO_STRING_SPACED)
  * The pointer you get is an internal of your json object. You don't
@@ -239,7 +190,7 @@ JSON_EXPORT enum json_type json_object_get_type(const struct json_object *obj);
  * @param obj the json_object instance
  * @returns a string in JSON format
  */
-JSON_EXPORT const char* json_object_to_json_string(struct json_object *obj);
+JSON_EXPORT const char *json_object_to_json_string(struct json_object *obj);
 
 /** Stringify object to json format
  * @see json_object_to_json_string() for details on how to free string.
@@ -247,8 +198,7 @@ JSON_EXPORT const char* json_object_to_json_string(struct json_object *obj);
  * @param flags formatting options, see JSON_C_TO_STRING_PRETTY and other constants
  * @returns a string in JSON format
  */
-JSON_EXPORT const char* json_object_to_json_string_ext(struct json_object *obj, int
-flags);
+JSON_EXPORT const char *json_object_to_json_string_ext(struct json_object *obj, int flags);
 
 /** Stringify object to json format
  * @see json_object_to_json_string() for details on how to free string.
@@ -257,8 +207,8 @@ flags);
  * @param length a pointer where, if not NULL, the length (without null) is stored
  * @returns a string in JSON format and the length if not NULL
  */
-JSON_EXPORT const char* json_object_to_json_string_length(struct json_object *obj, int
-flags, size_t *length);
+JSON_EXPORT const char *json_object_to_json_string_length(struct json_object *obj, int flags,
+                                                          size_t *length);
 
 /**
  * Returns the userdata set by json_object_set_userdata() or
@@ -266,7 +216,7 @@ flags, size_t *length);
  *
  * @param jso the object to return the userdata for
  */
-JSON_EXPORT void* json_object_get_userdata(json_object *jso);
+JSON_EXPORT void *json_object_get_userdata(json_object *jso);
 
 /**
  * Set an opaque userdata value for an object
@@ -294,7 +244,7 @@ JSON_EXPORT void* json_object_get_userdata(json_object *jso);
  * @param user_delete an optional function from freeing userdata
  */
 JSON_EXPORT void json_object_set_userdata(json_object *jso, void *userdata,
-				     json_object_delete_fn *user_delete);
+                                          json_object_delete_fn *user_delete);
 
 /**
  * Set a custom serialization function to be used when this particular object
@@ -327,9 +277,8 @@ JSON_EXPORT void json_object_set_userdata(json_object *jso, void *userdata,
  * @param user_delete an optional function from freeing userdata
  */
 JSON_EXPORT void json_object_set_serializer(json_object *jso,
-	json_object_to_json_string_fn *to_string_func,
-	void *userdata,
-	json_object_delete_fn *user_delete);
+                                            json_object_to_json_string_fn *to_string_func,
+                                            void *userdata, json_object_delete_fn *user_delete);
 
 #ifdef __clang__
 /*
@@ -348,7 +297,7 @@ JSON_EXPORT void json_object_set_serializer(json_object *jso,
  * @param jso unused
  * @param userdata the pointer that is passed to free().
  */
-json_object_delete_fn json_object_free_userdata;
+JSON_EXPORT json_object_delete_fn json_object_free_userdata;
 
 /**
  * Copy the jso->_userdata string over to pb as-is.
@@ -359,14 +308,13 @@ json_object_delete_fn json_object_free_userdata;
  * @param level Ignored.
  * @param flags Ignored.
  */
-json_object_to_json_string_fn json_object_userdata_to_json_string;
+JSON_EXPORT json_object_to_json_string_fn json_object_userdata_to_json_string;
 
 #ifdef __clang__
 /* } */
 #pragma clang diagnostic pop
 #endif
 
-
 /* object type methods */
 
 /** Create a new empty object with a reference count of 1.  The caller of
@@ -379,18 +327,23 @@ json_object_to_json_string_fn json_object_userdata_to_json_string;
  *
  * @returns a json_object of type json_type_object
  */
-JSON_EXPORT struct json_object* json_object_new_object(void);
+JSON_EXPORT struct json_object *json_object_new_object(void);
 
 /** Get the hashtable of a json_object of type json_type_object
  * @param obj the json_object instance
  * @returns a linkhash
  */
-JSON_EXPORT struct lh_table* json_object_get_object(const struct json_object *obj);
+JSON_EXPORT struct lh_table *json_object_get_object(const struct json_object *obj);
 
 /** Get the size of an object in terms of the number of fields it has.
  * @param obj the json_object whose length to return
  */
-JSON_EXPORT int json_object_object_length(const struct json_object* obj);
+JSON_EXPORT int json_object_object_length(const struct json_object *obj);
+
+/** Get the sizeof (struct json_object).
+ * @returns a size_t with the sizeof (struct json_object)
+ */
+JSON_C_CONST_FUNCTION(JSON_EXPORT size_t json_c_object_sizeof(void));
 
 /** Add an object field to a json_object of type json_type_object
  *
@@ -411,8 +364,8 @@ JSON_EXPORT int json_object_object_length(const struct json_object* obj);
  * @return On success, <code>0</code> is returned.
  * 	On error, a negative value is returned.
  */
-JSON_EXPORT int json_object_object_add(struct json_object* obj, const char *key,
-				   struct json_object *val);
+JSON_EXPORT int json_object_object_add(struct json_object *obj, const char *key,
+                                       struct json_object *val);
 
 /** Add an object field to a json_object of type json_type_object
  *
@@ -424,20 +377,18 @@ JSON_EXPORT int json_object_object_add(struct json_object* obj, const char *key,
  * @param obj the json_object instance
  * @param key the object field name (a private copy will be duplicated)
  * @param val a json_object or NULL member to associate with the given field
- * @param opts process-modifying options. To specify multiple options, use 
+ * @param opts process-modifying options. To specify multiple options, use
  *             arithmetic or (OPT1|OPT2)
  */
-JSON_EXPORT int json_object_object_add_ex(struct json_object* obj,
-				const char *const key,
-				struct json_object *const val,
-				const unsigned opts);
+JSON_EXPORT int json_object_object_add_ex(struct json_object *obj, const char *const key,
+                                          struct json_object *const val, const unsigned opts);
 
 /** Get the json_object associate with a given object field.
  * Deprecated/discouraged: used json_object_object_get_ex instead.
  *
  * This returns NULL if the field is found but its value is null, or if
  *  the field is not found, or if obj is not a json_type_object.  If you
- *  need to distinguis between these cases, use json_object_object_get_ex().
+ *  need to distinguish between these cases, use json_object_object_get_ex().
  *
  * *No* reference counts will be changed.  There is no need to manually adjust
  * reference counts through the json_object_put/json_object_get methods unless
@@ -453,8 +404,8 @@ JSON_EXPORT int json_object_object_add_ex(struct json_object* obj,
  * @param key the object field name
  * @returns the json_object associated with the given field name
  */
-JSON_EXPORT struct json_object* json_object_object_get(const struct json_object* obj,
-						  const char *key);
+JSON_EXPORT struct json_object *json_object_object_get(const struct json_object *obj,
+                                                       const char *key);
 
 /** Get the json_object associated with a given object field.
  *
@@ -474,9 +425,8 @@ JSON_EXPORT struct json_object* json_object_object_get(const struct json_object*
  *              It is safe to pass a NULL value.
  * @returns whether or not the key exists
  */
-JSON_EXPORT json_bool json_object_object_get_ex(const struct json_object* obj,
-                                           const char *key,
-                                           struct json_object **value);
+JSON_EXPORT json_bool json_object_object_get_ex(const struct json_object *obj, const char *key,
+                                                struct json_object **value);
 
 /** Delete the given json_object field
  *
@@ -487,7 +437,7 @@ JSON_EXPORT json_bool json_object_object_get_ex(const struct json_object* obj,
  * @param obj the json_object instance
  * @param key the object field name
  */
-JSON_EXPORT void json_object_object_del(struct json_object* obj, const char *key);
+JSON_EXPORT void json_object_object_del(struct json_object *obj, const char *key);
 
 /**
  * Iterate through all keys and values of an object.
@@ -504,31 +454,35 @@ JSON_EXPORT void json_object_object_del(struct json_object* obj, const char *key
  */
 #if defined(__GNUC__) && !defined(__STRICT_ANSI__) && __STDC_VERSION__ >= 199901L
 
-# define json_object_object_foreach(obj,key,val) \
-	char *key = NULL; \
-	struct json_object *val __attribute__((__unused__)) = NULL; \
-	for(struct lh_entry *entry ## key = json_object_get_object(obj)->head, *entry_next ## key = NULL; \
-		({ if(entry ## key) { \
-			key = (char*)lh_entry_k(entry ## key); \
-			val = (struct json_object*)lh_entry_v(entry ## key); \
-			entry_next ## key = entry ## key->next; \
-		} ; entry ## key; }); \
-		entry ## key = entry_next ## key )
+#define json_object_object_foreach(obj, key, val)                                \
+	char *key = NULL;                                                        \
+	struct json_object *val __attribute__((__unused__)) = NULL;              \
+	for (struct lh_entry *entry##key = json_object_get_object(obj)->head,    \
+	                     *entry_next##key = NULL;                            \
+	     ({                                                                  \
+		     if (entry##key)                                             \
+		     {                                                           \
+			     key = (char *)lh_entry_k(entry##key);               \
+			     val = (struct json_object *)lh_entry_v(entry##key); \
+			     entry_next##key = entry##key->next;                 \
+		     };                                                          \
+		     entry##key;                                                 \
+	     });                                                                 \
+	     entry##key = entry_next##key)
 
 #else /* ANSI C or MSC */
 
-# define json_object_object_foreach(obj,key,val) \
-	char *key;\
-	struct json_object *val; \
-	struct lh_entry *entry ## key; \
-	struct lh_entry *entry_next ## key = NULL; \
-	for(entry ## key = json_object_get_object(obj)->head; \
-		(entry ## key ? ( \
-			key = (char*)lh_entry_k(entry ## key), \
-			val = (struct json_object*)lh_entry_v(entry ## key), \
-			entry_next ## key = entry ## key->next, \
-			entry ## key) : 0); \
-		entry ## key = entry_next ## key)
+#define json_object_object_foreach(obj, key, val)                              \
+	char *key = NULL;                                                      \
+	struct json_object *val = NULL;                                        \
+	struct lh_entry *entry##key;                                           \
+	struct lh_entry *entry_next##key = NULL;                               \
+	for (entry##key = json_object_get_object(obj)->head;                   \
+	     (entry##key ? (key = (char *)lh_entry_k(entry##key),              \
+	                   val = (struct json_object *)lh_entry_v(entry##key), \
+	                   entry_next##key = entry##key->next, entry##key)     \
+	                 : 0);                                                 \
+	     entry##key = entry_next##key)
 
 #endif /* defined(__GNUC__) && !defined(__STRICT_ANSI__) && __STDC_VERSION__ >= 199901L */
 
@@ -536,23 +490,25 @@ JSON_EXPORT void json_object_object_del(struct json_object* obj, const char *key
  * @param obj the json_object instance
  * @param iter the object iterator, use type json_object_iter
  */
-#define json_object_object_foreachC(obj,iter) \
- for(iter.entry = json_object_get_object(obj)->head; \
-     (iter.entry ? (iter.key = (char*)lh_entry_k(iter.entry), iter.val = (struct json_object*)lh_entry_v(iter.entry), iter.entry) : 0); \
-     iter.entry = iter.entry->next)
+#define json_object_object_foreachC(obj, iter)                                                  \
+	for (iter.entry = json_object_get_object(obj)->head;                                    \
+	     (iter.entry ? (iter.key = (char *)lh_entry_k(iter.entry),                          \
+	                   iter.val = (struct json_object *)lh_entry_v(iter.entry), iter.entry) \
+	                 : 0);                                                                  \
+	     iter.entry = iter.entry->next)
 
 /* Array type methods */
 
 /** Create a new empty json_object of type json_type_array
  * @returns a json_object of type json_type_array
  */
-JSON_EXPORT struct json_object* json_object_new_array(void);
+JSON_EXPORT struct json_object *json_object_new_array(void);
 
 /** Get the arraylist of a json_object of type json_type_array
  * @param obj the json_object instance
  * @returns an arraylist
  */
-JSON_EXPORT struct array_list* json_object_get_array(const struct json_object *obj);
+JSON_EXPORT struct array_list *json_object_get_array(const struct json_object *obj);
 
 /** Get the length of a json_object of type json_type_array
  * @param obj the json_object instance
@@ -568,7 +524,8 @@ JSON_EXPORT size_t json_object_array_length(const struct json_object *obj);
 * @param jso the json_object instance
 * @param sort_fn a sorting function
 */
-JSON_EXPORT void json_object_array_sort(struct json_object *jso, int(*sort_fn)(const void *, const void *));
+JSON_EXPORT void json_object_array_sort(struct json_object *jso,
+                                        int (*sort_fn)(const void *, const void *));
 
 /** Binary search a sorted array for a specified key object.
  *
@@ -584,10 +541,9 @@ JSON_EXPORT void json_object_array_sort(struct json_object *jso, int(*sort_fn)(c
  *
  * @return the wanted json_object instance
  */
-JSON_EXPORT struct json_object* json_object_array_bsearch(
-		const struct json_object *key,
-		const struct json_object *jso,
-		int (*sort_fn)(const void *, const void *));
+JSON_EXPORT struct json_object *
+json_object_array_bsearch(const struct json_object *key, const struct json_object *jso,
+                          int (*sort_fn)(const void *, const void *));
 
 /** Add an element to the end of a json_object of type json_type_array
  *
@@ -598,8 +554,7 @@ JSON_EXPORT struct json_object* json_object_array_bsearch(
  * @param obj the json_object instance
  * @param val the json_object to be added
  */
-JSON_EXPORT int json_object_array_add(struct json_object *obj,
-				 struct json_object *val);
+JSON_EXPORT int json_object_array_add(struct json_object *obj, struct json_object *val);
 
 /** Insert or replace an element at a specified index in an array (a json_object of type json_type_array)
  *
@@ -617,20 +572,20 @@ JSON_EXPORT int json_object_array_add(struct json_object *obj,
  * @param val the json_object to be added
  */
 JSON_EXPORT int json_object_array_put_idx(struct json_object *obj, size_t idx,
-				     struct json_object *val);
+                                          struct json_object *val);
 
-/** Get the element at specificed index of the array (a json_object of type json_type_array)
+/** Get the element at specified index of the array (a json_object of type json_type_array)
  * @param obj the json_object instance
  * @param idx the index to get the element at
  * @returns the json_object at the specified index (or NULL)
  */
-JSON_EXPORT struct json_object* json_object_array_get_idx(const struct json_object *obj,
-						     size_t idx);
+JSON_EXPORT struct json_object *json_object_array_get_idx(const struct json_object *obj,
+                                                          size_t idx);
 
 /** Delete an elements from a specified index in an array (a json_object of type json_type_array)
  *
  * The reference count will be decremented for each of the deleted objects.  If there
- * are no more owners of an element that is being deleted, then the value is 
+ * are no more owners of an element that is being deleted, then the value is
  * freed.  Otherwise, the reference to the value will remain in memory.
  *
  * @param obj the json_object instance
@@ -643,37 +598,35 @@ JSON_EXPORT int json_object_array_del_idx(struct json_object *obj, size_t idx, s
 /* json_bool type methods */
 
 /** Create a new empty json_object of type json_type_boolean
- * @param b a json_bool TRUE or FALSE (1 or 0)
+ * @param b a json_bool 1 or 0
  * @returns a json_object of type json_type_boolean
  */
-JSON_EXPORT struct json_object* json_object_new_boolean(json_bool b);
+JSON_EXPORT struct json_object *json_object_new_boolean(json_bool b);
 
 /** Get the json_bool value of a json_object
  *
  * The type is coerced to a json_bool if the passed object is not a json_bool.
- * integer and double objects will return FALSE if there value is zero
- * or TRUE otherwise. If the passed object is a string it will return
- * TRUE if it has a non zero length. If any other object type is passed
- * TRUE will be returned if the object is not NULL.
+ * integer and double objects will return 0 if there value is zero
+ * or 1 otherwise. If the passed object is a string it will return
+ * 1 if it has a non zero length. If any other object type is passed
+ * 1 will be returned if the object is not NULL.
  *
  * @param obj the json_object instance
  * @returns a json_bool
  */
 JSON_EXPORT json_bool json_object_get_boolean(const struct json_object *obj);
 
-
 /** Set the json_bool value of a json_object
- * 
- * The type of obj is checked to be a json_type_boolean and 0 is returned 
+ *
+ * The type of obj is checked to be a json_type_boolean and 0 is returned
  * if it is not without any further actions. If type of obj is json_type_boolean
- * the obect value is chaned to new_value
+ * the object value is changed to new_value
  *
  * @param obj the json_object instance
  * @param new_value the value to be set
  * @returns 1 if value is set correctly, 0 otherwise
  */
-JSON_EXPORT int json_object_set_boolean(struct json_object *obj,json_bool new_value);
-
+JSON_EXPORT int json_object_set_boolean(struct json_object *obj, json_bool new_value);
 
 /* int type methods */
 
@@ -683,15 +636,19 @@ JSON_EXPORT int json_object_set_boolean(struct json_object *obj,json_bool new_va
  * @param i the integer
  * @returns a json_object of type json_type_int
  */
-JSON_EXPORT struct json_object* json_object_new_int(int32_t i);
-
+JSON_EXPORT struct json_object *json_object_new_int(int32_t i);
 
 /** Create a new empty json_object of type json_type_int
  * @param i the integer
  * @returns a json_object of type json_type_int
  */
-JSON_EXPORT struct json_object* json_object_new_int64(int64_t i);
+JSON_EXPORT struct json_object *json_object_new_int64(int64_t i);
 
+/** Create a new empty json_object of type json_type_uint
+ * @param i the integer
+ * @returns a json_object of type json_type_uint
+ */
+JSON_EXPORT struct json_object *json_object_new_uint64(uint64_t i);
 
 /** Get the int value of a json_object
  *
@@ -710,16 +667,16 @@ JSON_EXPORT struct json_object* json_object_new_int64(int64_t i);
 JSON_EXPORT int32_t json_object_get_int(const struct json_object *obj);
 
 /** Set the int value of a json_object
- * 
- * The type of obj is checked to be a json_type_int and 0 is returned 
+ *
+ * The type of obj is checked to be a json_type_int and 0 is returned
  * if it is not without any further actions. If type of obj is json_type_int
- * the obect value is changed to new_value
+ * the object value is changed to new_value
  *
  * @param obj the json_object instance
  * @param new_value the value to be set
  * @returns 1 if value is set correctly, 0 otherwise
  */
-JSON_EXPORT int json_object_set_int(struct json_object *obj,int new_value);
+JSON_EXPORT int json_object_set_int(struct json_object *obj, int new_value);
 
 /** Increment a json_type_int object by the given amount, which may be negative.
  *
@@ -737,7 +694,6 @@ JSON_EXPORT int json_object_set_int(struct json_object *obj,int new_value);
  */
 JSON_EXPORT int json_object_int_inc(struct json_object *obj, int64_t val);
 
-
 /** Get the int value of a json_object
  *
  * The type is coerced to a int64 if the passed object is not a int64.
@@ -753,18 +709,44 @@ JSON_EXPORT int json_object_int_inc(struct json_object *obj, int64_t val);
  */
 JSON_EXPORT int64_t json_object_get_int64(const struct json_object *obj);
 
+/** Get the uint value of a json_object
+ *
+ * The type is coerced to a uint64 if the passed object is not a uint64.
+ * double objects will return their uint64 conversion. Strings will be
+ * parsed as an uint64. If no conversion exists then 0 is returned.
+ *
+ * NOTE: Set errno to 0 directly before a call to this function to determine
+ * whether or not conversion was successful (it does not clear the value for
+ * you).
+ *
+ * @param obj the json_object instance
+ * @returns an uint64
+ */
+JSON_EXPORT uint64_t json_object_get_uint64(const struct json_object *obj);
 
 /** Set the int64_t value of a json_object
- * 
- * The type of obj is checked to be a json_type_int and 0 is returned 
+ *
+ * The type of obj is checked to be a json_type_int and 0 is returned
  * if it is not without any further actions. If type of obj is json_type_int
- * the obect value is chaned to new_value
+ * the object value is changed to new_value
  *
  * @param obj the json_object instance
  * @param new_value the value to be set
  * @returns 1 if value is set correctly, 0 otherwise
  */
-JSON_EXPORT int json_object_set_int64(struct json_object *obj,int64_t new_value);
+JSON_EXPORT int json_object_set_int64(struct json_object *obj, int64_t new_value);
+
+/** Set the uint64_t value of a json_object
+ *
+ * The type of obj is checked to be a json_type_uint and 0 is returned
+ * if it is not without any further actions. If type of obj is json_type_uint
+ * the object value is changed to new_value
+ *
+ * @param obj the json_object instance
+ * @param new_value the value to be set
+ * @returns 1 if value is set correctly, 0 otherwise
+ */
+JSON_EXPORT int json_object_set_uint64(struct json_object *obj, uint64_t new_value);
 
 /* double type methods */
 
@@ -775,7 +757,7 @@ JSON_EXPORT int json_object_set_int64(struct json_object *obj,int64_t new_value)
  * @param d the double
  * @returns a json_object of type json_type_double
  */
-JSON_EXPORT struct json_object* json_object_new_double(double d);
+JSON_EXPORT struct json_object *json_object_new_double(double d);
 
 /**
  * Create a new json_object of type json_type_double, using
@@ -793,7 +775,8 @@ JSON_EXPORT struct json_object* json_object_new_double(double d);
  * The userdata field is used to store the string representation, so it
  * can't be used for other data if this function is used.
  *
- * An equivalent sequence of calls is:
+ * A roughly equivalent sequence of calls, with the difference being that
+ *  the serialization function won't be reset by json_object_set_double(), is:
  * @code
  *   jso = json_object_new_double(d);
  *   json_object_set_serializer(jso, json_object_userdata_to_json_string,
@@ -803,7 +786,7 @@ JSON_EXPORT struct json_object* json_object_new_double(double d);
  * @param d the numeric value of the double.
  * @param ds the string representation of the double.  This will be copied.
  */
-JSON_EXPORT struct json_object* json_object_new_double_s(double d, const char *ds);
+JSON_EXPORT struct json_object *json_object_new_double_s(double d, const char *ds);
 
 /**
  * Set a global or thread-local json-c option, depending on whether
@@ -817,9 +800,8 @@ JSON_EXPORT struct json_object* json_object_new_double_s(double d, const char *d
  *
  * @return -1 on errors, 0 on success.
  */
-int json_c_set_serialization_double_format(const char *double_format, int global_or_thread);
-
-
+JSON_EXPORT int json_c_set_serialization_double_format(const char *double_format,
+                                                       int global_or_thread);
 
 /** Serialize a json_object of type json_type_double to a string.
  *
@@ -840,10 +822,8 @@ int json_c_set_serialization_double_format(const char *double_format, int global
  * @param level Ignored.
  * @param flags Ignored.
  */
-JSON_EXPORT int json_object_double_to_json_string(struct json_object* jso,
-					     struct printbuf *pb,
-					     int level,
-					     int flags);
+JSON_EXPORT int json_object_double_to_json_string(struct json_object *jso, struct printbuf *pb,
+                                                  int level, int flags);
 
 /** Get the double floating point value of a json_object
  *
@@ -870,20 +850,20 @@ JSON_EXPORT int json_object_double_to_json_string(struct json_object* jso,
  */
 JSON_EXPORT double json_object_get_double(const struct json_object *obj);
 
-
 /** Set the double value of a json_object
- * 
- * The type of obj is checked to be a json_type_double and 0 is returned 
+ *
+ * The type of obj is checked to be a json_type_double and 0 is returned
  * if it is not without any further actions. If type of obj is json_type_double
- * the obect value is chaned to new_value
+ * the object value is changed to new_value
+ *
+ * If the object was created with json_object_new_double_s(), the serialization
+ * function is reset to the default and the cached serialized value is cleared.
  *
  * @param obj the json_object instance
  * @param new_value the value to be set
  * @returns 1 if value is set correctly, 0 otherwise
  */
-JSON_EXPORT int json_object_set_double(struct json_object *obj,double new_value);
-
-
+JSON_EXPORT int json_object_set_double(struct json_object *obj, double new_value);
 
 /* string type methods */
 
@@ -893,10 +873,21 @@ JSON_EXPORT int json_object_set_double(struct json_object *obj,double new_value)
  *
  * @param s the string
  * @returns a json_object of type json_type_string
+ * @see json_object_new_string_len()
  */
-JSON_EXPORT struct json_object* json_object_new_string(const char *s);
+JSON_EXPORT struct json_object *json_object_new_string(const char *s);
 
-JSON_EXPORT struct json_object* json_object_new_string_len(const char *s, int len);
+/** Create a new empty json_object of type json_type_string and allocate
+ * len characters for the new string.
+ *
+ * A copy of the string is made and the memory is managed by the json_object
+ *
+ * @param s the string
+ * @param len max length of the new string
+ * @returns a json_object of type json_type_string
+ * @see json_object_new_string()
+ */
+JSON_EXPORT struct json_object *json_object_new_string_len(const char *s, const int len);
 
 /** Get the string value of a json_object
  *
@@ -914,7 +905,7 @@ JSON_EXPORT struct json_object* json_object_new_string_len(const char *s, int le
  * @param obj the json_object instance
  * @returns a string or NULL
  */
-JSON_EXPORT const char* json_object_get_string(struct json_object *obj);
+JSON_EXPORT const char *json_object_get_string(struct json_object *obj);
 
 /** Get the string length of a json_object
  *
@@ -926,25 +917,30 @@ JSON_EXPORT const char* json_object_get_string(struct json_object *obj);
  */
 JSON_EXPORT int json_object_get_string_len(const struct json_object *obj);
 
-
 /** Set the string value of a json_object with zero terminated strings
  * equivalent to json_object_set_string_len (obj, new_value, strlen(new_value))
  * @returns 1 if value is set correctly, 0 otherwise
  */
-JSON_EXPORT int json_object_set_string(json_object* obj, const char* new_value);
+JSON_EXPORT int json_object_set_string(json_object *obj, const char *new_value);
 
 /** Set the string value of a json_object str
- * 
- * The type of obj is checked to be a json_type_string and 0 is returned 
+ *
+ * The type of obj is checked to be a json_type_string and 0 is returned
  * if it is not without any further actions. If type of obj is json_type_string
- * the obect value is chaned to new_value
+ * the object value is changed to new_value
  *
  * @param obj the json_object instance
- * @param new_value the value to be set; Since string legth is given in len this need not be zero terminated
+ * @param new_value the value to be set; Since string length is given in len this need not be zero terminated
  * @param len the length of new_value
  * @returns 1 if value is set correctly, 0 otherwise
  */
-JSON_EXPORT int json_object_set_string_len(json_object* obj, const char* new_value, int len);
+JSON_EXPORT int json_object_set_string_len(json_object *obj, const char *new_value, int len);
+
+/** This method exists only to provide a complementary function
+ * along the lines of the other json_object_new_* functions.
+ * It always returns NULL, and it is entirely acceptable to simply use NULL directly.
+ */
+JSON_EXPORT struct json_object *json_object_new_null(void);
 
 /** Check if two json_object's are equal
  *
@@ -963,8 +959,7 @@ JSON_EXPORT int json_object_set_string_len(json_object* obj, const char* new_val
  * @param obj2 the second json_object instance
  * @returns whether both objects are equal or not
  */
-JSON_EXPORT int json_object_equal(struct json_object *obj1,
-			     struct json_object *obj2);
+JSON_EXPORT int json_object_equal(struct json_object *obj1, struct json_object *obj2);
 
 /**
  * Perform a shallow copy of src into *dst as part of an overall json_object_deep_copy().
@@ -974,17 +969,18 @@ JSON_EXPORT int json_object_equal(struct json_object *obj1,
  * When shallow_copy is called *dst will be NULL, and must be non-NULL when it returns.
  * src will never be NULL.
  *
- * If shallow_copy sets the serializer on an object, return 2 to indicate to 
+ * If shallow_copy sets the serializer on an object, return 2 to indicate to
  *  json_object_deep_copy that it should not attempt to use the standard userdata
  *  copy function.
  *
  * @return On success 1 or 2, -1 on errors
  */
-typedef int (json_c_shallow_copy_fn)(json_object *src, json_object *parent, const char *key, size_t index, json_object **dst);
+typedef int(json_c_shallow_copy_fn)(json_object *src, json_object *parent, const char *key,
+                                    size_t index, json_object **dst);
 
 /**
  * The default shallow copy implementation for use with json_object_deep_copy().
- * This simply calls the appropriate json_object_new_<type>() function and 
+ * This simply calls the appropriate json_object_new_<type>() function and
  * copies over the serializer function (_to_json_string internal field of
  * the json_object structure) but not any _userdata or _user_delete values.
  *
@@ -994,7 +990,7 @@ typedef int (json_c_shallow_copy_fn)(json_object *src, json_object *parent, cons
  *
  * @return 1 on success, -1 on errors, but never 2.
  */
-json_c_shallow_copy_fn json_c_shallow_copy_default;
+JSON_EXPORT json_c_shallow_copy_fn json_c_shallow_copy_default;
 
 /**
  * Copy the contents of the JSON object.
@@ -1015,7 +1011,8 @@ json_c_shallow_copy_fn json_c_shallow_copy_default;
  *          or if the destination pointer is non-NULL
  */
 
-JSON_EXPORT int json_object_deep_copy(struct json_object *src, struct json_object **dst, json_c_shallow_copy_fn *shallow_copy); 
+JSON_EXPORT int json_object_deep_copy(struct json_object *src, struct json_object **dst,
+                                      json_c_shallow_copy_fn *shallow_copy);
 #ifdef __cplusplus
 }
 #endif

json_object_iterator.c

@@ -9,6 +9,7 @@
 *
 *******************************************************************************
 */
+#include "config.h"
 
 #include <stddef.h>
 
@@ -53,111 +54,100 @@
 /// Our current representation of the "end" iterator;
 ///
 /// @note May not always be NULL
-static const void* kObjectEndIterValue = NULL;
+static const void *kObjectEndIterValue = NULL;
 
 /**
  * ****************************************************************************
  */
-struct json_object_iterator
-json_object_iter_begin(struct json_object* obj)
+struct json_object_iterator json_object_iter_begin(struct json_object *obj)
 {
-    struct json_object_iterator iter;
-    struct lh_table* pTable;
+	struct json_object_iterator iter;
+	struct lh_table *pTable;
 
-    /// @note json_object_get_object will return NULL if passed NULL
-    ///       or a non-json_type_object instance
-    pTable = json_object_get_object(obj);
-    JASSERT(NULL != pTable);
+	/// @note json_object_get_object will return NULL if passed NULL
+	///       or a non-json_type_object instance
+	pTable = json_object_get_object(obj);
+	JASSERT(NULL != pTable);
 
-    /// @note For a pair-less Object, head is NULL, which matches our
-    ///       definition of the "end" iterator
-    iter.opaque_ = pTable->head;
-    return iter;
+	/// @note For a pair-less Object, head is NULL, which matches our
+	///       definition of the "end" iterator
+	iter.opaque_ = pTable->head;
+	return iter;
 }
 
 /**
  * ****************************************************************************
  */
-struct json_object_iterator
-json_object_iter_end(const struct json_object* obj)
+struct json_object_iterator json_object_iter_end(const struct json_object *obj)
 {
-    struct json_object_iterator iter;
+	struct json_object_iterator iter;
 
-    JASSERT(NULL != obj);
-    JASSERT(json_object_is_type(obj, json_type_object));
+	JASSERT(NULL != obj);
+	JASSERT(json_object_is_type(obj, json_type_object));
 
-    iter.opaque_ = kObjectEndIterValue;
+	iter.opaque_ = kObjectEndIterValue;
 
-    return iter;
+	return iter;
 }
 
 /**
  * ****************************************************************************
  */
-void
-json_object_iter_next(struct json_object_iterator* iter)
+void json_object_iter_next(struct json_object_iterator *iter)
 {
-    JASSERT(NULL != iter);
-    JASSERT(kObjectEndIterValue != iter->opaque_);
+	JASSERT(NULL != iter);
+	JASSERT(kObjectEndIterValue != iter->opaque_);
 
-    iter->opaque_ = ((const struct lh_entry *)iter->opaque_)->next;
+	iter->opaque_ = ((const struct lh_entry *)iter->opaque_)->next;
 }
 
-
 /**
  * ****************************************************************************
  */
-const char*
-json_object_iter_peek_name(const struct json_object_iterator* iter)
+const char *json_object_iter_peek_name(const struct json_object_iterator *iter)
 {
-    JASSERT(NULL != iter);
-    JASSERT(kObjectEndIterValue != iter->opaque_);
+	JASSERT(NULL != iter);
+	JASSERT(kObjectEndIterValue != iter->opaque_);
 
-    return (const char*)(((const struct lh_entry *)iter->opaque_)->k);
+	return (const char *)(((const struct lh_entry *)iter->opaque_)->k);
 }
 
-
 /**
  * ****************************************************************************
  */
-struct json_object*
-json_object_iter_peek_value(const struct json_object_iterator* iter)
+struct json_object *json_object_iter_peek_value(const struct json_object_iterator *iter)
 {
-    JASSERT(NULL != iter);
-    JASSERT(kObjectEndIterValue != iter->opaque_);
+	JASSERT(NULL != iter);
+	JASSERT(kObjectEndIterValue != iter->opaque_);
 
-    return (struct json_object*)lh_entry_v((const struct lh_entry *)iter->opaque_);
+	return (struct json_object *)lh_entry_v((const struct lh_entry *)iter->opaque_);
 }
 
-
 /**
  * ****************************************************************************
  */
-json_bool
-json_object_iter_equal(const struct json_object_iterator* iter1,
-                       const struct json_object_iterator* iter2)
+json_bool json_object_iter_equal(const struct json_object_iterator *iter1,
+                                 const struct json_object_iterator *iter2)
 {
-    JASSERT(NULL != iter1);
-    JASSERT(NULL != iter2);
+	JASSERT(NULL != iter1);
+	JASSERT(NULL != iter2);
 
-    return (iter1->opaque_ == iter2->opaque_);
+	return (iter1->opaque_ == iter2->opaque_);
 }
 
-
 /**
  * ****************************************************************************
  */
-struct json_object_iterator
-json_object_iter_init_default(void)
+struct json_object_iterator json_object_iter_init_default(void)
 {
-    struct json_object_iterator iter;
+	struct json_object_iterator iter;
 
-    /**
-     * @note Make this a negative, invalid value, such that
-     *       accidental access to it would likely be trapped by the
-     *       hardware as an invalid address.
-     */
-    iter.opaque_ = NULL;
+	/**
+	 * @note Make this a negative, invalid value, such that
+	 *       accidental access to it would likely be trapped by the
+	 *       hardware as an invalid address.
+	 */
+	iter.opaque_ = NULL;
 
-    return iter;
+	return iter;
 }

json_object_iterator.h

@@ -20,10 +20,10 @@
 *******************************************************************************
 */
 
-
 #ifndef JSON_OBJECT_ITERATOR_H
 #define JSON_OBJECT_ITERATOR_H
 
+#include "json_types.h"
 #include <stddef.h>
 
 #ifdef __cplusplus
@@ -39,17 +39,16 @@ struct json_object_iter_info_;
  * The opaque iterator that references a name/value pair within
  * a JSON Object instance or the "end" iterator value.
  */
-struct json_object_iterator {
-    const void* opaque_;
+struct json_object_iterator
+{
+	const void *opaque_;
 };
 
-
 /**
  * forward declaration of json-c's JSON value instance structure
  */
 struct json_object;
 
-
 /**
  * Initializes an iterator structure to a "default" value that
  * is convenient for initializing an iterator variable to a
@@ -72,8 +71,7 @@ struct json_object;
  *
  * @return json_object_iterator
  */
-struct json_object_iterator
-json_object_iter_init_default(void);
+JSON_EXPORT struct json_object_iterator json_object_iter_init_default(void);
 
 /** Retrieves an iterator to the first pair of the JSON Object.
  *
@@ -106,8 +104,7 @@ json_object_iter_init_default(void);
  *
  * @endcode
  */
-struct json_object_iterator
-json_object_iter_begin(struct json_object* obj);
+JSON_EXPORT struct json_object_iterator json_object_iter_begin(struct json_object *obj);
 
 /** Retrieves the iterator that represents the position beyond the
  *  last pair of the given JSON Object instance.
@@ -137,8 +134,7 @@ json_object_iter_begin(struct json_object* obj);
  *              (i.e., NOT the last pair, but "beyond the last
  *              pair" value)
  */
-struct json_object_iterator
-json_object_iter_end(const struct json_object* obj);
+JSON_EXPORT struct json_object_iterator json_object_iter_end(const struct json_object *obj);
 
 /** Returns an iterator to the next pair, if any
  *
@@ -155,9 +151,7 @@ json_object_iter_end(const struct json_object* obj);
  *         of json_object_iter_end() for the same JSON Object
  *         instance.
  */
-void
-json_object_iter_next(struct json_object_iterator* iter);
-
+JSON_EXPORT void json_object_iter_next(struct json_object_iterator *iter);
 
 /** Returns a const pointer to the name of the pair referenced
  *  by the given iterator.
@@ -174,9 +168,7 @@ json_object_iter_next(struct json_object_iterator* iter);
  *         deleted or modified, and MUST NOT be modified or
  *         freed by the user.
  */
-const char*
-json_object_iter_peek_name(const struct json_object_iterator* iter);
-
+JSON_EXPORT const char *json_object_iter_peek_name(const struct json_object_iterator *iter);
 
 /** Returns a pointer to the json-c instance representing the
  *  value of the referenced name/value pair, without altering
@@ -197,9 +189,8 @@ json_object_iter_peek_name(const struct json_object_iterator* iter);
  *         the JSON Null value as a NULL json_object instance
  *         pointer.
  */
-struct json_object*
-json_object_iter_peek_value(const struct json_object_iterator* iter);
-
+JSON_EXPORT struct json_object *
+json_object_iter_peek_value(const struct json_object_iterator *iter);
 
 /** Tests two iterators for equality.  Typically used to test
  *  for end of iteration by comparing an iterator to the
@@ -227,14 +218,11 @@ json_object_iter_peek_value(const struct json_object_iterator* iter);
  *         reference the same name/value pair or are both at
  *         "end"); zero if they are not equal.
  */
-json_bool
-json_object_iter_equal(const struct json_object_iterator* iter1,
-                       const struct json_object_iterator* iter2);
-
+JSON_EXPORT json_bool json_object_iter_equal(const struct json_object_iterator *iter1,
+                                             const struct json_object_iterator *iter2);
 
 #ifdef __cplusplus
 }
 #endif
 
-
 #endif /* JSON_OBJECT_ITERATOR_H */

json_object_private.h

@@ -20,36 +20,80 @@
 extern "C" {
 #endif
 
-#define LEN_DIRECT_STRING_DATA 32 /**< how many bytes are directly stored in json_object for strings? */
+struct json_object;
+#include "json_inttypes.h"
+#include "json_types.h"
 
-typedef void (json_object_private_delete_fn)(struct json_object *o);
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif /* HAVE_UNISTD_H */
+
+#ifdef _MSC_VER
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+
+/* json object int type, support extension*/
+typedef enum json_object_int_type
+{
+	json_object_int_type_int64,
+	json_object_int_type_uint64
+} json_object_int_type;
 
 struct json_object
 {
-  enum json_type o_type;
-  json_object_private_delete_fn *_delete;
-  json_object_to_json_string_fn *_to_json_string;
-  int _ref_count;
-  struct printbuf *_pb;
-  union data {
-    json_bool c_boolean;
-    double c_double;
-    int64_t c_int64;
-    struct lh_table *c_object;
-    struct array_list *c_array;
-    struct {
-	union {
-		/* optimize: if we have small strings, we can store them
-		 * directly. This saves considerable CPU cycles AND memory.
-		 */
-		char *ptr;
-		char data[LEN_DIRECT_STRING_DATA];
-	} str;
-        int len;
-    } c_string;
-  } o;
-  json_object_delete_fn *_user_delete;
-  void *_userdata;
+	enum json_type o_type;
+	uint32_t _ref_count;
+	json_object_to_json_string_fn *_to_json_string;
+	struct printbuf *_pb;
+	json_object_delete_fn *_user_delete;
+	void *_userdata;
+	// Actually longer, always malloc'd as some more-specific type.
+	// The rest of a struct json_object_${o_type} follows
+};
+
+struct json_object_object
+{
+	struct json_object base;
+	struct lh_table *c_object;
+};
+struct json_object_array
+{
+	struct json_object base;
+	struct array_list *c_array;
+};
+
+struct json_object_boolean
+{
+	struct json_object base;
+	json_bool c_boolean;
+};
+struct json_object_double
+{
+	struct json_object base;
+	double c_double;
+};
+struct json_object_int
+{
+	struct json_object base;
+	enum json_object_int_type cint_type;
+	union
+	{
+		int64_t c_int64;
+		uint64_t c_uint64;
+	} cint;
+};
+struct json_object_string
+{
+	struct json_object base;
+	ssize_t len; // Signed b/c negative lengths indicate data is a pointer
+	// Consider adding an "alloc" field here, if json_object_set_string calls
+	// to expand the length of a string are common operations to perform.
+	union
+	{
+		char idata[1]; // Immediate data.  Actually longer
+		char *pdata;   // Only when len < 0
+	} c_string;
 };
 
 void _json_c_set_last_err(const char *err_fmt, ...);

json_pointer.c

@@ -10,11 +10,11 @@
 
 #include "strerror_override.h"
 
+#include <ctype.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 
 #include "json_pointer.h"
 #include "strdup_compat.h"
@@ -28,9 +28,10 @@
 static void string_replace_all_occurrences_with_char(char *s, const char *occur, char repl_char)
 {
 	int slen = strlen(s);
-	int skip = strlen(occur) - 1; /* length of the occurence, minus the char we're replacing */
+	int skip = strlen(occur) - 1; /* length of the occurrence, minus the char we're replacing */
 	char *p = s;
-	while ((p = strstr(p, occur))) {
+	while ((p = strstr(p, occur)))
+	{
 		*p = repl_char;
 		p++;
 		slen -= skip;
@@ -41,10 +42,13 @@ static void string_replace_all_occurrences_with_char(char *s, const char *occur,
 static int is_valid_index(struct json_object *jo, const char *path, int32_t *idx)
 {
 	int i, len = strlen(path);
-	/* this code-path optimizes a bit, for when we reference the 0-9 index range in a JSON array
-	   and because leading zeros not allowed */
-	if (len == 1) {
-		if (isdigit((int)path[0])) {
+	/* this code-path optimizes a bit, for when we reference the 0-9 index range
+	 * in a JSON array and because leading zeros not allowed
+	 */
+	if (len == 1)
+	{
+		if (isdigit((unsigned char)path[0]))
+		{
 			*idx = (path[0] - '0');
 			goto check_oob;
 		}
@@ -52,26 +56,31 @@ static int is_valid_index(struct json_object *jo, const char *path, int32_t *idx
 		return 0;
 	}
 	/* leading zeros not allowed per RFC */
-	if (path[0] == '0') {
+	if (path[0] == '0')
+	{
 		errno = EINVAL;
 		return 0;
 	}
 	/* RFC states base-10 decimals */
-	for (i = 0; i < len; i++) {
-		if (!isdigit((int)path[i])) {
+	for (i = 0; i < len; i++)
+	{
+		if (!isdigit((unsigned char)path[i]))
+		{
 			errno = EINVAL;
 			return 0;
 		}
 	}
 
 	*idx = strtol(path, NULL, 10);
-	if (*idx < 0) {
+	if (*idx < 0)
+	{
 		errno = EINVAL;
 		return 0;
 	}
 check_oob:
 	len = json_object_array_length(jo);
-	if (*idx >= len) {
+	if (*idx >= len)
+	{
 		errno = ENOENT;
 		return 0;
 	}
@@ -79,14 +88,17 @@ check_oob:
 	return 1;
 }
 
-static int json_pointer_get_single_path(struct json_object *obj, char *path, struct json_object **value)
+static int json_pointer_get_single_path(struct json_object *obj, char *path,
+                                        struct json_object **value)
 {
-	if (json_object_is_type(obj, json_type_array)) {
+	if (json_object_is_type(obj, json_type_array))
+	{
 		int32_t idx;
 		if (!is_valid_index(obj, path, &idx))
 			return -1;
 		obj = json_object_array_get_idx(obj, idx);
-		if (obj) {
+		if (obj)
+		{
 			if (value)
 				*value = obj;
 			return 0;
@@ -100,7 +112,8 @@ static int json_pointer_get_single_path(struct json_object *obj, char *path, str
 	string_replace_all_occurrences_with_char(path, "~1", '/');
 	string_replace_all_occurrences_with_char(path, "~0", '~');
 
-	if (!json_object_object_get_ex(obj, path, value)) {
+	if (!json_object_object_get_ex(obj, path, value))
+	{
 		errno = ENOENT;
 		return -1;
 	}
@@ -108,12 +121,11 @@ static int json_pointer_get_single_path(struct json_object *obj, char *path, str
 	return 0;
 }
 
-static int json_pointer_set_single_path(
-	struct json_object *parent,
-	const char *path,
-	struct json_object *value)
+static int json_pointer_set_single_path(struct json_object *parent, const char *path,
+                                        struct json_object *value)
 {
-	if (json_object_is_type(parent, json_type_array)) {
+	if (json_object_is_type(parent, json_type_array))
+	{
 		int32_t idx;
 		/* RFC (Chapter 4) states that '-' may be used to add new elements to an array */
 		if (path[0] == '-' && path[1] == '\0')
@@ -124,26 +136,27 @@ static int json_pointer_set_single_path(
 	}
 
 	/* path replacements should have been done in json_pointer_get_single_path(),
-	   and we should still be good here */
+	 * and we should still be good here
+	 */
 	if (json_object_is_type(parent, json_type_object))
 		return json_object_object_add(parent, path, value);
 
-	/* Getting here means that we tried to "dereference" a primitive JSON type (like string, int, bool).
-	   i.e. add a sub-object to it */
+	/* Getting here means that we tried to "dereference" a primitive JSON type
+	 * (like string, int, bool).i.e. add a sub-object to it
+	 */
 	errno = ENOENT;
 	return -1;
 }
 
-static int json_pointer_get_recursive(
-	struct json_object *obj,
-	char *path,
-	struct json_object **value)
+static int json_pointer_get_recursive(struct json_object *obj, char *path,
+                                      struct json_object **value)
 {
 	char *endp;
 	int rc;
 
 	/* All paths (on each recursion level must have a leading '/' */
-	if (path[0] != '/') {
+	if (path[0] != '/')
+	{
 		errno = EINVAL;
 		return -1;
 	}
@@ -157,8 +170,10 @@ static int json_pointer_get_recursive(
 	if ((rc = json_pointer_get_single_path(obj, path, &obj)))
 		return rc;
 
-	if (endp) {
-		*endp = '/'; /* Put the slash back, so that the sanity check passes on next recursion level */
+	if (endp)
+	{
+		/* Put the slash back, so that the sanity check passes on next recursion level */
+		*endp = '/';
 		return json_pointer_get_recursive(obj, endp, value);
 	}
 
@@ -174,19 +189,22 @@ int json_pointer_get(struct json_object *obj, const char *path, struct json_obje
 	char *path_copy = NULL;
 	int rc;
 
-	if (!obj || !path) {
+	if (!obj || !path)
+	{
 		errno = EINVAL;
 		return -1;
 	}
 
-	if (path[0] == '\0') {
+	if (path[0] == '\0')
+	{
 		if (res)
 			*res = obj;
 		return 0;
 	}
 
 	/* pass a working copy to the recursive call */
-	if (!(path_copy = strdup(path))) {
+	if (!(path_copy = strdup(path)))
+	{
 		errno = ENOMEM;
 		return -1;
 	}
@@ -202,7 +220,8 @@ int json_pointer_getf(struct json_object *obj, struct json_object **res, const c
 	int rc = 0;
 	va_list args;
 
-	if (!obj || !path_fmt) {
+	if (!obj || !path_fmt)
+	{
 		errno = EINVAL;
 		return -1;
 	}
@@ -214,7 +233,8 @@ int json_pointer_getf(struct json_object *obj, struct json_object **res, const c
 	if (rc < 0)
 		return rc;
 
-	if (path_copy[0] == '\0') {
+	if (path_copy[0] == '\0')
+	{
 		if (res)
 			*res = obj;
 		goto out;
@@ -234,30 +254,35 @@ int json_pointer_set(struct json_object **obj, const char *path, struct json_obj
 	struct json_object *set = NULL;
 	int rc;
 
-	if (!obj || !path) {
+	if (!obj || !path)
+	{
 		errno = EINVAL;
 		return -1;
 	}
 
-	if (path[0] == '\0') {
+	if (path[0] == '\0')
+	{
 		json_object_put(*obj);
 		*obj = value;
 		return 0;
 	}
 
-	if (path[0] != '/') {
+	if (path[0] != '/')
+	{
 		errno = EINVAL;
 		return -1;
 	}
 
 	/* If there's only 1 level to set, stop here */
-	if ((endp = strrchr(path, '/')) == path) {
+	if ((endp = strrchr(path, '/')) == path)
+	{
 		path++;
 		return json_pointer_set_single_path(*obj, path, value);
 	}
 
 	/* pass a working copy to the recursive call */
-	if (!(path_copy = strdup(path))) {
+	if (!(path_copy = strdup(path)))
+	{
 		errno = ENOMEM;
 		return -1;
 	}
@@ -272,7 +297,8 @@ int json_pointer_set(struct json_object **obj, const char *path, struct json_obj
 	return json_pointer_set_single_path(set, endp, value);
 }
 
-int json_pointer_setf(struct json_object **obj, struct json_object *value, const char *path_fmt, ...)
+int json_pointer_setf(struct json_object **obj, struct json_object *value, const char *path_fmt,
+                      ...)
 {
 	char *endp;
 	char *path_copy = NULL;
@@ -280,7 +306,8 @@ int json_pointer_setf(struct json_object **obj, struct json_object *value, const
 	va_list args;
 	int rc = 0;
 
-	if (!obj || !path_fmt) {
+	if (!obj || !path_fmt)
+	{
 		errno = EINVAL;
 		return -1;
 	}
@@ -293,20 +320,23 @@ int json_pointer_setf(struct json_object **obj, struct json_object *value, const
 	if (rc < 0)
 		return rc;
 
-	if (path_copy[0] == '\0') {
+	if (path_copy[0] == '\0')
+	{
 		json_object_put(*obj);
 		*obj = value;
 		goto out;
 	}
 
-	if (path_copy[0] != '/') {
+	if (path_copy[0] != '/')
+	{
 		errno = EINVAL;
 		rc = -1;
 		goto out;
 	}
 
 	/* If there's only 1 level to set, stop here */
-	if ((endp = strrchr(path_copy, '/')) == path_copy) {
+	if ((endp = strrchr(path_copy, '/')) == path_copy)
+	{
 		set = *obj;
 		goto set_single_path;
 	}
@@ -324,4 +354,3 @@ out:
 	free(path_copy);
 	return rc;
 }
-

json_pointer.h

@@ -39,12 +39,13 @@ extern "C" {
  *
  * @param obj the json_object instance/tree from where to retrieve sub-objects
  * @param path a (RFC6901) string notation for the sub-object to retrieve
- * @param res a pointer where to store a reference to the json_object
+ * @param res a pointer that stores a reference to the json_object
  *              associated with the given path
  *
  * @return negative if an error (or not found), or 0 if succeeded
  */
-int json_pointer_get(struct json_object *obj, const char *path, struct json_object **res);
+JSON_EXPORT int json_pointer_get(struct json_object *obj, const char *path,
+                                 struct json_object **res);
 
 /**
  * This is a variant of 'json_pointer_get()' that supports printf() style arguments.
@@ -56,13 +57,14 @@ int json_pointer_get(struct json_object *obj, const char *path, struct json_obje
  * aspects when using this function.
  *
  * @param obj the json_object instance/tree to which to add a sub-object
- * @param res a pointer where to store a reference to the json_object
+ * @param res a pointer that stores a reference to the json_object
  *              associated with the given path
  * @param path_fmt a printf() style format for the path
  *
  * @return negative if an error (or not found), or 0 if succeeded
  */
-int json_pointer_getf(struct json_object *obj, struct json_object **res, const char *path_fmt, ...);
+JSON_EXPORT int json_pointer_getf(struct json_object *obj, struct json_object **res,
+                                  const char *path_fmt, ...);
 
 /**
  * Sets JSON object 'value' in the 'obj' tree at the location specified
@@ -93,7 +95,8 @@ int json_pointer_getf(struct json_object *obj, struct json_object **res, const c
  *
  * @return negative if an error (or not found), or 0 if succeeded
  */
-int json_pointer_set(struct json_object **obj, const char *path, struct json_object *value);
+JSON_EXPORT int json_pointer_set(struct json_object **obj, const char *path,
+                                 struct json_object *value);
 
 /**
  * This is a variant of 'json_pointer_set()' that supports printf() style arguments.
@@ -110,8 +113,8 @@ int json_pointer_set(struct json_object **obj, const char *path, struct json_obj
  *
  * @return negative if an error (or not found), or 0 if succeeded
  */
-int json_pointer_setf(struct json_object **obj, struct json_object *value, const char *path_fmt, ...);
-
+JSON_EXPORT int json_pointer_setf(struct json_object **obj, struct json_object *value,
+                                  const char *path_fmt, ...);
 
 #ifdef __cplusplus
 }

json_tokener.h

@@ -16,80 +16,123 @@
 #ifndef _json_tokener_h_
 #define _json_tokener_h_
 
-#include <stddef.h>
 #include "json_object.h"
+#include <stddef.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-enum json_tokener_error {
-  json_tokener_success,
-  json_tokener_continue,
-  json_tokener_error_depth,
-  json_tokener_error_parse_eof,
-  json_tokener_error_parse_unexpected,
-  json_tokener_error_parse_null,
-  json_tokener_error_parse_boolean,
-  json_tokener_error_parse_number,
-  json_tokener_error_parse_array,
-  json_tokener_error_parse_object_key_name,
-  json_tokener_error_parse_object_key_sep,
-  json_tokener_error_parse_object_value_sep,
-  json_tokener_error_parse_string,
-  json_tokener_error_parse_comment,
-  json_tokener_error_size
+enum json_tokener_error
+{
+	json_tokener_success,
+	json_tokener_continue,
+	json_tokener_error_depth,
+	json_tokener_error_parse_eof,
+	json_tokener_error_parse_unexpected,
+	json_tokener_error_parse_null,
+	json_tokener_error_parse_boolean,
+	json_tokener_error_parse_number,
+	json_tokener_error_parse_array,
+	json_tokener_error_parse_object_key_name,
+	json_tokener_error_parse_object_key_sep,
+	json_tokener_error_parse_object_value_sep,
+	json_tokener_error_parse_string,
+	json_tokener_error_parse_comment,
+	json_tokener_error_parse_utf8_string,
+	json_tokener_error_size
 };
 
-enum json_tokener_state {
-  json_tokener_state_eatws,
-  json_tokener_state_start,
-  json_tokener_state_finish,
-  json_tokener_state_null,
-  json_tokener_state_comment_start,
-  json_tokener_state_comment,
-  json_tokener_state_comment_eol,
-  json_tokener_state_comment_end,
-  json_tokener_state_string,
-  json_tokener_state_string_escape,
-  json_tokener_state_escape_unicode,
-  json_tokener_state_boolean,
-  json_tokener_state_number,
-  json_tokener_state_array,
-  json_tokener_state_array_add,
-  json_tokener_state_array_sep,
-  json_tokener_state_object_field_start,
-  json_tokener_state_object_field,
-  json_tokener_state_object_field_end,
-  json_tokener_state_object_value,
-  json_tokener_state_object_value_add,
-  json_tokener_state_object_sep,
-  json_tokener_state_array_after_sep,
-  json_tokener_state_object_field_start_after_sep,
-  json_tokener_state_inf
+/**
+ * @deprecated Don't use this outside of json_tokener.c, it will be made private in a future release.
+ */
+enum json_tokener_state
+{
+	json_tokener_state_eatws,
+	json_tokener_state_start,
+	json_tokener_state_finish,
+	json_tokener_state_null,
+	json_tokener_state_comment_start,
+	json_tokener_state_comment,
+	json_tokener_state_comment_eol,
+	json_tokener_state_comment_end,
+	json_tokener_state_string,
+	json_tokener_state_string_escape,
+	json_tokener_state_escape_unicode,
+	json_tokener_state_boolean,
+	json_tokener_state_number,
+	json_tokener_state_array,
+	json_tokener_state_array_add,
+	json_tokener_state_array_sep,
+	json_tokener_state_object_field_start,
+	json_tokener_state_object_field,
+	json_tokener_state_object_field_end,
+	json_tokener_state_object_value,
+	json_tokener_state_object_value_add,
+	json_tokener_state_object_sep,
+	json_tokener_state_array_after_sep,
+	json_tokener_state_object_field_start_after_sep,
+	json_tokener_state_inf
 };
 
+/**
+ * @deprecated Don't use this outside of json_tokener.c, it will be made private in a future release.
+ */
 struct json_tokener_srec
 {
-  enum json_tokener_state state, saved_state;
-  struct json_object *obj;
-  struct json_object *current;
-  char *obj_field_name;
+	enum json_tokener_state state, saved_state;
+	struct json_object *obj;
+	struct json_object *current;
+	char *obj_field_name;
 };
 
 #define JSON_TOKENER_DEFAULT_DEPTH 32
 
+/**
+ * Internal state of the json parser.
+ * Do not access any fields of this structure directly.
+ * Its definition is published due to historical limitations
+ * in the json tokener API, and will be changed to be an opaque
+ * type in the future.
+ */
 struct json_tokener
 {
-  char *str;
-  struct printbuf *pb;
-  int max_depth, depth, is_double, st_pos, char_offset;
-  enum json_tokener_error err;
-  unsigned int ucs_char;
-  char quote_char;
-  struct json_tokener_srec *stack;
-  int flags;
+	/**
+	 * @deprecated Do not access any of these fields outside of json_tokener.c
+	 */
+	char *str;
+	struct printbuf *pb;
+	int max_depth, depth, is_double, st_pos;
+	/**
+	 * @deprecated See json_tokener_get_parse_end() instead.
+	 */
+	int char_offset;
+	/**
+	 * @deprecated See json_tokener_get_error() instead.
+	 */
+	enum json_tokener_error err;
+	unsigned int ucs_char;
+	char quote_char;
+	struct json_tokener_srec *stack;
+	int flags;
 };
+
+/**
+ * Return the offset of the byte after the last byte parsed
+ * relative to the start of the most recent string passed in
+ * to json_tokener_parse_ex().  i.e. this is where parsing
+ * would start again if the input contains another JSON object
+ * after the currently parsed one.
+ *
+ * Note that when multiple parse calls are issued, this is *not* the
+ * total number of characters parsed.
+ *
+ * In the past this would have been accessed as tok->char_offset.
+ *
+ * See json_tokener_parse_ex() for an example of how to use this.
+ */
+JSON_EXPORT size_t json_tokener_get_parse_end(struct json_tokener *tok);
+
 /**
  * @deprecated Unused in json-c code
  */
@@ -101,11 +144,36 @@ typedef struct json_tokener json_tokener;
  * restrictive from one release to the next, causing your
  * code to fail on previously working input.
  *
+ * Note that setting this will also effectively disable parsing
+ * of multiple json objects in a single character stream
+ * (e.g. {"foo":123}{"bar":234}); if you want to allow that
+ * also set JSON_TOKENER_ALLOW_TRAILING_CHARS
+ *
  * This flag is not set by default.
  *
  * @see json_tokener_set_flags()
  */
-#define JSON_TOKENER_STRICT  0x01
+#define JSON_TOKENER_STRICT 0x01
+
+/**
+ * Use with JSON_TOKENER_STRICT to allow trailing characters after the
+ * first parsed object.
+ *
+ * @see json_tokener_set_flags()
+ */
+#define JSON_TOKENER_ALLOW_TRAILING_CHARS 0x02
+
+/**
+ * Cause json_tokener_parse_ex() to validate that input is UTF8.
+ * If this flag is specified and validation fails, then
+ * json_tokener_get_error(tok) will return
+ * json_tokener_error_parse_utf8_string
+ *
+ * This flag is not set by default.
+ *
+ * @see json_tokener_set_flags()
+ */
+#define JSON_TOKENER_VALIDATE_UTF8 0x10
 
 /**
  * Given an error previously returned by json_tokener_get_error(),
@@ -113,7 +181,7 @@ typedef struct json_tokener json_tokener;
  *
  * @return a generic error message is returned if an invalid error value is provided.
  */
-const char *json_tokener_error_desc(enum json_tokener_error jerr);
+JSON_EXPORT const char *json_tokener_error_desc(enum json_tokener_error jerr);
 
 /**
  * Retrieve the error caused by the last call to json_tokener_parse_ex(),
@@ -122,16 +190,17 @@ const char *json_tokener_error_desc(enum json_tokener_error jerr);
  * When parsing a JSON string in pieces, if the tokener is in the middle
  * of parsing this will return json_tokener_continue.
  *
- * See also json_tokener_error_desc().
+ * @see json_tokener_error_desc().
  */
 JSON_EXPORT enum json_tokener_error json_tokener_get_error(struct json_tokener *tok);
 
-JSON_EXPORT struct json_tokener* json_tokener_new(void);
-JSON_EXPORT struct json_tokener* json_tokener_new_ex(int depth);
+JSON_EXPORT struct json_tokener *json_tokener_new(void);
+JSON_EXPORT struct json_tokener *json_tokener_new_ex(int depth);
 JSON_EXPORT void json_tokener_free(struct json_tokener *tok);
 JSON_EXPORT void json_tokener_reset(struct json_tokener *tok);
-JSON_EXPORT struct json_object* json_tokener_parse(const char *str);
-JSON_EXPORT struct json_object* json_tokener_parse_verbose(const char *str, enum json_tokener_error *error);
+JSON_EXPORT struct json_object *json_tokener_parse(const char *str);
+JSON_EXPORT struct json_object *json_tokener_parse_verbose(const char *str,
+                                                           enum json_tokener_error *error);
 
 /**
  * Set flags that control how parsing will be done.
@@ -155,17 +224,18 @@ JSON_EXPORT void json_tokener_set_flags(struct json_tokener *tok, int flags);
  * called.
  *
  * When a valid JSON value is parsed, a non-NULL json_object will be
- * returned.  Also, json_tokener_get_error() will return json_tokener_success.
- * Be sure to check the type with json_object_is_type() or
- * json_object_get_type() before using the object.
+ * returned, with a reference count of one which belongs to the caller.  Also,
+ * json_tokener_get_error() will return json_tokener_success. Be sure to check
+ * the type with json_object_is_type() or json_object_get_type() before using
+ * the object.
  *
- * @b XXX this shouldn't use internal fields:
  * Trailing characters after the parsed value do not automatically cause an
  * error.  It is up to the caller to decide whether to treat this as an
  * error or to handle the additional characters, perhaps by parsing another
  * json value starting from that point.
  *
- * Extra characters can be detected by comparing the tok->char_offset against
+ * Extra characters can be detected by comparing the value returned by
+ * json_tokener_get_parse_end() against
  * the length of the last len parameter passed in.
  *
  * The tokener does \b not maintain an internal buffer so the caller is
@@ -193,7 +263,7 @@ if (jerr != json_tokener_success)
 	fprintf(stderr, "Error: %s\n", json_tokener_error_desc(jerr));
 	// Handle errors, as appropriate for your application.
 }
-if (tok->char_offset < stringlen) // XXX shouldn't access internal fields
+if (json_tokener_get_parse_end(tok) < stringlen)
 {
 	// Handle extra characters after parsed object as desired.
 	// e.g. issue an error, parse another object from that point, etc...
@@ -206,8 +276,8 @@ if (tok->char_offset < stringlen) // XXX shouldn't access internal fields
  * @param str an string with any valid JSON expression, or portion of.  This does not need to be null terminated.
  * @param len the length of str
  */
-JSON_EXPORT struct json_object* json_tokener_parse_ex(struct json_tokener *tok,
-						 const char *str, int len);
+JSON_EXPORT struct json_object *json_tokener_parse_ex(struct json_tokener *tok, const char *str,
+                                                      int len);
 
 #ifdef __cplusplus
 }

json_types.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2020 Eric Hawicz
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See COPYING for details.
+ */
+
+#ifndef _json_types_h_
+#define _json_types_h_
+
+/**
+ * @file
+ * @brief Basic types used in a few places in json-c, but you should include "json_object.h" instead.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef JSON_EXPORT
+#if defined(_MSC_VER)
+#define JSON_EXPORT __declspec(dllexport)
+#else
+#define JSON_EXPORT extern
+#endif
+#endif
+
+struct printbuf;
+
+/**
+ * A structure to use with json_object_object_foreachC() loops.
+ * Contains key, val and entry members.
+ */
+struct json_object_iter
+{
+	char *key;
+	struct json_object *val;
+	struct lh_entry *entry;
+};
+typedef struct json_object_iter json_object_iter;
+
+typedef int json_bool;
+
+/**
+ * @brief The core type for all type of JSON objects handled by json-c
+ */
+typedef struct json_object json_object;
+
+/**
+ * Type of custom user delete functions.  See json_object_set_serializer.
+ */
+typedef void(json_object_delete_fn)(struct json_object *jso, void *userdata);
+
+/**
+ * Type of a custom serialization function.  See json_object_set_serializer.
+ */
+typedef int(json_object_to_json_string_fn)(struct json_object *jso, struct printbuf *pb, int level,
+                                           int flags);
+
+/* supported object types */
+
+typedef enum json_type
+{
+	/* If you change this, be sure to update json_type_to_name() too */
+	json_type_null,
+	json_type_boolean,
+	json_type_double,
+	json_type_int,
+	json_type_object,
+	json_type_array,
+	json_type_string
+} json_type;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

json_util.c

@@ -14,13 +14,13 @@
 
 #include "strerror_override.h"
 
+#include <ctype.h>
+#include <limits.h>
 #include <stdarg.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stddef.h>
-#include <limits.h>
 #include <string.h>
-#include <ctype.h>
 
 #ifdef HAVE_SYS_TYPES_H
 #include <sys/types.h>
@@ -35,31 +35,27 @@
 #endif /* HAVE_FCNTL_H */
 
 #ifdef HAVE_UNISTD_H
-# include <unistd.h>
+#include <unistd.h>
 #endif /* HAVE_UNISTD_H */
 
 #ifdef WIN32
-# if MSC_VER < 1800
-/* strtoll is available only since Visual Studio 2013 */
-#  define strtoll _strtoi64
-# endif
-# define WIN32_LEAN_AND_MEAN
-# include <windows.h>
-# include <io.h>
+#define WIN32_LEAN_AND_MEAN
+#include <io.h>
+#include <windows.h>
 #endif /* defined(WIN32) */
 
 #if !defined(HAVE_OPEN) && defined(WIN32)
-# define open _open
+#define open _open
 #endif
 
 #include "snprintf_compat.h"
 
 #include "debug.h"
-#include "printbuf.h"
 #include "json_inttypes.h"
 #include "json_object.h"
 #include "json_tokener.h"
 #include "json_util.h"
+#include "printbuf.h"
 
 static int _json_object_to_fd(int fd, struct json_object *obj, int flags, const char *filename);
 
@@ -81,43 +77,74 @@ void _json_c_set_last_err(const char *err_fmt, ...)
 	va_end(ap);
 }
 
-struct json_object* json_object_from_fd(int fd)
+struct json_object *json_object_from_fd(int fd)
 {
-  struct printbuf *pb;
-  struct json_object *obj;
-  char buf[JSON_FILE_BUF_SIZE];
-  int ret;
+	return json_object_from_fd_ex(fd, -1);
+}
+struct json_object *json_object_from_fd_ex(int fd, int in_depth)
+{
+	struct printbuf *pb;
+	struct json_object *obj;
+	char buf[JSON_FILE_BUF_SIZE];
+	int ret;
+	int depth = JSON_TOKENER_DEFAULT_DEPTH;
+	json_tokener *tok;
 
-  if(!(pb = printbuf_new())) {
-    _json_c_set_last_err("json_object_from_file: printbuf_new failed\n");
-    return NULL;
-  }
-  while((ret = read(fd, buf, JSON_FILE_BUF_SIZE)) > 0) {
-    printbuf_memappend(pb, buf, ret);
-  }
-  if(ret < 0) {
-    _json_c_set_last_err("json_object_from_fd: error reading fd %d: %s\n", fd, strerror(errno));
-    printbuf_free(pb);
-    return NULL;
-  }
-  obj = json_tokener_parse(pb->buf);
-  printbuf_free(pb);
-  return obj;
+	if (!(pb = printbuf_new()))
+	{
+		_json_c_set_last_err("json_object_from_file: printbuf_new failed\n");
+		return NULL;
+	}
+
+	if (in_depth != -1)
+		depth = in_depth;
+	tok = json_tokener_new_ex(depth);
+	if (!tok)
+	{
+		_json_c_set_last_err(
+		    "json_object_from_fd: unable to allocate json_tokener(depth=%d): %s\n", depth,
+		    strerror(errno));
+		printbuf_free(pb);
+		return NULL;
+	}
+
+	while ((ret = read(fd, buf, JSON_FILE_BUF_SIZE)) > 0)
+	{
+		printbuf_memappend(pb, buf, ret);
+	}
+	if (ret < 0)
+	{
+		_json_c_set_last_err("json_object_from_fd: error reading fd %d: %s\n", fd,
+		                     strerror(errno));
+		json_tokener_free(tok);
+		printbuf_free(pb);
+		return NULL;
+	}
+
+	obj = json_tokener_parse_ex(tok, pb->buf, printbuf_length(pb));
+	if (obj == NULL)
+		_json_c_set_last_err("json_tokener_parse_ex failed: %s\n",
+		                     json_tokener_error_desc(json_tokener_get_error(tok)));
+
+	json_tokener_free(tok);
+	printbuf_free(pb);
+	return obj;
 }
 
-struct json_object* json_object_from_file(const char *filename)
+struct json_object *json_object_from_file(const char *filename)
 {
-  struct json_object *obj;
-  int fd;
+	struct json_object *obj;
+	int fd;
 
-  if((fd = open(filename, O_RDONLY)) < 0) {
-    _json_c_set_last_err("json_object_from_file: error opening file %s: %s\n",
-	     filename, strerror(errno));
-    return NULL;
-  }
-  obj = json_object_from_fd(fd);
-  close(fd);
-  return obj;
+	if ((fd = open(filename, O_RDONLY)) < 0)
+	{
+		_json_c_set_last_err("json_object_from_file: error opening file %s: %s\n", filename,
+		                     strerror(errno));
+		return NULL;
+	}
+	obj = json_object_from_fd(fd);
+	close(fd);
+	return obj;
 }
 
 /* extended "format and write to file" function */
@@ -127,14 +154,16 @@ int json_object_to_file_ext(const char *filename, struct json_object *obj, int f
 	int fd, ret;
 	int saved_errno;
 
-	if (!obj) {
+	if (!obj)
+	{
 		_json_c_set_last_err("json_object_to_file: object is null\n");
 		return -1;
 	}
 
-	if ((fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT, 0644)) < 0) {
-		_json_c_set_last_err("json_object_to_file: error opening file %s: %s\n",
-		              filename, strerror(errno));
+	if ((fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT, 0644)) < 0)
+	{
+		_json_c_set_last_err("json_object_to_file: error opening file %s: %s\n", filename,
+		                     strerror(errno));
 		return -1;
 	}
 	ret = _json_object_to_fd(fd, obj, flags, filename);
@@ -146,7 +175,8 @@ int json_object_to_file_ext(const char *filename, struct json_object *obj, int f
 
 int json_object_to_fd(int fd, struct json_object *obj, int flags)
 {
-	if (!obj) {
+	if (!obj)
+	{
 		_json_c_set_last_err("json_object_to_fd: object is null\n");
 		return -1;
 	}
@@ -161,17 +191,21 @@ static int _json_object_to_fd(int fd, struct json_object *obj, int flags, const
 
 	filename = filename ? filename : "(fd)";
 
-	if (!(json_str = json_object_to_json_string_ext(obj,flags))) {
+	if (!(json_str = json_object_to_json_string_ext(obj, flags)))
+	{
 		return -1;
 	}
 
-	wsize = (unsigned int)(strlen(json_str) & UINT_MAX); /* CAW: probably unnecessary, but the most 64bit safe */
+	/* CAW: probably unnecessary, but the most 64bit safe */
+	wsize = (unsigned int)(strlen(json_str) & UINT_MAX);
 	wpos = 0;
-	while(wpos < wsize) {
-		if((ret = write(fd, json_str + wpos, wsize-wpos)) < 0) {
-		  _json_c_set_last_err("json_object_to_file: error writing file %s: %s\n",
-			 filename, strerror(errno));
-		  return -1;
+	while (wpos < wsize)
+	{
+		if ((ret = write(fd, json_str + wpos, wsize - wpos)) < 0)
+		{
+			_json_c_set_last_err("json_object_to_file: error writing file %s: %s\n",
+			                     filename, strerror(errno));
+			return -1;
 		}
 
 		/* because of the above check for ret < 0, we can safely cast and add */
@@ -185,14 +219,14 @@ static int _json_object_to_fd(int fd, struct json_object *obj, int flags, const
 
 int json_object_to_file(const char *filename, struct json_object *obj)
 {
-  return json_object_to_file_ext(filename, obj, JSON_C_TO_STRING_PLAIN);
+	return json_object_to_file_ext(filename, obj, JSON_C_TO_STRING_PLAIN);
 }
 
 int json_parse_double(const char *buf, double *retval)
 {
-  char *end;
-  *retval = strtod(buf, &end);
-  return end == buf ? 1 : 0;
+	char *end;
+	*retval = strtod(buf, &end);
+	return end == buf ? 1 : 0;
 }
 
 int json_parse_int64(const char *buf, int64_t *retval)
@@ -207,8 +241,25 @@ int json_parse_int64(const char *buf, int64_t *retval)
 	return ((val == 0 && errno != 0) || (end == buf)) ? 1 : 0;
 }
 
+int json_parse_uint64(const char *buf, uint64_t *retval)
+{
+	char *end = NULL;
+	uint64_t val;
+
+	errno = 0;
+	while (*buf == ' ')
+		buf++;
+	if (*buf == '-')
+		return 1;  /* error: uint cannot be negative */
+
+	val = strtoull(buf, &end, 10);
+	if (end != buf)
+		*retval = val;
+	return ((val == 0 && errno != 0) || (end == buf)) ? 1 : 0;
+}
+
 #ifndef HAVE_REALLOC
-void* rpl_realloc(void* p, size_t n)
+void *rpl_realloc(void *p, size_t n)
 {
 	if (n == 0)
 		n = 1;
@@ -218,26 +269,28 @@ void* rpl_realloc(void* p, size_t n)
 }
 #endif
 
-#define NELEM(a)        (sizeof(a) / sizeof(a[0]))
-static const char* json_type_name[] = {
-  /* If you change this, be sure to update the enum json_type definition too */
-  "null",
-  "boolean",
-  "double",
-  "int",
-  "object",
-  "array",
-  "string",
+#define NELEM(a) (sizeof(a) / sizeof(a[0]))
+/* clang-format off */
+static const char *json_type_name[] = {
+	/* If you change this, be sure to update the enum json_type definition too */
+	"null",
+	"boolean",
+	"double",
+	"int",
+	"object",
+	"array",
+	"string",
 };
+/* clang-format on */
 
 const char *json_type_to_name(enum json_type o_type)
 {
 	int o_type_int = (int)o_type;
 	if (o_type_int < 0 || o_type_int >= (int)NELEM(json_type_name))
 	{
-		_json_c_set_last_err("json_type_to_name: type %d is out of range [0,%d]\n", o_type, NELEM(json_type_name));
+		_json_c_set_last_err("json_type_to_name: type %d is out of range [0,%d]\n", o_type,
+		                     NELEM(json_type_name));
 		return NULL;
 	}
 	return json_type_name[o_type];
 }
-

json_util.h

@@ -12,21 +12,20 @@
 /**
  * @file
  * @brief Miscllaneous utility functions and macros.
- */ 
+ */
 #ifndef _json_util_h_
 #define _json_util_h_
 
 #include "json_object.h"
 
 #ifndef json_min
-#define json_min(a,b) ((a) < (b) ? (a) : (b))
+#define json_min(a, b) ((a) < (b) ? (a) : (b))
 #endif
 
 #ifndef json_max
-#define json_max(a,b) ((a) > (b) ? (a) : (b))
+#define json_max(a, b) ((a) > (b) ? (a) : (b))
 #endif
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -38,9 +37,9 @@ extern "C" {
  * Read the full contents of the given file, then convert it to a
  * json_object using json_tokener_parse().
  *
- * Returns -1 if something fails.  See json_util_get_last_err() for details.
+ * Returns NULL on failure.  See json_util_get_last_err() for details.
  */
-extern struct json_object* json_object_from_file(const char *filename);
+JSON_EXPORT struct json_object *json_object_from_file(const char *filename);
 
 /**
  * Create a JSON object from already opened file descriptor.
@@ -50,9 +49,21 @@ extern struct json_object* json_object_from_file(const char *filename);
  * Note, that the fd must be readable at the actual position, i.e.
  * use lseek(fd, 0, SEEK_SET) before.
  *
- * Returns -1 if something fails.  See json_util_get_last_err() for details.
+ * The depth argument specifies the maximum object depth to pass to
+ * json_tokener_new_ex().  When depth == -1, JSON_TOKENER_DEFAULT_DEPTH
+ * is used instead.
+ *
+ * Returns NULL on failure.  See json_util_get_last_err() for details.
  */
-extern struct json_object* json_object_from_fd(int fd);
+JSON_EXPORT struct json_object *json_object_from_fd_ex(int fd, int depth);
+
+/**
+ * Create a JSON object from an already opened file descriptor, using
+ * the default maximum object depth. (JSON_TOKENER_DEFAULT_DEPTH)
+ *
+ * See json_object_from_fd_ex() for details.
+ */
+JSON_EXPORT struct json_object *json_object_from_fd(int fd);
 
 /**
  * Equivalent to:
@@ -60,7 +71,7 @@ extern struct json_object* json_object_from_fd(int fd);
  *
  * Returns -1 if something fails.  See json_util_get_last_err() for details.
  */
-extern int json_object_to_file(const char *filename, struct json_object *obj);
+JSON_EXPORT int json_object_to_file(const char *filename, struct json_object *obj);
 
 /**
  * Open and truncate the given file, creating it if necessary, then
@@ -68,7 +79,7 @@ extern int json_object_to_file(const char *filename, struct json_object *obj);
  *
  * Returns -1 if something fails.  See json_util_get_last_err() for details.
  */
-extern int json_object_to_file_ext(const char *filename, struct json_object *obj, int flags);
+JSON_EXPORT int json_object_to_file_ext(const char *filename, struct json_object *obj, int flags);
 
 /**
  * Convert the json_object to a string and write it to the file descriptor.
@@ -80,24 +91,25 @@ extern int json_object_to_file_ext(const char *filename, struct json_object *obj
  * @param flags flags to pass to json_object_to_json_string_ext()
  * @return -1 if something fails.  See json_util_get_last_err() for details.
  */
-extern int json_object_to_fd(int fd, struct json_object *obj, int flags);
+JSON_EXPORT int json_object_to_fd(int fd, struct json_object *obj, int flags);
 
 /**
  * Return the last error from various json-c functions, including:
  * json_object_to_file{,_ext}, json_object_to_fd() or
  * json_object_from_{file,fd}, or NULL if there is none.
  */
-const char *json_util_get_last_err(void);
+JSON_EXPORT const char *json_util_get_last_err(void);
 
-
-extern int json_parse_int64(const char *buf, int64_t *retval);
-extern int json_parse_double(const char *buf, double *retval);
+/* these parsing helpers return zero on success */
+JSON_EXPORT int json_parse_int64(const char *buf, int64_t *retval);
+JSON_EXPORT int json_parse_uint64(const char *buf, uint64_t *retval);
+JSON_EXPORT int json_parse_double(const char *buf, double *retval);
 
 /**
  * Return a string describing the type of the object.
  * e.g. "int", or "object", etc...
  */
-extern const char *json_type_to_name(enum json_type o_type);
+JSON_EXPORT const char *json_type_to_name(enum json_type o_type);
 
 #ifdef __cplusplus
 }

json_visit.c

@@ -13,45 +13,39 @@
 #include "json_visit.h"
 #include "linkhash.h"
 
-static int _json_c_visit(json_object *jso, json_object *parent_jso,
-                         const char *jso_key, size_t *jso_index,
-                         json_c_visit_userfunc *userfunc, void *userarg);
+static int _json_c_visit(json_object *jso, json_object *parent_jso, const char *jso_key,
+                         size_t *jso_index, json_c_visit_userfunc *userfunc, void *userarg);
 
-int json_c_visit(json_object *jso, int future_flags,
-                 json_c_visit_userfunc *userfunc, void *userarg)
+int json_c_visit(json_object *jso, int future_flags, json_c_visit_userfunc *userfunc, void *userarg)
 {
 	int ret = _json_c_visit(jso, NULL, NULL, NULL, userfunc, userarg);
-	switch(ret)
+	switch (ret)
 	{
 	case JSON_C_VISIT_RETURN_CONTINUE:
 	case JSON_C_VISIT_RETURN_SKIP:
 	case JSON_C_VISIT_RETURN_POP:
-	case JSON_C_VISIT_RETURN_STOP:
-		return 0;
-	default:
-		return JSON_C_VISIT_RETURN_ERROR;
+	case JSON_C_VISIT_RETURN_STOP: return 0;
+	default: return JSON_C_VISIT_RETURN_ERROR;
 	}
 }
-static int _json_c_visit(json_object *jso, json_object *parent_jso,
-                         const char *jso_key, size_t *jso_index,
-                         json_c_visit_userfunc *userfunc, void *userarg)
+static int _json_c_visit(json_object *jso, json_object *parent_jso, const char *jso_key,
+                         size_t *jso_index, json_c_visit_userfunc *userfunc, void *userarg)
 {
 	int userret = userfunc(jso, 0, parent_jso, jso_key, jso_index, userarg);
-	switch(userret)
+	switch (userret)
 	{
-	case JSON_C_VISIT_RETURN_CONTINUE:
-		break;
+	case JSON_C_VISIT_RETURN_CONTINUE: break;
 	case JSON_C_VISIT_RETURN_SKIP:
 	case JSON_C_VISIT_RETURN_POP:
 	case JSON_C_VISIT_RETURN_STOP:
-	case JSON_C_VISIT_RETURN_ERROR:
-		return userret;
+	case JSON_C_VISIT_RETURN_ERROR: return userret;
 	default:
-		fprintf(stderr, "ERROR: invalid return value from json_c_visit userfunc: %d\n", userret);
+		fprintf(stderr, "ERROR: invalid return value from json_c_visit userfunc: %d\n",
+		        userret);
 		return JSON_C_VISIT_RETURN_ERROR;
 	}
 
-	switch(json_object_get_type(jso))
+	switch (json_object_get_type(jso))
 	{
 	case json_type_null:
 	case json_type_boolean:
@@ -69,12 +63,13 @@ static int _json_c_visit(json_object *jso, json_object *parent_jso,
 			if (userret == JSON_C_VISIT_RETURN_POP)
 				break;
 			if (userret == JSON_C_VISIT_RETURN_STOP ||
-				userret == JSON_C_VISIT_RETURN_ERROR)
+			    userret == JSON_C_VISIT_RETURN_ERROR)
 				return userret;
 			if (userret != JSON_C_VISIT_RETURN_CONTINUE &&
-				userret != JSON_C_VISIT_RETURN_SKIP)
+			    userret != JSON_C_VISIT_RETURN_SKIP)
 			{
-				fprintf(stderr, "INTERNAL ERROR: _json_c_visit returned %d\n", userret);
+				fprintf(stderr, "INTERNAL ERROR: _json_c_visit returned %d\n",
+				        userret);
 				return JSON_C_VISIT_RETURN_ERROR;
 			}
 		}
@@ -91,19 +86,21 @@ static int _json_c_visit(json_object *jso, json_object *parent_jso,
 			if (userret == JSON_C_VISIT_RETURN_POP)
 				break;
 			if (userret == JSON_C_VISIT_RETURN_STOP ||
-				userret == JSON_C_VISIT_RETURN_ERROR)
+			    userret == JSON_C_VISIT_RETURN_ERROR)
 				return userret;
 			if (userret != JSON_C_VISIT_RETURN_CONTINUE &&
-				userret != JSON_C_VISIT_RETURN_SKIP)
+			    userret != JSON_C_VISIT_RETURN_SKIP)
 			{
-				fprintf(stderr, "INTERNAL ERROR: _json_c_visit returned %d\n", userret);
+				fprintf(stderr, "INTERNAL ERROR: _json_c_visit returned %d\n",
+				        userret);
 				return JSON_C_VISIT_RETURN_ERROR;
 			}
 		}
 		break;
 	}
 	default:
-		fprintf(stderr, "INTERNAL ERROR: _json_c_visit found object of unknown type: %d\n", json_object_get_type(jso));
+		fprintf(stderr, "INTERNAL ERROR: _json_c_visit found object of unknown type: %d\n",
+		        json_object_get_type(jso));
 		return JSON_C_VISIT_RETURN_ERROR;
 	}
 
@@ -112,22 +109,20 @@ static int _json_c_visit(json_object *jso, json_object *parent_jso,
 	// Non-container types will have already returned before this point.
 
 	userret = userfunc(jso, JSON_C_VISIT_SECOND, parent_jso, jso_key, jso_index, userarg);
-	switch(userret)
+	switch (userret)
 	{
 	case JSON_C_VISIT_RETURN_SKIP:
 	case JSON_C_VISIT_RETURN_POP:
-		// These are not really sensible during JSON_C_VISIT_SECOND, 
+		// These are not really sensible during JSON_C_VISIT_SECOND,
 		// but map them to JSON_C_VISIT_CONTINUE anyway.
 		// FALLTHROUGH
-	case JSON_C_VISIT_RETURN_CONTINUE:
-		return JSON_C_VISIT_RETURN_CONTINUE;
+	case JSON_C_VISIT_RETURN_CONTINUE: return JSON_C_VISIT_RETURN_CONTINUE;
 	case JSON_C_VISIT_RETURN_STOP:
-	case JSON_C_VISIT_RETURN_ERROR:
-		return userret;
+	case JSON_C_VISIT_RETURN_ERROR: return userret;
 	default:
-		fprintf(stderr, "ERROR: invalid return value from json_c_visit userfunc: %d\n", userret);
+		fprintf(stderr, "ERROR: invalid return value from json_c_visit userfunc: %d\n",
+		        userret);
 		return JSON_C_VISIT_RETURN_ERROR;
 	}
 	// NOTREACHED
 }
-

json_visit.h

@@ -8,9 +8,12 @@
  */
 #include "json_object.h"
 
-typedef int (json_c_visit_userfunc)(json_object *jso, int flags,
-                                     json_object *parent_jso,                                                        const char *jso_key,
-                                     size_t *jso_index, void *userarg);
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef int(json_c_visit_userfunc)(json_object *jso, int flags, json_object *parent_jso,
+                                   const char *jso_key, size_t *jso_index, void *userarg);
 
 /**
  * Visit each object in the JSON hierarchy starting at jso.
@@ -26,20 +29,20 @@ typedef int (json_c_visit_userfunc)(json_object *jso, int flags,
  * userfunc must return one of the defined return values, to indicate
  * whether and how to continue visiting nodes, or one of various ways to stop.
  *
- * Returns 0 if nodes were visited successfully, even if some were 
+ * Returns 0 if nodes were visited successfully, even if some were
  *  intentionally skipped due to what userfunc returned.
  * Returns <0 if an error occurred during iteration, including if
  *  userfunc returned JSON_C_VISIT_RETURN_ERROR.
  */
-int json_c_visit(json_object *jso, int future_flags,
-                 json_c_visit_userfunc *userfunc, void *userarg);
+JSON_EXPORT int json_c_visit(json_object *jso, int future_flags, json_c_visit_userfunc *userfunc,
+                             void *userarg);
 
 /**
  * Passed to json_c_visit_userfunc as one of the flags values to indicate
  * that this is the second time a container (array or object) is being
  * called, after all of it's members have been iterated over.
  */
-#define JSON_C_VISIT_SECOND  0x02
+#define JSON_C_VISIT_SECOND 0x02
 
 /**
  * This json_c_visit_userfunc return value indicates that iteration
@@ -47,7 +50,6 @@ int json_c_visit(json_object *jso, int future_flags,
  */
 #define JSON_C_VISIT_RETURN_CONTINUE 0
 
-
 /**
  * This json_c_visit_userfunc return value indicates that iteration
  * over the members of the current object should be skipped.
@@ -60,7 +62,7 @@ int json_c_visit(json_object *jso, int future_flags,
  * This json_c_visit_userfunc return value indicates that iteration
  * of the fields/elements of the <b>containing</b> object should stop
  * and continue "popped up" a level of the object hierarchy.
- * For example, returning this when handling arg will result in 
+ * For example, returning this when handling arg will result in
  * arg3 and any other fields being skipped.   The next call to userfunc
  * will be the JSON_C_VISIT_SECOND call on "foo", followed by a userfunc
  * call on "bar".
@@ -92,4 +94,8 @@ int json_c_visit(json_object *jso, int future_flags,
  */
 #define JSON_C_VISIT_RETURN_ERROR -1
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* _json_c_json_visit_h_ */

libjson.c

@@ -7,13 +7,13 @@
 
 #ifndef __warn_references
 
-#if defined(__GNUC__)  && defined (HAS_GNU_WARNING_LONG)
+#if defined(__GNUC__) && defined(HAS_GNU_WARNING_LONG)
 
-#define __warn_references(sym,msg)                  \
-  __asm__(".section .gnu" #sym ",\n\t.ascii \"" msg "\"\n\t.text");
+#define __warn_references(sym, msg) \
+	__asm__(".section .gnu" #sym ",\n\t.ascii \"" msg "\"\n\t.text");
 
 #else
-#define __warn_references(sym,msg)    /* nothing */
+#define __warn_references(sym, msg) /* nothing */
 #endif
 
 #endif

linkhash.c

@@ -12,55 +12,46 @@
 
 #include "config.h"
 
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
+#include <assert.h>
+#include <limits.h>
 #include <stdarg.h>
 #include <stddef.h>
-#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #ifdef HAVE_ENDIAN_H
-# include <endian.h>    /* attempt to define endianness */
+#include <endian.h> /* attempt to define endianness */
 #endif
 
 #if defined(_MSC_VER) || defined(__MINGW32__)
-# define WIN32_LEAN_AND_MEAN
-# include <windows.h>   /* Get InterlockedCompareExchange */
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h> /* Get InterlockedCompareExchange */
 #endif
 
-#include "random_seed.h"
 #include "linkhash.h"
+#include "random_seed.h"
 
 /* hash functions */
 static unsigned long lh_char_hash(const void *k);
 static unsigned long lh_perllike_str_hash(const void *k);
 static lh_hash_fn *char_hash_fn = lh_char_hash;
 
-int
-json_global_set_string_hash(const int h)
+/* comparison functions */
+int lh_char_equal(const void *k1, const void *k2);
+int lh_ptr_equal(const void *k1, const void *k2);
+
+int json_global_set_string_hash(const int h)
 {
-	switch(h) {
-	case JSON_C_STR_HASH_DFLT:
-		char_hash_fn = lh_char_hash;
-		break;
-	case JSON_C_STR_HASH_PERLLIKE:
-		char_hash_fn = lh_perllike_str_hash;
-		break;
-	default:
-		return -1;
+	switch (h)
+	{
+	case JSON_C_STR_HASH_DFLT: char_hash_fn = lh_char_hash; break;
+	case JSON_C_STR_HASH_PERLLIKE: char_hash_fn = lh_perllike_str_hash; break;
+	default: return -1;
 	}
 	return 0;
 }
 
-void lh_abort(const char *msg, ...)
-{
-	va_list ap;
-	va_start(ap, msg);
-	vprintf(msg, ap);
-	va_end(ap);
-	exit(1);
-}
-
 static unsigned long lh_ptr_hash(const void *k)
 {
 	/* CAW: refactored to be 64bit nice */
@@ -119,25 +110,23 @@ on 1 byte), but shoehorning those bytes into integers efficiently is messy.
  * My best guess at if you are big-endian or little-endian.  This may
  * need adjustment.
  */
-#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && \
-     __BYTE_ORDER == __LITTLE_ENDIAN) || \
-    (defined(i386) || defined(__i386__) || defined(__i486__) || \
-     defined(__i586__) || defined(__i686__) || defined(vax) || defined(MIPSEL))
-# define HASH_LITTLE_ENDIAN 1
-# define HASH_BIG_ENDIAN 0
-#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && \
-       __BYTE_ORDER == __BIG_ENDIAN) || \
-      (defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel))
-# define HASH_LITTLE_ENDIAN 0
-# define HASH_BIG_ENDIAN 1
+#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN) || \
+    (defined(i386) || defined(__i386__) || defined(__i486__) || defined(__i586__) ||          \
+     defined(__i686__) || defined(vax) || defined(MIPSEL))
+#define HASH_LITTLE_ENDIAN 1
+#define HASH_BIG_ENDIAN 0
+#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && __BYTE_ORDER == __BIG_ENDIAN) || \
+    (defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel))
+#define HASH_LITTLE_ENDIAN 0
+#define HASH_BIG_ENDIAN 1
 #else
-# define HASH_LITTLE_ENDIAN 0
-# define HASH_BIG_ENDIAN 0
+#define HASH_LITTLE_ENDIAN 0
+#define HASH_BIG_ENDIAN 0
 #endif
 
-#define hashsize(n) ((uint32_t)1<<(n))
-#define hashmask(n) (hashsize(n)-1)
-#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
+#define hashsize(n) ((uint32_t)1 << (n))
+#define hashmask(n) (hashsize(n) - 1)
+#define rot(x, k) (((x) << (k)) | ((x) >> (32 - (k))))
 
 /*
 -------------------------------------------------------------------------------
@@ -183,15 +172,17 @@ on, and rotates are much kinder to the top and bottom bits, so I used
 rotates.
 -------------------------------------------------------------------------------
 */
+/* clang-format off */
 #define mix(a,b,c) \
 { \
-  a -= c;  a ^= rot(c, 4);  c += b; \
-  b -= a;  b ^= rot(a, 6);  a += c; \
-  c -= b;  c ^= rot(b, 8);  b += a; \
-  a -= c;  a ^= rot(c,16);  c += b; \
-  b -= a;  b ^= rot(a,19);  a += c; \
-  c -= b;  c ^= rot(b, 4);  b += a; \
+	a -= c;  a ^= rot(c, 4);  c += b; \
+	b -= a;  b ^= rot(a, 6);  a += c; \
+	c -= b;  c ^= rot(b, 8);  b += a; \
+	a -= c;  a ^= rot(c,16);  c += b; \
+	b -= a;  b ^= rot(a,19);  a += c; \
+	c -= b;  c ^= rot(b, 4);  b += a; \
 }
+/* clang-format on */
 
 /*
 -------------------------------------------------------------------------------
@@ -218,17 +209,18 @@ and these came close:
  11  8 15 26 3 22 24
 -------------------------------------------------------------------------------
 */
+/* clang-format off */
 #define final(a,b,c) \
 { \
-  c ^= b; c -= rot(b,14); \
-  a ^= c; a -= rot(c,11); \
-  b ^= a; b -= rot(a,25); \
-  c ^= b; c -= rot(b,16); \
-  a ^= c; a -= rot(c,4);  \
-  b ^= a; b -= rot(a,14); \
-  c ^= b; c -= rot(b,24); \
+	c ^= b; c -= rot(b,14); \
+	a ^= c; a -= rot(c,11); \
+	b ^= a; b -= rot(a,25); \
+	c ^= b; c -= rot(b,16); \
+	a ^= c; a -= rot(c,4);  \
+	b ^= a; b -= rot(a,14); \
+	c ^= b; c -= rot(b,24); \
 }
-
+/* clang-format on */
 
 /*
 -------------------------------------------------------------------------------
@@ -257,197 +249,208 @@ acceptable.  Do NOT use for cryptographic purposes.
 -------------------------------------------------------------------------------
 */
 
-static uint32_t hashlittle( const void *key, size_t length, uint32_t initval)
+/* clang-format off */
+static uint32_t hashlittle(const void *key, size_t length, uint32_t initval)
 {
-  uint32_t a,b,c;                                          /* internal state */
-  union { const void *ptr; size_t i; } u;     /* needed for Mac Powerbook G4 */
+	uint32_t a,b,c; /* internal state */
+	union
+	{
+		const void *ptr;
+		size_t i;
+	} u; /* needed for Mac Powerbook G4 */
 
-  /* Set up the internal state */
-  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
+	/* Set up the internal state */
+	a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
 
-  u.ptr = key;
-  if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
-    const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
+	u.ptr = key;
+	if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
+		const uint32_t *k = (const uint32_t *)key; /* read 32-bit chunks */
 
-    /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
-    while (length > 12)
-    {
-      a += k[0];
-      b += k[1];
-      c += k[2];
-      mix(a,b,c);
-      length -= 12;
-      k += 3;
-    }
+		/*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
+		while (length > 12)
+		{
+			a += k[0];
+			b += k[1];
+			c += k[2];
+			mix(a,b,c);
+			length -= 12;
+			k += 3;
+		}
 
-    /*----------------------------- handle the last (probably partial) block */
-    /*
-     * "k[2]&0xffffff" actually reads beyond the end of the string, but
-     * then masks off the part it's not allowed to read.  Because the
-     * string is aligned, the masked-off tail is in the same word as the
-     * rest of the string.  Every machine with memory protection I've seen
-     * does it on word boundaries, so is OK with this.  But VALGRIND will
-     * still catch it and complain.  The masking trick does make the hash
-     * noticably faster for short strings (like English words).
-     * AddressSanitizer is similarly picky about overrunning
-	 * the buffer. (http://clang.llvm.org/docs/AddressSanitizer.html
-     */
+		/*----------------------------- handle the last (probably partial) block */
+		/*
+		 * "k[2]&0xffffff" actually reads beyond the end of the string, but
+		 * then masks off the part it's not allowed to read.  Because the
+		 * string is aligned, the masked-off tail is in the same word as the
+		 * rest of the string.  Every machine with memory protection I've seen
+		 * does it on word boundaries, so is OK with this.  But VALGRIND will
+		 * still catch it and complain.  The masking trick does make the hash
+		 * noticably faster for short strings (like English words).
+		 * AddressSanitizer is similarly picky about overrunning
+		 * the buffer. (http://clang.llvm.org/docs/AddressSanitizer.html
+		 */
 #ifdef VALGRIND
-#    define PRECISE_MEMORY_ACCESS 1
+#define PRECISE_MEMORY_ACCESS 1
 #elif defined(__SANITIZE_ADDRESS__) /* GCC's ASAN */
-#    define PRECISE_MEMORY_ACCESS 1
+#define PRECISE_MEMORY_ACCESS 1
 #elif defined(__has_feature)
-#  if __has_feature(address_sanitizer) /* Clang's ASAN */
-#    define PRECISE_MEMORY_ACCESS 1
-#  endif
+#if __has_feature(address_sanitizer) /* Clang's ASAN */
+#define PRECISE_MEMORY_ACCESS 1
+#endif
 #endif
 #ifndef PRECISE_MEMORY_ACCESS
 
-    switch(length)
-    {
-    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
-    case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
-    case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
-    case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
-    case 8 : b+=k[1]; a+=k[0]; break;
-    case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
-    case 6 : b+=k[1]&0xffff; a+=k[0]; break;
-    case 5 : b+=k[1]&0xff; a+=k[0]; break;
-    case 4 : a+=k[0]; break;
-    case 3 : a+=k[0]&0xffffff; break;
-    case 2 : a+=k[0]&0xffff; break;
-    case 1 : a+=k[0]&0xff; break;
-    case 0 : return c;              /* zero length strings require no mixing */
-    }
+		switch(length)
+		{
+		case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+		case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
+		case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
+		case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
+		case 8 : b+=k[1]; a+=k[0]; break;
+		case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
+		case 6 : b+=k[1]&0xffff; a+=k[0]; break;
+		case 5 : b+=k[1]&0xff; a+=k[0]; break;
+		case 4 : a+=k[0]; break;
+		case 3 : a+=k[0]&0xffffff; break;
+		case 2 : a+=k[0]&0xffff; break;
+		case 1 : a+=k[0]&0xff; break;
+		case 0 : return c; /* zero length strings require no mixing */
+		}
 
 #else /* make valgrind happy */
 
-    const uint8_t  *k8 = (const uint8_t *)k;
-    switch(length)
-    {
-    case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
-    case 11: c+=((uint32_t)k8[10])<<16;  /* fall through */
-    case 10: c+=((uint32_t)k8[9])<<8;    /* fall through */
-    case 9 : c+=k8[8];                   /* fall through */
-    case 8 : b+=k[1]; a+=k[0]; break;
-    case 7 : b+=((uint32_t)k8[6])<<16;   /* fall through */
-    case 6 : b+=((uint32_t)k8[5])<<8;    /* fall through */
-    case 5 : b+=k8[4];                   /* fall through */
-    case 4 : a+=k[0]; break;
-    case 3 : a+=((uint32_t)k8[2])<<16;   /* fall through */
-    case 2 : a+=((uint32_t)k8[1])<<8;    /* fall through */
-    case 1 : a+=k8[0]; break;
-    case 0 : return c;
-    }
+		const uint8_t  *k8 = (const uint8_t *)k;
+		switch(length)
+		{
+		case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
+		case 11: c+=((uint32_t)k8[10])<<16;  /* fall through */
+		case 10: c+=((uint32_t)k8[9])<<8;    /* fall through */
+		case 9 : c+=k8[8];                   /* fall through */
+		case 8 : b+=k[1]; a+=k[0]; break;
+		case 7 : b+=((uint32_t)k8[6])<<16;   /* fall through */
+		case 6 : b+=((uint32_t)k8[5])<<8;    /* fall through */
+		case 5 : b+=k8[4];                   /* fall through */
+		case 4 : a+=k[0]; break;
+		case 3 : a+=((uint32_t)k8[2])<<16;   /* fall through */
+		case 2 : a+=((uint32_t)k8[1])<<8;    /* fall through */
+		case 1 : a+=k8[0]; break;
+		case 0 : return c;
+		}
 
 #endif /* !valgrind */
 
-  } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
-    const uint16_t *k = (const uint16_t *)key;         /* read 16-bit chunks */
-    const uint8_t  *k8;
+	}
+	else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0))
+	{
+		const uint16_t *k = (const uint16_t *)key; /* read 16-bit chunks */
+		const uint8_t  *k8;
 
-    /*--------------- all but last block: aligned reads and different mixing */
-    while (length > 12)
-    {
-      a += k[0] + (((uint32_t)k[1])<<16);
-      b += k[2] + (((uint32_t)k[3])<<16);
-      c += k[4] + (((uint32_t)k[5])<<16);
-      mix(a,b,c);
-      length -= 12;
-      k += 6;
-    }
+		/*--------------- all but last block: aligned reads and different mixing */
+		while (length > 12)
+		{
+			a += k[0] + (((uint32_t)k[1])<<16);
+			b += k[2] + (((uint32_t)k[3])<<16);
+			c += k[4] + (((uint32_t)k[5])<<16);
+			mix(a,b,c);
+			length -= 12;
+			k += 6;
+		}
 
-    /*----------------------------- handle the last (probably partial) block */
-    k8 = (const uint8_t *)k;
-    switch(length)
-    {
-    case 12: c+=k[4]+(((uint32_t)k[5])<<16);
-             b+=k[2]+(((uint32_t)k[3])<<16);
-             a+=k[0]+(((uint32_t)k[1])<<16);
-             break;
-    case 11: c+=((uint32_t)k8[10])<<16;     /* fall through */
-    case 10: c+=k[4];
-             b+=k[2]+(((uint32_t)k[3])<<16);
-             a+=k[0]+(((uint32_t)k[1])<<16);
-             break;
-    case 9 : c+=k8[8];                      /* fall through */
-    case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
-             a+=k[0]+(((uint32_t)k[1])<<16);
-             break;
-    case 7 : b+=((uint32_t)k8[6])<<16;      /* fall through */
-    case 6 : b+=k[2];
-             a+=k[0]+(((uint32_t)k[1])<<16);
-             break;
-    case 5 : b+=k8[4];                      /* fall through */
-    case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
-             break;
-    case 3 : a+=((uint32_t)k8[2])<<16;      /* fall through */
-    case 2 : a+=k[0];
-             break;
-    case 1 : a+=k8[0];
-             break;
-    case 0 : return c;                     /* zero length requires no mixing */
-    }
+		/*----------------------------- handle the last (probably partial) block */
+		k8 = (const uint8_t *)k;
+		switch(length)
+		{
+		case 12: c+=k[4]+(((uint32_t)k[5])<<16);
+			 b+=k[2]+(((uint32_t)k[3])<<16);
+			 a+=k[0]+(((uint32_t)k[1])<<16);
+			 break;
+		case 11: c+=((uint32_t)k8[10])<<16;     /* fall through */
+		case 10: c+=k[4];
+			 b+=k[2]+(((uint32_t)k[3])<<16);
+			 a+=k[0]+(((uint32_t)k[1])<<16);
+			 break;
+		case 9 : c+=k8[8];                      /* fall through */
+		case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
+			 a+=k[0]+(((uint32_t)k[1])<<16);
+			 break;
+		case 7 : b+=((uint32_t)k8[6])<<16;      /* fall through */
+		case 6 : b+=k[2];
+			 a+=k[0]+(((uint32_t)k[1])<<16);
+			 break;
+		case 5 : b+=k8[4];                      /* fall through */
+		case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
+			 break;
+		case 3 : a+=((uint32_t)k8[2])<<16;      /* fall through */
+		case 2 : a+=k[0];
+			 break;
+		case 1 : a+=k8[0];
+			 break;
+		case 0 : return c;                     /* zero length requires no mixing */
+		}
 
-  } else {                        /* need to read the key one byte at a time */
-    const uint8_t *k = (const uint8_t *)key;
+	}
+	else
+	{
+		/* need to read the key one byte at a time */
+		const uint8_t *k = (const uint8_t *)key;
 
-    /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
-    while (length > 12)
-    {
-      a += k[0];
-      a += ((uint32_t)k[1])<<8;
-      a += ((uint32_t)k[2])<<16;
-      a += ((uint32_t)k[3])<<24;
-      b += k[4];
-      b += ((uint32_t)k[5])<<8;
-      b += ((uint32_t)k[6])<<16;
-      b += ((uint32_t)k[7])<<24;
-      c += k[8];
-      c += ((uint32_t)k[9])<<8;
-      c += ((uint32_t)k[10])<<16;
-      c += ((uint32_t)k[11])<<24;
-      mix(a,b,c);
-      length -= 12;
-      k += 12;
-    }
+		/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
+		while (length > 12)
+		{
+			a += k[0];
+			a += ((uint32_t)k[1])<<8;
+			a += ((uint32_t)k[2])<<16;
+			a += ((uint32_t)k[3])<<24;
+			b += k[4];
+			b += ((uint32_t)k[5])<<8;
+			b += ((uint32_t)k[6])<<16;
+			b += ((uint32_t)k[7])<<24;
+			c += k[8];
+			c += ((uint32_t)k[9])<<8;
+			c += ((uint32_t)k[10])<<16;
+			c += ((uint32_t)k[11])<<24;
+			mix(a,b,c);
+			length -= 12;
+			k += 12;
+		}
 
-    /*-------------------------------- last block: affect all 32 bits of (c) */
-    switch(length)                   /* all the case statements fall through */
-    {
-    case 12: c+=((uint32_t)k[11])<<24; /* FALLTHRU */
-    case 11: c+=((uint32_t)k[10])<<16; /* FALLTHRU */
-    case 10: c+=((uint32_t)k[9])<<8; /* FALLTHRU */
-    case 9 : c+=k[8]; /* FALLTHRU */
-    case 8 : b+=((uint32_t)k[7])<<24; /* FALLTHRU */
-    case 7 : b+=((uint32_t)k[6])<<16; /* FALLTHRU */
-    case 6 : b+=((uint32_t)k[5])<<8; /* FALLTHRU */
-    case 5 : b+=k[4]; /* FALLTHRU */
-    case 4 : a+=((uint32_t)k[3])<<24; /* FALLTHRU */
-    case 3 : a+=((uint32_t)k[2])<<16; /* FALLTHRU */
-    case 2 : a+=((uint32_t)k[1])<<8; /* FALLTHRU */
-    case 1 : a+=k[0];
-             break;
-    case 0 : return c;
-    }
-  }
+		/*-------------------------------- last block: affect all 32 bits of (c) */
+		switch(length) /* all the case statements fall through */
+		{
+		case 12: c+=((uint32_t)k[11])<<24; /* FALLTHRU */
+		case 11: c+=((uint32_t)k[10])<<16; /* FALLTHRU */
+		case 10: c+=((uint32_t)k[9])<<8; /* FALLTHRU */
+		case 9 : c+=k[8]; /* FALLTHRU */
+		case 8 : b+=((uint32_t)k[7])<<24; /* FALLTHRU */
+		case 7 : b+=((uint32_t)k[6])<<16; /* FALLTHRU */
+		case 6 : b+=((uint32_t)k[5])<<8; /* FALLTHRU */
+		case 5 : b+=k[4]; /* FALLTHRU */
+		case 4 : a+=((uint32_t)k[3])<<24; /* FALLTHRU */
+		case 3 : a+=((uint32_t)k[2])<<16; /* FALLTHRU */
+		case 2 : a+=((uint32_t)k[1])<<8; /* FALLTHRU */
+		case 1 : a+=k[0];
+			 break;
+		case 0 : return c;
+		}
+	}
 
-  final(a,b,c);
-  return c;
+	final(a,b,c);
+	return c;
 }
+/* clang-format on */
 
 /* a simple hash function similiar to what perl does for strings.
  * for good results, the string should not be excessivly large.
  */
-static unsigned long lh_perllike_str_hash(const void *k) 
+static unsigned long lh_perllike_str_hash(const void *k)
 {
-    const char *rkey = (const char *)k;
-    unsigned hashval = 1;
+	const char *rkey = (const char *)k;
+	unsigned hashval = 1;
 
-    while (*rkey)
-        hashval = hashval * 33 + *rkey++;
+	while (*rkey)
+		hashval = hashval * 33 + *rkey++;
 
-    return hashval;
+	return hashval;
 }
 
 static unsigned long lh_char_hash(const void *k)
@@ -459,10 +462,11 @@ static unsigned long lh_char_hash(const void *k)
 #endif
 	static volatile RANDOM_SEED_TYPE random_seed = -1;
 
-	if (random_seed == -1) {
+	if (random_seed == -1)
+	{
 		RANDOM_SEED_TYPE seed;
 		/* we can't use -1 as it is the unitialized sentinel */
-		while ((seed = json_c_get_random_seed()) == -1);
+		while ((seed = json_c_get_random_seed()) == -1) {}
 #if SIZEOF_INT == 8 && defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
 #define USE_SYNC_COMPARE_AND_SWAP 1
 #endif
@@ -477,34 +481,34 @@ static unsigned long lh_char_hash(const void *k)
 #elif defined _MSC_VER || defined __MINGW32__
 		InterlockedCompareExchange(&random_seed, seed, -1);
 #else
-//#warning "racy random seed initializtion if used by multiple threads"
+		//#warning "racy random seed initializtion if used by multiple threads"
 		random_seed = seed; /* potentially racy */
 #endif
 	}
 
-	return hashlittle((const char*)k, strlen((const char*)k), random_seed);
+	return hashlittle((const char *)k, strlen((const char *)k), random_seed);
 }
 
 int lh_char_equal(const void *k1, const void *k2)
 {
-	return (strcmp((const char*)k1, (const char*)k2) == 0);
+	return (strcmp((const char *)k1, (const char *)k2) == 0);
 }
 
-struct lh_table* lh_table_new(int size,
-			      lh_entry_free_fn *free_fn,
-			      lh_hash_fn *hash_fn,
-			      lh_equal_fn *equal_fn)
+struct lh_table *lh_table_new(int size, lh_entry_free_fn *free_fn, lh_hash_fn *hash_fn,
+                              lh_equal_fn *equal_fn)
 {
 	int i;
 	struct lh_table *t;
 
-	t = (struct lh_table*)calloc(1, sizeof(struct lh_table));
+	/* Allocate space for elements to avoid divisions by zero. */
+	assert(size > 0);
+	t = (struct lh_table *)calloc(1, sizeof(struct lh_table));
 	if (!t)
 		return NULL;
 
 	t->count = 0;
 	t->size = size;
-	t->table = (struct lh_entry*)calloc(size, sizeof(struct lh_entry));
+	t->table = (struct lh_entry *)calloc(size, sizeof(struct lh_entry));
 	if (!t->table)
 	{
 		free(t);
@@ -513,18 +517,17 @@ struct lh_table* lh_table_new(int size,
 	t->free_fn = free_fn;
 	t->hash_fn = hash_fn;
 	t->equal_fn = equal_fn;
-	for(i = 0; i < size; i++) t->table[i].k = LH_EMPTY;
+	for (i = 0; i < size; i++)
+		t->table[i].k = LH_EMPTY;
 	return t;
 }
 
-struct lh_table* lh_kchar_table_new(int size,
-				    lh_entry_free_fn *free_fn)
+struct lh_table *lh_kchar_table_new(int size, lh_entry_free_fn *free_fn)
 {
 	return lh_table_new(size, free_fn, char_hash_fn, lh_char_equal);
 }
 
-struct lh_table* lh_kptr_table_new(int size,
-				   lh_entry_free_fn *free_fn)
+struct lh_table *lh_kptr_table_new(int size, lh_entry_free_fn *free_fn)
 {
 	return lh_table_new(size, free_fn, lh_ptr_hash, lh_ptr_equal);
 }
@@ -563,28 +566,36 @@ int lh_table_resize(struct lh_table *t, int new_size)
 void lh_table_free(struct lh_table *t)
 {
 	struct lh_entry *c;
-	if(t->free_fn) {
-		for(c = t->head; c != NULL; c = c->next)
+	if (t->free_fn)
+	{
+		for (c = t->head; c != NULL; c = c->next)
 			t->free_fn(c);
 	}
 	free(t->table);
 	free(t);
 }
 
-
-int lh_table_insert_w_hash(struct lh_table *t, const void *k, const void *v, const unsigned long h, const unsigned opts)
+int lh_table_insert_w_hash(struct lh_table *t, const void *k, const void *v, const unsigned long h,
+                           const unsigned opts)
 {
 	unsigned long n;
 
 	if (t->count >= t->size * LH_LOAD_FACTOR)
-		if (lh_table_resize(t, t->size * 2) != 0)
+	{
+		/* Avoid signed integer overflow with large tables. */
+		int new_size = (t->size > INT_MAX / 2) ? INT_MAX : (t->size * 2);
+		if (t->size == INT_MAX || lh_table_resize(t, new_size) != 0)
 			return -1;
+	}
 
 	n = h % t->size;
 
-	while( 1 ) {
-		if(t->table[n].k == LH_EMPTY || t->table[n].k == LH_FREED) break;
-		if ((int)++n == t->size) n = 0;
+	while (1)
+	{
+		if (t->table[n].k == LH_EMPTY || t->table[n].k == LH_FREED)
+			break;
+		if ((int)++n == t->size)
+			n = 0;
 	}
 
 	t->table[n].k = k;
@@ -592,10 +603,13 @@ int lh_table_insert_w_hash(struct lh_table *t, const void *k, const void *v, con
 	t->table[n].v = v;
 	t->count++;
 
-	if(t->head == NULL) {
+	if (t->head == NULL)
+	{
 		t->head = t->tail = &t->table[n];
 		t->table[n].next = t->table[n].prev = NULL;
-	} else {
+	}
+	else
+	{
 		t->tail->next = &t->table[n];
 		t->table[n].prev = t->tail;
 		t->table[n].next = NULL;
@@ -609,66 +623,78 @@ int lh_table_insert(struct lh_table *t, const void *k, const void *v)
 	return lh_table_insert_w_hash(t, k, v, lh_get_hash(t, k), 0);
 }
 
-
-struct lh_entry* lh_table_lookup_entry_w_hash(struct lh_table *t, const void *k, const unsigned long h)
+struct lh_entry *lh_table_lookup_entry_w_hash(struct lh_table *t, const void *k,
+                                              const unsigned long h)
 {
 	unsigned long n = h % t->size;
 	int count = 0;
 
-	while( count < t->size ) {
-		if(t->table[n].k == LH_EMPTY) return NULL;
-		if(t->table[n].k != LH_FREED &&
-		   t->equal_fn(t->table[n].k, k)) return &t->table[n];
-		if ((int)++n == t->size) n = 0;
+	while (count < t->size)
+	{
+		if (t->table[n].k == LH_EMPTY)
+			return NULL;
+		if (t->table[n].k != LH_FREED && t->equal_fn(t->table[n].k, k))
+			return &t->table[n];
+		if ((int)++n == t->size)
+			n = 0;
 		count++;
 	}
 	return NULL;
 }
 
-struct lh_entry* lh_table_lookup_entry(struct lh_table *t, const void *k)
+struct lh_entry *lh_table_lookup_entry(struct lh_table *t, const void *k)
 {
 	return lh_table_lookup_entry_w_hash(t, k, lh_get_hash(t, k));
 }
 
-const void* lh_table_lookup(struct lh_table *t, const void *k)
-{
-	void *result;
-	lh_table_lookup_ex(t, k, &result);
-	return result;
-}
-
-json_bool lh_table_lookup_ex(struct lh_table* t, const void* k, void **v)
+json_bool lh_table_lookup_ex(struct lh_table *t, const void *k, void **v)
 {
 	struct lh_entry *e = lh_table_lookup_entry(t, k);
-	if (e != NULL) {
-		if (v != NULL) *v = lh_entry_v(e);
-		return TRUE; /* key found */
+	if (e != NULL)
+	{
+		if (v != NULL)
+			*v = lh_entry_v(e);
+		return 1; /* key found */
 	}
-	if (v != NULL) *v = NULL;
-		return FALSE; /* key not found */
+	if (v != NULL)
+		*v = NULL;
+	return 0; /* key not found */
 }
 
 int lh_table_delete_entry(struct lh_table *t, struct lh_entry *e)
 {
-	ptrdiff_t n = (ptrdiff_t)(e - t->table); /* CAW: fixed to be 64bit nice, still need the crazy negative case... */
+	/* CAW: fixed to be 64bit nice, still need the crazy negative case... */
+	ptrdiff_t n = (ptrdiff_t)(e - t->table);
 
 	/* CAW: this is bad, really bad, maybe stack goes other direction on this machine... */
-	if(n < 0) { return -2; }
+	if (n < 0)
+	{
+		return -2;
+	}
 
-	if(t->table[n].k == LH_EMPTY || t->table[n].k == LH_FREED) return -1;
+	if (t->table[n].k == LH_EMPTY || t->table[n].k == LH_FREED)
+		return -1;
 	t->count--;
-	if(t->free_fn) t->free_fn(e);
+	if (t->free_fn)
+		t->free_fn(e);
 	t->table[n].v = NULL;
 	t->table[n].k = LH_FREED;
-	if(t->tail == &t->table[n] && t->head == &t->table[n]) {
+	if (t->tail == &t->table[n] && t->head == &t->table[n])
+	{
 		t->head = t->tail = NULL;
-	} else if (t->head == &t->table[n]) {
+	}
+	else if (t->head == &t->table[n])
+	{
 		t->head->next->prev = NULL;
 		t->head = t->head->next;
-	} else if (t->tail == &t->table[n]) {
+	}
+	else if (t->tail == &t->table[n])
+	{
 		t->tail->prev->next = NULL;
 		t->tail = t->tail->prev;
-	} else {
+	}
+	else
+	{
 		t->table[n].prev->next = t->table[n].next;
 		t->table[n].next->prev = t->table[n].prev;
 	}
@@ -676,11 +702,11 @@ int lh_table_delete_entry(struct lh_table *t, struct lh_entry *e)
 	return 0;
 }
 
-
 int lh_table_delete(struct lh_table *t, const void *k)
 {
 	struct lh_entry *e = lh_table_lookup_entry(t, k);
-	if(!e) return -1;
+	if (!e)
+		return -1;
 	return lh_table_delete_entry(t, e);
 }
 

linkhash.h

@@ -40,12 +40,12 @@ extern "C" {
 /**
  * sentinel pointer value for empty slots
  */
-#define LH_EMPTY (void*)-1
+#define LH_EMPTY (void *)-1
 
 /**
  * sentinel pointer value for freed slots
  */
-#define LH_FREED (void*)-2
+#define LH_FREED (void *)-2
 
 /**
  * default string hash function
@@ -69,20 +69,21 @@ struct lh_entry;
 /**
  * callback function prototypes
  */
-typedef void (lh_entry_free_fn) (struct lh_entry *e);
+typedef void(lh_entry_free_fn)(struct lh_entry *e);
 /**
  * callback function prototypes
  */
-typedef unsigned long (lh_hash_fn) (const void *k);
+typedef unsigned long(lh_hash_fn)(const void *k);
 /**
  * callback function prototypes
  */
-typedef int (lh_equal_fn) (const void *k1, const void *k2);
+typedef int(lh_equal_fn)(const void *k1, const void *k2);
 
 /**
  * An entry in the hash table
  */
-struct lh_entry {
+struct lh_entry
+{
 	/**
 	 * The key.  Use lh_entry_k() instead of accessing this directly.
 	 */
@@ -106,11 +107,11 @@ struct lh_entry {
 	struct lh_entry *prev;
 };
 
-
 /**
  * The hash table structure.
  */
-struct lh_table {
+struct lh_table
+{
 	/**
 	 * Size of our hash.
 	 */
@@ -141,12 +142,10 @@ struct lh_table {
 };
 typedef struct lh_table lh_table;
 
-
 /**
  * Convenience list iterator.
  */
-#define lh_foreach(table, entry) \
-for(entry = table->head; entry; entry = entry->next)
+#define lh_foreach(table, entry) for (entry = table->head; entry; entry = entry->next)
 
 /**
  * lh_foreach_safe allows calling of deletion routine while iterating.
@@ -156,9 +155,7 @@ for(entry = table->head; entry; entry = entry->next)
  * @param tmp a struct lh_entry * variable to hold a temporary pointer to the next element
  */
 #define lh_foreach_safe(table, entry, tmp) \
-for(entry = table->head; entry && ((tmp = entry->next) || 1); entry = tmp)
-
-
+	for (entry = table->head; entry && ((tmp = entry->next) || 1); entry = tmp)
 
 /**
  * Create a new linkhash table.
@@ -178,10 +175,8 @@ for(entry = table->head; entry && ((tmp = entry->next) || 1); entry = tmp)
  * @return On success, a pointer to the new linkhash table is returned.
  * 	On error, a null pointer is returned.
  */
-extern struct lh_table* lh_table_new(int size,
-				     lh_entry_free_fn *free_fn,
-				     lh_hash_fn *hash_fn,
-				     lh_equal_fn *equal_fn);
+extern struct lh_table *lh_table_new(int size, lh_entry_free_fn *free_fn, lh_hash_fn *hash_fn,
+                                     lh_equal_fn *equal_fn);
 
 /**
  * Convenience function to create a new linkhash table with char keys.
@@ -191,9 +186,7 @@ extern struct lh_table* lh_table_new(int size,
  * @return On success, a pointer to the new linkhash table is returned.
  * 	On error, a null pointer is returned.
  */
-extern struct lh_table* lh_kchar_table_new(int size,
-					   lh_entry_free_fn *free_fn);
-
+extern struct lh_table *lh_kchar_table_new(int size, lh_entry_free_fn *free_fn);
 
 /**
  * Convenience function to create a new linkhash table with ptr keys.
@@ -203,9 +196,7 @@ extern struct lh_table* lh_kchar_table_new(int size,
  * @return On success, a pointer to the new linkhash table is returned.
  * 	On error, a null pointer is returned.
  */
-extern struct lh_table* lh_kptr_table_new(int size,
-					  lh_entry_free_fn *free_fn);
-
+extern struct lh_table *lh_kptr_table_new(int size, lh_entry_free_fn *free_fn);
 
 /**
  * Free a linkhash table.
@@ -217,7 +208,6 @@ extern struct lh_table* lh_kptr_table_new(int size,
  */
 extern void lh_table_free(struct lh_table *t);
 
-
 /**
  * Insert a record into the table.
  *
@@ -230,7 +220,6 @@ extern void lh_table_free(struct lh_table *t);
  */
 extern int lh_table_insert(struct lh_table *t, const void *k, const void *v);
 
-
 /**
  * Insert a record into the table using a precalculated key hash.
  *
@@ -245,8 +234,8 @@ extern int lh_table_insert(struct lh_table *t, const void *k, const void *v);
  * @param opts if set to JSON_C_OBJECT_KEY_IS_CONSTANT, sets lh_entry.k_is_constant
  *             so t's free function knows to avoid freeing the key.
  */
-extern int lh_table_insert_w_hash(struct lh_table *t, const void *k, const void *v, const unsigned long h, const unsigned opts);
-
+extern int lh_table_insert_w_hash(struct lh_table *t, const void *k, const void *v,
+                                  const unsigned long h, const unsigned opts);
 
 /**
  * Lookup a record in the table.
@@ -255,7 +244,7 @@ extern int lh_table_insert_w_hash(struct lh_table *t, const void *k, const void
  * @param k a pointer to the key to lookup
  * @return a pointer to the record structure of the value or NULL if it does not exist.
  */
-extern struct lh_entry* lh_table_lookup_entry(struct lh_table *t, const void *k);
+extern struct lh_entry *lh_table_lookup_entry(struct lh_table *t, const void *k);
 
 /**
  * Lookup a record in the table using a precalculated key hash.
@@ -269,17 +258,8 @@ extern struct lh_entry* lh_table_lookup_entry(struct lh_table *t, const void *k)
  * @param h hash value of the key to lookup
  * @return a pointer to the record structure of the value or NULL if it does not exist.
  */
-extern struct lh_entry* lh_table_lookup_entry_w_hash(struct lh_table *t, const void *k, const unsigned long h);
-
-/**
- * Lookup a record into the table.
- *
- * @param t the table to lookup
- * @param k a pointer to the key to lookup
- * @return a pointer to the found value or NULL if it does not exist.
- * @deprecated Use lh_table_lookup_ex() instead.
- */
-THIS_FUNCTION_IS_DEPRECATED(extern const void* lh_table_lookup(struct lh_table *t, const void *k));
+extern struct lh_entry *lh_table_lookup_entry_w_hash(struct lh_table *t, const void *k,
+                                                     const unsigned long h);
 
 /**
  * Lookup a record in the table.
@@ -303,7 +283,6 @@ extern json_bool lh_table_lookup_ex(struct lh_table *t, const void *k, void **v)
  */
 extern int lh_table_delete_entry(struct lh_table *t, struct lh_entry *e);
 
-
 /**
  * Delete a record from the table.
  *
@@ -318,21 +297,6 @@ extern int lh_table_delete(struct lh_table *t, const void *k);
 
 extern int lh_table_length(struct lh_table *t);
 
-/**
- * Prints a message to <code>stdout</code>,
- * then exits the program with an exit code of <code>1</code>.
- *
- * @param msg Message format string, like for <code>printf</code>.
- * @param ... Format args.
- *
- * @deprecated Since it is not a good idea to exit the entire program
- * 	because of an internal library failure, json-c will no longer
- * 	use this function internally.
- * 	However, because its interface is public, it will remain part of
- * 	the API on the off chance of legacy software using it externally.
- */
-THIS_FUNCTION_IS_DEPRECATED(void lh_abort(const char *msg, ...));
-
 /**
  * Resizes the specified table.
  *
@@ -344,7 +308,6 @@ THIS_FUNCTION_IS_DEPRECATED(void lh_abort(const char *msg, ...));
  */
 int lh_table_resize(struct lh_table *t, int new_size);
 
-
 /**
  * @deprecated Don't use this outside of linkhash.h:
  */

math_compat.h

@@ -9,17 +9,24 @@
 /* Define isnan, isinf, infinity and nan on Windows/MSVC */
 
 #ifndef HAVE_DECL_ISNAN
-# ifdef HAVE_DECL__ISNAN
+#ifdef HAVE_DECL__ISNAN
 #include <float.h>
 #define isnan(x) _isnan(x)
-# endif
+#else
+/* On platforms like AIX and "IBM i" we need to provide our own isnan */
+#define isnan(x) ((x) != (x))
+#endif
 #endif
 
 #ifndef HAVE_DECL_ISINF
-# ifdef HAVE_DECL__FINITE
+#ifdef HAVE_DECL__FINITE
 #include <float.h>
 #define isinf(x) (!_finite(x))
-# endif
+#else
+#include <float.h>
+/* On platforms like AIX and "IBM i" we need to provide our own isinf */
+#define isinf(x) ((x) < -DBL_MAX || (x) > DBL_MAX)
+#endif
 #endif
 
 #ifndef HAVE_DECL_INFINITY

printbuf.c

@@ -15,14 +15,15 @@
 
 #include "config.h"
 
+#include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #ifdef HAVE_STDARG_H
-# include <stdarg.h>
+#include <stdarg.h>
 #else /* !HAVE_STDARG_H */
-# error Not enough var arg support!
+#error Not enough var arg support!
 #endif /* HAVE_STDARG_H */
 
 #include "debug.h"
@@ -32,23 +33,24 @@
 
 static int printbuf_extend(struct printbuf *p, int min_size);
 
-struct printbuf* printbuf_new(void)
+struct printbuf *printbuf_new(void)
 {
-  struct printbuf *p;
+	struct printbuf *p;
 
-  p = (struct printbuf*)calloc(1, sizeof(struct printbuf));
-  if(!p) return NULL;
-  p->size = 32;
-  p->bpos = 0;
-  if(!(p->buf = (char*)malloc(p->size))) {
-    free(p);
-    return NULL;
-  }
-  p->buf[0]= '\0';
-  return p;
+	p = (struct printbuf *)calloc(1, sizeof(struct printbuf));
+	if (!p)
+		return NULL;
+	p->size = 32;
+	p->bpos = 0;
+	if (!(p->buf = (char *)malloc(p->size)))
+	{
+		free(p);
+		return NULL;
+	}
+	p->buf[0] = '\0';
+	return p;
 }
 
-
 /**
  * Extend the buffer p so it has a size of at least min_size.
  *
@@ -64,16 +66,22 @@ static int printbuf_extend(struct printbuf *p, int min_size)
 
 	if (p->size >= min_size)
 		return 0;
-
-	new_size = p->size * 2;
-	if (new_size < min_size + 8)
-		new_size =  min_size + 8;
+	/* Prevent signed integer overflows with large buffers. */
+	if (min_size > INT_MAX - 8)
+		return -1;
+	if (p->size > INT_MAX / 2)
+		new_size = min_size + 8;
+	else {
+		new_size = p->size * 2;
+		if (new_size < min_size + 8)
+			new_size = min_size + 8;
+	}
 #ifdef PRINTBUF_DEBUG
 	MC_DEBUG("printbuf_memappend: realloc "
-	  "bpos=%d min_size=%d old_size=%d new_size=%d\n",
-	  p->bpos, min_size, p->size, new_size);
+	         "bpos=%d min_size=%d old_size=%d new_size=%d\n",
+	         p->bpos, min_size, p->size, new_size);
 #endif /* PRINTBUF_DEBUG */
-	if(!(t = (char*)realloc(p->buf, new_size)))
+	if (!(t = (char *)realloc(p->buf, new_size)))
 		return -1;
 	p->size = new_size;
 	p->buf = t;
@@ -82,14 +90,18 @@ static int printbuf_extend(struct printbuf *p, int min_size)
 
 int printbuf_memappend(struct printbuf *p, const char *buf, int size)
 {
-  if (p->size <= p->bpos + size + 1) {
-    if (printbuf_extend(p, p->bpos + size + 1) < 0)
-      return -1;
-  }
-  memcpy(p->buf + p->bpos, buf, size);
-  p->bpos += size;
-  p->buf[p->bpos]= '\0';
-  return size;
+	/* Prevent signed integer overflows with large buffers. */
+	if (size > INT_MAX - p->bpos - 1)
+		return -1;
+	if (p->size <= p->bpos + size + 1)
+	{
+		if (printbuf_extend(p, p->bpos + size + 1) < 0)
+			return -1;
+	}
+	memcpy(p->buf + p->bpos, buf, size);
+	p->bpos += size;
+	p->buf[p->bpos] = '\0';
+	return size;
 }
 
 int printbuf_memset(struct printbuf *pb, int offset, int charvalue, int len)
@@ -98,6 +110,9 @@ int printbuf_memset(struct printbuf *pb, int offset, int charvalue, int len)
 
 	if (offset == -1)
 		offset = pb->bpos;
+	/* Prevent signed integer overflows with large buffers. */
+	if (len > INT_MAX - offset)
+		return -1;
 	size_needed = offset + len;
 	if (pb->size < size_needed)
 	{
@@ -114,42 +129,51 @@ int printbuf_memset(struct printbuf *pb, int offset, int charvalue, int len)
 
 int sprintbuf(struct printbuf *p, const char *msg, ...)
 {
-  va_list ap;
-  char *t;
-  int size;
-  char buf[128];
+	va_list ap;
+	char *t;
+	int size;
+	char buf[128];
 
-  /* user stack buffer first */
-  va_start(ap, msg);
-  size = vsnprintf(buf, 128, msg, ap);
-  va_end(ap);
-  /* if string is greater than stack buffer, then use dynamic string
-     with vasprintf.  Note: some implementation of vsnprintf return -1
-     if output is truncated whereas some return the number of bytes that
-     would have been written - this code handles both cases. */
-  if(size == -1 || size > 127) {
-    va_start(ap, msg);
-    if((size = vasprintf(&t, msg, ap)) < 0) { va_end(ap); return -1; }
-    va_end(ap);
-    printbuf_memappend(p, t, size);
-    free(t);
-    return size;
-  } else {
-    printbuf_memappend(p, buf, size);
-    return size;
-  }
+	/* user stack buffer first */
+	va_start(ap, msg);
+	size = vsnprintf(buf, 128, msg, ap);
+	va_end(ap);
+	/* if string is greater than stack buffer, then use dynamic string
+	 * with vasprintf.  Note: some implementation of vsnprintf return -1
+	 * if output is truncated whereas some return the number of bytes that
+	 * would have been written - this code handles both cases.
+	 */
+	if (size == -1 || size > 127)
+	{
+		va_start(ap, msg);
+		if ((size = vasprintf(&t, msg, ap)) < 0)
+		{
+			va_end(ap);
+			return -1;
+		}
+		va_end(ap);
+		printbuf_memappend(p, t, size);
+		free(t);
+		return size;
+	}
+	else
+	{
+		printbuf_memappend(p, buf, size);
+		return size;
+	}
 }
 
 void printbuf_reset(struct printbuf *p)
 {
-  p->buf[0] = '\0';
-  p->bpos = 0;
+	p->buf[0] = '\0';
+	p->bpos = 0;
 }
 
 void printbuf_free(struct printbuf *p)
 {
-  if(p) {
-    free(p->buf);
-    free(p);
-  }
+	if (p)
+	{
+		free(p->buf);
+		free(p);
+	}
 }

printbuf.h

@@ -15,7 +15,7 @@
 
 /**
  * @file
- * @brief Internal string buffer handing.  Unless you're writing a 
+ * @brief Internal string buffer handing.  Unless you're writing a
  *        json_object_to_json_string_fn implementation for use with
  *        json_object_set_serializer() direct use of this is not
  *        recommended.
@@ -23,19 +23,27 @@
 #ifndef _printbuf_h_
 #define _printbuf_h_
 
+#ifndef JSON_EXPORT
+#if defined(_MSC_VER)
+#define JSON_EXPORT __declspec(dllexport)
+#else
+#define JSON_EXPORT extern
+#endif
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-struct printbuf {
-  char *buf;
-  int bpos;
-  int size;
+struct printbuf
+{
+	char *buf;
+	int bpos;
+	int size;
 };
 typedef struct printbuf printbuf;
 
-extern struct printbuf*
-printbuf_new(void);
+JSON_EXPORT struct printbuf *printbuf_new(void);
 
 /* As an optimization, printbuf_memappend_fast() is defined as a macro
  * that handles copying data if the buffer is large enough; otherwise
@@ -45,17 +53,22 @@ printbuf_new(void);
  * Your code should not use printbuf_memappend() directly unless it
  * checks the return code. Use printbuf_memappend_fast() instead.
  */
-extern int
-printbuf_memappend(struct printbuf *p, const char *buf, int size);
+JSON_EXPORT int printbuf_memappend(struct printbuf *p, const char *buf, int size);
 
-#define printbuf_memappend_fast(p, bufptr, bufsize)          \
-do {                                                         \
-  if ((p->size - p->bpos) > bufsize) {                       \
-    memcpy(p->buf + p->bpos, (bufptr), bufsize);             \
-    p->bpos += bufsize;                                      \
-    p->buf[p->bpos]= '\0';                                   \
-  } else {  printbuf_memappend(p, (bufptr), bufsize); }      \
-} while (0)
+#define printbuf_memappend_fast(p, bufptr, bufsize)                  \
+	do                                                           \
+	{                                                            \
+		if ((p->size - p->bpos) > bufsize)                   \
+		{                                                    \
+			memcpy(p->buf + p->bpos, (bufptr), bufsize); \
+			p->bpos += bufsize;                          \
+			p->buf[p->bpos] = '\0';                      \
+		}                                                    \
+		else                                                 \
+		{                                                    \
+			printbuf_memappend(p, (bufptr), bufsize);    \
+		}                                                    \
+	} while (0)
 
 #define printbuf_length(p) ((p)->bpos)
 
@@ -79,7 +92,7 @@ do {                                                         \
  *   sprintbuf()
  */
 #define printbuf_strappend(pb, str) \
-   printbuf_memappend ((pb), _printbuf_check_literal(str), sizeof(str) - 1)
+	printbuf_memappend((pb), _printbuf_check_literal(str), sizeof(str) - 1)
 
 /**
  * Set len bytes of the buffer to charvalue, starting at offset offset.
@@ -89,8 +102,7 @@ do {                                                         \
  *
  * If offset is -1, this starts at the end of the current data in the buffer.
  */
-extern int
-printbuf_memset(struct printbuf *pb, int offset, int charvalue, int len);
+JSON_EXPORT int printbuf_memset(struct printbuf *pb, int offset, int charvalue, int len);
 
 /**
  * Formatted print to printbuf.
@@ -106,14 +118,11 @@ printbuf_memset(struct printbuf *pb, int offset, int charvalue, int len);
  *   printbuf_memappend()
  *   printbuf_strappend()
  */
-extern int
-sprintbuf(struct printbuf *p, const char *msg, ...);
+JSON_EXPORT int sprintbuf(struct printbuf *p, const char *msg, ...);
 
-extern void
-printbuf_reset(struct printbuf *p);
+JSON_EXPORT void printbuf_reset(struct printbuf *p);
 
-extern void
-printbuf_free(struct printbuf *p);
+JSON_EXPORT void printbuf_free(struct printbuf *p);
 
 #ifdef __cplusplus
 }

random_seed.c

@@ -9,14 +9,13 @@
  *
  */
 
+#include "random_seed.h"
+#include "config.h"
 #include "strerror_override.h"
 #include <stdio.h>
-#include "config.h"
-#include "random_seed.h"
 
 #define DEBUG_SEED(s)
 
-
 #if defined ENABLE_RDRAND
 
 /* cpuid */
@@ -26,20 +25,11 @@
 
 static void do_cpuid(int regs[], int h)
 {
-    __asm__ __volatile__(
-#if defined __x86_64__
-                         "pushq %%rbx;\n"
-#else
-                         "pushl %%ebx;\n"
-#endif
-                         "cpuid;\n"
-#if defined __x86_64__
-                         "popq %%rbx;\n"
-#else
-                         "popl %%ebx;\n"
-#endif
-                         : "=a"(regs[0]), [ebx] "=r"(regs[1]), "=c"(regs[2]), "=d"(regs[3])
+	/* clang-format off */
+    __asm__ __volatile__("cpuid"
+                         : "=a"(regs[0]), "=b"(regs[1]), "=c"(regs[2]), "=d"(regs[3])
                          : "a"(h));
+	/* clang-format on */
 }
 
 #elif defined _MSC_VER
@@ -53,12 +43,51 @@ static void do_cpuid(int regs[], int h)
 
 #if HAS_X86_CPUID
 
-static int has_rdrand()
+static int get_rdrand_seed(void);
+
+/* Valid values are -1 (haven't tested), 0 (no), and 1 (yes). */
+static int _has_rdrand = -1;
+
+static int has_rdrand(void)
 {
-    // CPUID.01H:ECX.RDRAND[bit 30] == 1
-    int regs[4];
-    do_cpuid(regs, 1);
-    return (regs[2] & (1 << 30)) != 0;
+	if (_has_rdrand != -1)
+	{
+		return _has_rdrand;
+	}
+
+	/* CPUID.01H:ECX.RDRAND[bit 30] == 1 */
+	int regs[4];
+	do_cpuid(regs, 1);
+	if (!(regs[2] & (1 << 30)))
+	{
+		_has_rdrand = 0;
+		return 0;
+	}
+
+	/*
+	 * Some CPUs advertise RDRAND in CPUID, but return 0xFFFFFFFF
+	 * unconditionally. To avoid locking up later, test RDRAND here. If over
+	 * 3 trials RDRAND has returned the same value, declare it broken.
+	 * Example CPUs are AMD Ryzen 3000 series
+	 * and much older AMD APUs, such as the E1-1500
+	 * https://github.com/systemd/systemd/issues/11810
+	 * https://linuxreviews.org/RDRAND_stops_returning_random_values_on_older_AMD_CPUs_after_suspend
+	 */
+	_has_rdrand = 0;
+	int prev = get_rdrand_seed();
+	for (int i = 0; i < 3; i++)
+	{
+		int temp = get_rdrand_seed();
+		if (temp != prev)
+		{
+			_has_rdrand = 1;
+			break;
+		}
+
+		prev = temp;
+	}
+
+	return _has_rdrand;
 }
 
 #endif
@@ -69,17 +98,19 @@ static int has_rdrand()
 
 #define HAVE_RDRAND 1
 
-static int get_rdrand_seed()
+static int get_rdrand_seed(void)
 {
-    DEBUG_SEED("get_rdrand_seed");
-    int _eax;
-    // rdrand eax
-    __asm__ __volatile__("1: .byte 0x0F\n"
-                         "   .byte 0xC7\n"
-                         "   .byte 0xF0\n"
-                         "   jnc 1b;\n"
-                         : "=a" (_eax));
-    return _eax;
+	DEBUG_SEED("get_rdrand_seed");
+	int _eax;
+	/* rdrand eax */
+	/* clang-format off */
+	__asm__ __volatile__("1: .byte 0x0F\n"
+	                     "   .byte 0xC7\n"
+	                     "   .byte 0xF0\n"
+	                     "   jnc 1b;\n"
+	                     : "=a" (_eax));
+	/* clang-format on */
+	return _eax;
 }
 
 #endif
@@ -91,12 +122,13 @@ static int get_rdrand_seed()
 
 /* get_rdrand_seed - Visual Studio 2012 and above */
 
-static int get_rdrand_seed()
+static int get_rdrand_seed(void)
 {
-    DEBUG_SEED("get_rdrand_seed");
-    int r;
-    while (_rdrand32_step(&r) == 0);
-    return r;
+	DEBUG_SEED("get_rdrand_seed");
+	int r;
+	while (_rdrand32_step(&r) == 0)
+		;
+	return r;
 }
 
 #elif defined _M_IX86
@@ -104,31 +136,34 @@ static int get_rdrand_seed()
 
 /* get_rdrand_seed - Visual Studio 2010 and below - x86 only */
 
-static int get_rdrand_seed()
+/* clang-format off */
+static int get_rdrand_seed(void)
 {
 	DEBUG_SEED("get_rdrand_seed");
 	int _eax;
 retry:
-	// rdrand eax
+	/* rdrand eax */
 	__asm _emit 0x0F __asm _emit 0xC7 __asm _emit 0xF0
 	__asm jnc retry
 	__asm mov _eax, eax
 	return _eax;
 }
+/* clang-format on */
 
 #endif
 #endif
 
 #endif /* defined ENABLE_RDRAND */
 
-
 /* has_dev_urandom */
 
-#if defined (__APPLE__) || defined(__unix__) || defined(__linux__)
+#if defined(__APPLE__) || defined(__unix__) || defined(__linux__)
 
-#include <string.h>
 #include <fcntl.h>
+#include <string.h>
+#if HAVE_UNISTD_H
 #include <unistd.h>
+#endif /* HAVE_UNISTD_H */
 #include <stdlib.h>
 #include <sys/stat.h>
 
@@ -136,103 +171,113 @@ retry:
 
 static const char *dev_random_file = "/dev/urandom";
 
-static int has_dev_urandom()
+static int has_dev_urandom(void)
 {
-    struct stat buf;
-    if (stat(dev_random_file, &buf)) {
-        return 0;
-    }
-    return ((buf.st_mode & S_IFCHR) != 0);
+	struct stat buf;
+	if (stat(dev_random_file, &buf))
+	{
+		return 0;
+	}
+	return ((buf.st_mode & S_IFCHR) != 0);
 }
 
-
 /* get_dev_random_seed */
 
-static int get_dev_random_seed()
+static int get_dev_random_seed(void)
 {
-    DEBUG_SEED("get_dev_random_seed");
+	DEBUG_SEED("get_dev_random_seed");
 
-    int fd = open(dev_random_file, O_RDONLY);
-    if (fd < 0) {
-        fprintf(stderr, "error opening %s: %s", dev_random_file, strerror(errno));
-        exit(1);
-    }
+	int fd = open(dev_random_file, O_RDONLY);
+	if (fd < 0)
+	{
+		fprintf(stderr, "error opening %s: %s", dev_random_file, strerror(errno));
+		exit(1);
+	}
 
-    int r;
-    ssize_t nread = read(fd, &r, sizeof(r));
-    if (nread != sizeof(r)) {
-        fprintf(stderr, "error short read %s: %s", dev_random_file, strerror(errno));
-        exit(1);
-    }
+	int r;
+	ssize_t nread = read(fd, &r, sizeof(r));
+	if (nread != sizeof(r))
+	{
+		fprintf(stderr, "error short read %s: %s", dev_random_file, strerror(errno));
+		exit(1);
+	}
 
-    close(fd);
-    return r;
+	close(fd);
+	return r;
 }
 
 #endif
 
-
 /* get_cryptgenrandom_seed */
 
 #ifdef WIN32
 
 #define HAVE_CRYPTGENRANDOM 1
 
+/* clang-format off */
 #include <windows.h>
+
+/* Caution: these blank lines must remain so clang-format doesn't reorder
+   includes to put windows.h after wincrypt.h */
+
 #include <wincrypt.h>
+/* clang-format on */
 #ifndef __GNUC__
 #pragma comment(lib, "advapi32.lib")
 #endif
 
-static int get_cryptgenrandom_seed()
+static int get_cryptgenrandom_seed(void)
 {
-    HCRYPTPROV hProvider = 0;
-    int r;
+	HCRYPTPROV hProvider = 0;
+	int r;
 
-    DEBUG_SEED("get_cryptgenrandom_seed");
+	DEBUG_SEED("get_cryptgenrandom_seed");
 
-    if (!CryptAcquireContextW(&hProvider, 0, 0, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
-        fprintf(stderr, "error CryptAcquireContextW");
-        exit(1);
-    }
+	if (!CryptAcquireContextW(&hProvider, 0, 0, PROV_RSA_FULL,
+	                          CRYPT_VERIFYCONTEXT | CRYPT_SILENT))
+	{
+		fprintf(stderr, "error CryptAcquireContextW");
+		exit(1);
+	}
 
-    if (!CryptGenRandom(hProvider, sizeof(r), (BYTE*)&r)) {
-        fprintf(stderr, "error CryptGenRandom");
-        exit(1);
-    }
+	if (!CryptGenRandom(hProvider, sizeof(r), (BYTE *)&r))
+	{
+		fprintf(stderr, "error CryptGenRandom");
+		exit(1);
+	}
 
-    CryptReleaseContext(hProvider, 0);
+	CryptReleaseContext(hProvider, 0);
 
-    return r;
+	return r;
 }
 
 #endif
 
-
 /* get_time_seed */
 
 #include <time.h>
 
-static int get_time_seed()
+static int get_time_seed(void)
 {
-    DEBUG_SEED("get_time_seed");
+	DEBUG_SEED("get_time_seed");
 
-    return (int)time(NULL) * 433494437;
+	return (int)time(NULL) * 433494437;
 }
 
-
 /* json_c_get_random_seed */
 
-int json_c_get_random_seed()
+int json_c_get_random_seed(void)
 {
-#if HAVE_RDRAND
-    if (has_rdrand()) return get_rdrand_seed();
+#if defined HAVE_RDRAND && HAVE_RDRAND
+	if (has_rdrand())
+		return get_rdrand_seed();
 #endif
-#if HAVE_DEV_RANDOM
-    if (has_dev_urandom()) return get_dev_random_seed();
+#if defined HAVE_DEV_RANDOM && HAVE_DEV_RANDOM
+	if (has_dev_urandom())
+		return get_dev_random_seed();
 #endif
-#if HAVE_CRYPTGENRANDOM
-    return get_cryptgenrandom_seed();
+#if defined HAVE_CRYPTGENRANDOM && HAVE_CRYPTGENRANDOM
+	return get_cryptgenrandom_seed();
 #endif
-    return get_time_seed();
+	return get_time_seed();
 }

random_seed.h

@@ -20,7 +20,7 @@
 extern "C" {
 #endif
 
-extern int json_c_get_random_seed();
+extern int json_c_get_random_seed(void);
 
 #ifdef __cplusplus
 }

snprintf_compat.h

@@ -13,7 +13,7 @@
 
 #include <stdarg.h>
 
-#if !defined(HAVE_SNPRINTF) && defined(_MSC_VER)
+#if !defined(HAVE_SNPRINTF) && (defined(_MSC_VER) || defined(__MINGW32__))
 static int json_c_vsnprintf(char *str, size_t size, const char *format, va_list ap)
 {
 	int ret;
@@ -35,7 +35,7 @@ static int json_c_snprintf(char *str, size_t size, const char *format, ...)
 #define snprintf json_c_snprintf
 
 #elif !defined(HAVE_SNPRINTF) /* !HAVE_SNPRINTF */
-# error Need vsnprintf!
+#error Need vsnprintf!
 #endif /* !HAVE_SNPRINTF && defined(WIN32) */
 
 #endif /* __snprintf_compat_h */

strdup_compat.h

@@ -7,10 +7,10 @@
  */
 
 #if !defined(HAVE_STRDUP) && defined(_MSC_VER)
-  /* MSC has the version as _strdup */
-# define strdup _strdup
+/* MSC has the version as _strdup */
+#define strdup _strdup
 #elif !defined(HAVE_STRDUP)
-# error You do not have strdup on your system.
+#error You do not have strdup on your system.
 #endif /* HAVE_STRDUP */
 
 #endif

strerror_override.c

@@ -5,10 +5,12 @@
  * Override strerror() to get consistent output across platforms.
  */
 
-static struct {
+static struct
+{
 	int errno_value;
 	const char *errno_str;
 } errno_list[] = {
+/* clang-format off */
 #define STRINGIFY(x) #x
 #define ENTRY(x) {x, &STRINGIFY(undef_ ## x)[6]}
 	ENTRY(EPERM),
@@ -18,7 +20,9 @@ static struct {
 	ENTRY(EIO),
 	ENTRY(ENXIO),
 	ENTRY(E2BIG),
+#ifdef ENOEXEC
 	ENTRY(ENOEXEC),
+#endif
 	ENTRY(EBADF),
 	ENTRY(ECHILD),
 	ENTRY(EDEADLK),
@@ -52,6 +56,7 @@ static struct {
 	ENTRY(EAGAIN),
 	{ 0, (char *)0 }
 };
+/* clang-format on */
 
 // Enabled during tests
 int _json_c_strerror_enable = 0;
@@ -76,7 +81,8 @@ char *_json_c_strerror(int errno_in)
 		if (errno_list[ii].errno_value != errno_in)
 			continue;
 
-		for (start_idx = sizeof(PREFIX) - 1, jj = 0; errno_str[jj] != '\0'; jj++, start_idx++)
+		for (start_idx = sizeof(PREFIX) - 1, jj = 0; errno_str[jj] != '\0';
+		     jj++, start_idx++)
 		{
 			errno_buf[start_idx] = errno_str[jj];
 		}
@@ -92,10 +98,9 @@ char *_json_c_strerror(int errno_in)
 	digbuf[ii] = "0123456789"[(errno_in % 10)];
 
 	// Reverse the digits
-	for (start_idx = sizeof(PREFIX) - 1 ; ii >= 0; ii--, start_idx++)
+	for (start_idx = sizeof(PREFIX) - 1; ii >= 0; ii--, start_idx++)
 	{
 		errno_buf[start_idx] = digbuf[ii];
 	}
 	return errno_buf;
 }
-

strerror_override.h

@@ -20,11 +20,11 @@ extern "C" {
 JSON_EXPORT char *_json_c_strerror(int errno_in);
 
 #ifndef STRERROR_OVERRIDE_IMPL
-#define strerror	_json_c_strerror
+#define strerror _json_c_strerror
 #endif
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* _json_strerror_override_h_ */ 
+#endif /* _json_strerror_override_h_ */

strerror_override_private.h

@@ -6,7 +6,9 @@
  * @brief Do not use, json-c internal, may be changed or removed at any time.
  */
 
+#include "json_types.h"
+
 /* Used by tests to get consistent output */
-extern int _json_c_strerror_enable;
+JSON_EXPORT int _json_c_strerror_enable;
 
 #endif

tests/CMakeLists.txt

@@ -0,0 +1,54 @@
+
+add_executable(test1Formatted test1.c parse_flags.c parse_flags.h)
+target_compile_definitions(test1Formatted PRIVATE TEST_FORMATTED=1)
+target_link_libraries(test1Formatted PRIVATE ${PROJECT_NAME})
+
+add_executable(test2Formatted test2.c parse_flags.c parse_flags.h)
+target_compile_definitions(test2Formatted PRIVATE TEST_FORMATTED=1)
+target_link_libraries(test2Formatted PRIVATE ${PROJECT_NAME})
+
+# https://cmake.org/cmake/help/v3.0/command/add_test.html
+# https://pabloariasal.github.io/2018/02/19/its-time-to-do-cmake-right/
+
+include_directories(PUBLIC ${CMAKE_SOURCE_DIR})
+
+foreach(TESTNAME
+	test1
+	test2
+	test4
+	testReplaceExisting
+	test_cast
+	test_charcase
+	test_compare
+	test_deep_copy
+	test_double_serializer
+	test_float
+	test_int_add
+	test_json_pointer
+	test_locale
+	test_null
+	test_parse
+	test_parse_int64
+	test_printbuf
+	test_set_serializer
+	test_set_value
+	test_util_file
+	test_visit
+	test_object_iterator)
+
+add_executable(${TESTNAME} ${TESTNAME}.c)
+add_test(NAME ${TESTNAME} COMMAND ${PROJECT_SOURCE_DIR}/tests/${TESTNAME}.test)
+
+# XXX using the non-target_ versions of these doesn't work :(
+target_include_directories(
+  ${TESTNAME}
+  PUBLIC
+    ${CMAKE_CURRENT_LIST_DIR}
+  )
+target_link_libraries(
+  ${TESTNAME}
+  PRIVATE
+    ${PROJECT_NAME}
+  )
+
+endforeach(TESTNAME)

tests/Makefile.am

@@ -1,64 +0,0 @@
-
-AM_CPPFLAGS = -I$(top_srcdir) -I$(top_srcdir)/tests
-
-LDADD= $(LIBJSON_LA)
-
-LIBJSON_LA=$(top_builddir)/libjson-c.la
-
-TESTS=
-TESTS+= test_util_file.test
-TESTS+= test_float.test
-TESTS+= test1.test
-TESTS+= test2.test
-TESTS+= test4.test
-TESTS+= testReplaceExisting.test
-TESTS+= test_parse_int64.test
-TESTS+= test_deep_copy.test
-TESTS+= test_null.test
-TESTS+= test_cast.test
-TESTS+= test_double_serializer.test
-TESTS+= test_parse.test
-TESTS+= test_locale.test
-TESTS+= test_charcase.test
-TESTS+= test_printbuf.test
-TESTS+= test_set_serializer.test
-TESTS+= test_compare.test
-TESTS+= test_set_value.test
-TESTS+= test_visit.test
-TESTS+= test_json_pointer.test
-TESTS+= test_int_add.test
-
-check_PROGRAMS=
-check_PROGRAMS += $(TESTS:.test=)
-
-EXTRA_DIST=
-EXTRA_DIST += $(TESTS)
-EXTRA_DIST += $(TESTS:.test=.expected)
-EXTRA_DIST += test-defs.sh
-EXTRA_DIST += valid.json
-
-
-# Note: handled by test1.test
-check_PROGRAMS += test1Formatted
-test1Formatted_SOURCES = test1.c parse_flags.c parse_flags.h
-test1Formatted_CPPFLAGS = $(AM_CPPFLAGS) -DTEST_FORMATTED
-EXTRA_DIST+= test1Formatted_plain.expected
-EXTRA_DIST+= test1Formatted_pretty.expected
-EXTRA_DIST+= test1Formatted_spaced.expected
-
-# Note: handled by test2.test
-check_PROGRAMS += test2Formatted
-test2Formatted_SOURCES = test2.c parse_flags.c parse_flags.h
-test2Formatted_CPPFLAGS = $(AM_CPPFLAGS) -DTEST_FORMATTED
-EXTRA_DIST+= test2Formatted_plain.expected
-EXTRA_DIST+= test2Formatted_pretty.expected
-EXTRA_DIST+= test2Formatted_spaced.expected
-
-test_util_file_SOURCES = test_util_file.c
-
-testsubdir=testSubDir
-TESTS_ENVIRONMENT       = top_builddir=$(top_builddir)
-
-distclean-local:
-	-rm -rf $(testsubdir)
-	-rm -f *.vg.out

tests/parse_flags.c

@@ -7,18 +7,20 @@
 #include "parse_flags.h"
 
 #if !defined(HAVE_STRCASECMP) && defined(_MSC_VER)
-# define strcasecmp _stricmp
+#define strcasecmp _stricmp
 #elif !defined(HAVE_STRCASECMP)
-# error You do not have strcasecmp on your system.
+#error You do not have strcasecmp on your system.
 #endif /* HAVE_STRNCASECMP */
 
-static struct {
+static struct
+{
 	const char *arg;
 	int flag;
 } format_args[] = {
-	{ "plain", JSON_C_TO_STRING_PLAIN },
-	{ "spaced", JSON_C_TO_STRING_SPACED },
-	{ "pretty", JSON_C_TO_STRING_PRETTY },
+    {"plain", JSON_C_TO_STRING_PLAIN},
+    {"spaced", JSON_C_TO_STRING_SPACED},
+    {"pretty", JSON_C_TO_STRING_PRETTY},
+    {"pretty_tab", JSON_C_TO_STRING_PRETTY_TAB},
 };
 
 #ifndef NELEM
@@ -29,7 +31,7 @@ int parse_flags(int argc, char **argv)
 {
 	int arg_idx;
 	int sflags = 0;
-	for (arg_idx = 1; arg_idx < argc ; arg_idx++)
+	for (arg_idx = 1; arg_idx < argc; arg_idx++)
 	{
 		int jj;
 		for (jj = 0; jj < (int)NELEM(format_args); jj++)

tests/test-defs.sh

@@ -1,5 +1,10 @@
 #!/bin/sh
 
+if [ ! -z "$JSONC_TEST_TRACE" ] ; then
+	VERBOSE=1
+	set -x
+	set -v
+fi
 # Make sure srcdir is an absolute path.  Supply the variable
 # if it does not exist.  We want to be able to run the tests
 # stand-alone!!
@@ -85,7 +90,7 @@ run_output_test()
 	fi
 	TEST_COMMAND="$1"
 	shift
-	if [ -z "${TEST_OUTPUT}" ] ; then	
+	if [ -z "${TEST_OUTPUT}" ] ; then
 		TEST_OUTPUT=${TEST_COMMAND}
 	fi
 

tests/test1.c

@@ -1,19 +1,19 @@
+#include <assert.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stddef.h>
 #include <string.h>
-#include <assert.h>
 
 #include "json.h"
 #include "parse_flags.h"
 
-static int sort_fn (const void *j1, const void *j2)
+static int sort_fn(const void *j1, const void *j2)
 {
-	json_object * const *jso1, * const *jso2;
+	json_object *const *jso1, *const *jso2;
 	int i1, i2;
 
-	jso1 = (json_object* const*)j1;
-	jso2 = (json_object* const*)j2;
+	jso1 = (json_object *const *)j1;
+	jso2 = (json_object *const *)j2;
 	if (!*jso1 && !*jso2)
 		return 0;
 	if (!*jso1)
@@ -38,7 +38,8 @@ static const char *to_json_string(json_object *obj, int flags)
 	copy = strdup(result);
 	if (copy == NULL)
 		printf("to_json_string: Allocation failed!\n");
-	else {
+	else
+	{
 		result = json_object_to_json_string_ext(obj, flags);
 		if (length != strlen(result))
 			printf("to_json_string: Length mismatch!\n");
@@ -48,7 +49,7 @@ static const char *to_json_string(json_object *obj, int flags)
 	}
 	return result;
 }
-#define json_object_to_json_string(obj) to_json_string(obj,sflags)
+#define json_object_to_json_string(obj) to_json_string(obj, sflags)
 #else
 /* no special define */
 #endif
@@ -84,7 +85,7 @@ void test_array_del_idx()
 	orig_array_len = json_object_array_length(my_array);
 
 	printf("my_array=\n");
-	for(ii = 0; ii < json_object_array_length(my_array); ii++)
+	for (ii = 0; ii < json_object_array_length(my_array); ii++)
 	{
 		json_object *obj = json_object_array_get_idx(my_array, ii);
 		printf("\t[%d]=%s\n", (int)ii, json_object_to_json_string(obj));
@@ -94,38 +95,38 @@ void test_array_del_idx()
 	for (ii = 0; ii < orig_array_len; ii++)
 	{
 		rc = json_object_array_del_idx(my_array, 0, 1);
-		printf("after del_idx(0,1)=%d, my_array.to_string()=%s\n",
-		       rc, json_object_to_json_string(my_array));
+		printf("after del_idx(0,1)=%d, my_array.to_string()=%s\n", rc,
+		       json_object_to_json_string(my_array));
 	}
 
 	/* One more time, with the empty array: */
 	rc = json_object_array_del_idx(my_array, 0, 1);
-	printf("after del_idx(0,1)=%d, my_array.to_string()=%s\n",
-	       rc, json_object_to_json_string(my_array));
+	printf("after del_idx(0,1)=%d, my_array.to_string()=%s\n", rc,
+	       json_object_to_json_string(my_array));
 
 	json_object_put(my_array);
 
 	/* Delete all array indexes at once */
 	my_array = make_array();
 	rc = json_object_array_del_idx(my_array, 0, orig_array_len);
-	printf("after del_idx(0,%d)=%d, my_array.to_string()=%s\n",
-	       (int)orig_array_len, rc, json_object_to_json_string(my_array));
+	printf("after del_idx(0,%d)=%d, my_array.to_string()=%s\n", (int)orig_array_len, rc,
+	       json_object_to_json_string(my_array));
 
 	json_object_put(my_array);
 
 	/* Delete *more* than all array indexes at once */
 	my_array = make_array();
 	rc = json_object_array_del_idx(my_array, 0, orig_array_len + 1);
-	printf("after del_idx(0,%d)=%d, my_array.to_string()=%s\n",
-	       (int)(orig_array_len + 1), rc, json_object_to_json_string(my_array));
+	printf("after del_idx(0,%d)=%d, my_array.to_string()=%s\n", (int)(orig_array_len + 1), rc,
+	       json_object_to_json_string(my_array));
 
 	json_object_put(my_array);
-	
+
 	/* Delete some array indexes, then add more */
 	my_array = make_array();
 	rc = json_object_array_del_idx(my_array, 0, orig_array_len - 1);
-	printf("after del_idx(0,%d)=%d, my_array.to_string()=%s\n",
-	       (int)(orig_array_len - 1), rc, json_object_to_json_string(my_array));
+	printf("after del_idx(0,%d)=%d, my_array.to_string()=%s\n", (int)(orig_array_len - 1), rc,
+	       json_object_to_json_string(my_array));
 	json_object_array_add(my_array, json_object_new_string("s1"));
 	json_object_array_add(my_array, json_object_new_string("s2"));
 	json_object_array_add(my_array, json_object_new_string("s3"));
@@ -135,9 +136,56 @@ void test_array_del_idx()
 	json_object_put(my_array);
 }
 
+void test_array_list_expand_internal(void);
+void test_array_list_expand_internal()
+{
+	int rc;
+	size_t ii;
+	size_t idx;
+	json_object *my_array;
+#ifdef TEST_FORMATTED
+	int sflags = 0;
+#endif
+
+	my_array = make_array();
+	printf("my_array=\n");
+	for (ii = 0; ii < json_object_array_length(my_array); ii++)
+	{
+		json_object *obj = json_object_array_get_idx(my_array, ii);
+		printf("\t[%d]=%s\n", (int)ii, json_object_to_json_string(obj));
+	}
+	printf("my_array.to_string()=%s\n", json_object_to_json_string(my_array));
+
+	/* Put iNdex < array->size, no expand. */
+	rc = json_object_array_put_idx(my_array, 5, json_object_new_int(6));
+	printf("put_idx(5,6)=%d\n", rc);
+
+	/* array->size < Put Index < array->size * 2 <= SIZE_T_MAX, the size = array->size * 2. */
+	idx = ARRAY_LIST_DEFAULT_SIZE * 2 - 1;
+	rc = json_object_array_put_idx(my_array, idx, json_object_new_int(0));
+	printf("put_idx(%d,0)=%d\n", (int)(idx), rc);
+
+	/* array->size * 2 < Put Index, the size = Put Index. */
+	idx = ARRAY_LIST_DEFAULT_SIZE * 2 * 2 + 1;
+	rc = json_object_array_put_idx(my_array, idx, json_object_new_int(0));
+	printf("put_idx(%d,0)=%d\n", (int)(idx), rc);
+
+	/* SIZE_T_MAX <= Put Index, it will fail and the size will no change. */
+	idx = SIZE_MAX; // SIZE_MAX = SIZE_T_MAX
+	json_object *tmp = json_object_new_int(10);
+	rc = json_object_array_put_idx(my_array, idx, tmp);
+	printf("put_idx(SIZE_T_MAX,0)=%d\n", rc);
+	if (rc == -1)
+	{
+		json_object_put(tmp);
+	}
+
+	json_object_put(my_array);
+}
+
 int main(int argc, char **argv)
 {
-	json_object *my_string, *my_int, *my_object, *my_array;
+	json_object *my_string, *my_int, *my_null, *my_object, *my_array;
 	size_t i;
 #ifdef TEST_FORMATTED
 	int sflags = 0;
@@ -162,13 +210,15 @@ int main(int argc, char **argv)
 	my_string = json_object_new_string("/");
 	printf("my_string=%s\n", json_object_get_string(my_string));
 	printf("my_string.to_string()=%s\n", json_object_to_json_string(my_string));
-	printf("my_string.to_string(NOSLASHESCAPE)=%s\n", json_object_to_json_string_ext(my_string, JSON_C_TO_STRING_NOSLASHESCAPE));
+	printf("my_string.to_string(NOSLASHESCAPE)=%s\n",
+	       json_object_to_json_string_ext(my_string, JSON_C_TO_STRING_NOSLASHESCAPE));
 	json_object_put(my_string);
 
 	my_string = json_object_new_string("/foo/bar/baz");
 	printf("my_string=%s\n", json_object_get_string(my_string));
 	printf("my_string.to_string()=%s\n", json_object_to_json_string(my_string));
-	printf("my_string.to_string(NOSLASHESCAPE)=%s\n", json_object_to_json_string_ext(my_string, JSON_C_TO_STRING_NOSLASHESCAPE));
+	printf("my_string.to_string(NOSLASHESCAPE)=%s\n",
+	       json_object_to_json_string_ext(my_string, JSON_C_TO_STRING_NOSLASHESCAPE));
 	json_object_put(my_string);
 
 	my_string = json_object_new_string("foo");
@@ -179,13 +229,16 @@ int main(int argc, char **argv)
 	printf("my_int=%d\n", json_object_get_int(my_int));
 	printf("my_int.to_string()=%s\n", json_object_to_json_string(my_int));
 
+	my_null = json_object_new_null();
+	printf("my_null.to_string()=%s\n", json_object_to_json_string(my_null));
+
 	my_array = json_object_new_array();
 	json_object_array_add(my_array, json_object_new_int(1));
 	json_object_array_add(my_array, json_object_new_int(2));
 	json_object_array_add(my_array, json_object_new_int(3));
 	json_object_array_put_idx(my_array, 4, json_object_new_int(5));
 	printf("my_array=\n");
-	for(i=0; i < json_object_array_length(my_array); i++)
+	for (i = 0; i < json_object_array_length(my_array); i++)
 	{
 		json_object *obj = json_object_array_get_idx(my_array, i);
 		printf("\t[%d]=%s\n", (int)i, json_object_to_json_string(obj));
@@ -195,6 +248,7 @@ int main(int argc, char **argv)
 	json_object_put(my_array);
 
 	test_array_del_idx();
+	test_array_list_expand_internal();
 
 	my_array = json_object_new_array();
 	json_object_array_add(my_array, json_object_new_int(3));
@@ -202,7 +256,7 @@ int main(int argc, char **argv)
 	json_object_array_add(my_array, json_object_new_int(2));
 	json_object_array_put_idx(my_array, 4, json_object_new_int(0));
 	printf("my_array=\n");
-	for(i=0; i < json_object_array_length(my_array); i++)
+	for (i = 0; i < json_object_array_length(my_array); i++)
 	{
 		json_object *obj = json_object_array_get_idx(my_array, i);
 		printf("\t[%d]=%s\n", (int)i, json_object_to_json_string(obj));
@@ -210,13 +264,19 @@ int main(int argc, char **argv)
 	printf("my_array.to_string()=%s\n", json_object_to_json_string(my_array));
 	json_object_array_sort(my_array, sort_fn);
 	printf("my_array=\n");
-	for(i=0; i < json_object_array_length(my_array); i++)
+	for (i = 0; i < json_object_array_length(my_array); i++)
 	{
 		json_object *obj = json_object_array_get_idx(my_array, i);
 		printf("\t[%d]=%s\n", (int)i, json_object_to_json_string(obj));
 	}
 	printf("my_array.to_string()=%s\n", json_object_to_json_string(my_array));
 
+	json_object *one = json_object_new_int(1);
+	json_object *result = json_object_array_bsearch(one, my_array, sort_fn);
+	printf("find json_object(1) in my_array successfully: %s\n",
+	       json_object_to_json_string(result));
+	json_object_put(one);
+
 	my_object = json_object_new_object();
 	int rc = json_object_object_add(my_object, "abc", my_object);
 	if (rc != -1)
@@ -249,6 +309,7 @@ int main(int argc, char **argv)
 
 	json_object_put(my_string);
 	json_object_put(my_int);
+	json_object_put(my_null);
 	json_object_put(my_object);
 	json_object_put(my_array);
 

tests/test1.expected

@@ -12,6 +12,7 @@ my_string=foo
 my_string.to_string()="foo"
 my_int=9
 my_int.to_string()=9
+my_null.to_string()=null
 my_array=
 	[0]=1
 	[1]=2
@@ -40,6 +41,19 @@ after del_idx(0,7)=0, my_array.to_string()=[ ]
 after del_idx(0,8)=-1, my_array.to_string()=[ 1, 2, 3, 4, 5, null, 7 ]
 after del_idx(0,6)=0, my_array.to_string()=[ 7 ]
 after adding more entries, my_array.to_string()=[ 7, "s1", "s2", "s3" ]
+my_array=
+	[0]=1
+	[1]=2
+	[2]=3
+	[3]=4
+	[4]=5
+	[5]=null
+	[6]=7
+my_array.to_string()=[ 1, 2, 3, 4, 5, null, 7 ]
+put_idx(5,6)=0
+put_idx(63,0)=0
+put_idx(129,0)=0
+put_idx(SIZE_T_MAX,0)=-1
 my_array=
 	[0]=3
 	[1]=1
@@ -54,6 +68,7 @@ my_array=
 	[3]=2
 	[4]=3
 my_array.to_string()=[ null, 0, 1, 2, 3 ]
+find json_object(1) in my_array successfully: 1
 baz_obj.to_string()="fark"
 my_object=
 	abc: 12

tests/test1.test

@@ -19,4 +19,20 @@ for flag in plain spaced pretty ; do
 	fi
 done
 
+# Spaced and pretty JSON string
+run_output_test -o test1Formatted_spaced_pretty \
+					test1Formatted spaced pretty
+_err2=$?
+if [ $_err -eq 0 ] ; then
+	_err=$_err2
+fi
+
+# Spaced and pretty JSON string using tabs
+run_output_test -o test1Formatted_spaced_pretty_pretty_tab \
+					test1Formatted spaced pretty pretty_tab
+_err2=$?
+if [ $_err -eq 0 ] ; then
+	_err=$_err2
+fi
+
 exit $_err

tests/test1Formatted_plain.expected

@@ -12,6 +12,7 @@ my_string=foo
 my_string.to_string()="foo"
 my_int=9
 my_int.to_string()=9
+my_null.to_string()=null
 my_array=
 	[0]=1
 	[1]=2
@@ -40,6 +41,19 @@ after del_idx(0,7)=0, my_array.to_string()=[]
 after del_idx(0,8)=-1, my_array.to_string()=[1,2,3,4,5,null,7]
 after del_idx(0,6)=0, my_array.to_string()=[7]
 after adding more entries, my_array.to_string()=[7,"s1","s2","s3"]
+my_array=
+	[0]=1
+	[1]=2
+	[2]=3
+	[3]=4
+	[4]=5
+	[5]=null
+	[6]=7
+my_array.to_string()=[1,2,3,4,5,null,7]
+put_idx(5,6)=0
+put_idx(63,0)=0
+put_idx(129,0)=0
+put_idx(SIZE_T_MAX,0)=-1
 my_array=
 	[0]=3
 	[1]=1
@@ -54,6 +68,7 @@ my_array=
 	[3]=2
 	[4]=3
 my_array.to_string()=[null,0,1,2,3]
+find json_object(1) in my_array successfully: 1
 baz_obj.to_string()="fark"
 my_object=
 	abc: 12

tests/test1Formatted_pretty.expected

@@ -12,6 +12,7 @@ my_string=foo
 my_string.to_string()="foo"
 my_int=9
 my_int.to_string()=9
+my_null.to_string()=null
 my_array=
 	[0]=1
 	[1]=2
@@ -46,6 +47,19 @@ after del_idx(0,7)=0, my_array.to_string()=[]
 after del_idx(0,8)=-1, my_array.to_string()=[1,2,3,4,5,null,7]
 after del_idx(0,6)=0, my_array.to_string()=[7]
 after adding more entries, my_array.to_string()=[7,"s1","s2","s3"]
+my_array=
+	[0]=1
+	[1]=2
+	[2]=3
+	[3]=4
+	[4]=5
+	[5]=null
+	[6]=7
+my_array.to_string()=[1,2,3,4,5,null,7]
+put_idx(5,6)=0
+put_idx(63,0)=0
+put_idx(129,0)=0
+put_idx(SIZE_T_MAX,0)=-1
 my_array=
 	[0]=3
 	[1]=1
@@ -72,6 +86,7 @@ my_array.to_string()=[
   2,
   3
 ]
+find json_object(1) in my_array successfully: 1
 baz_obj.to_string()="fark"
 my_object=
 	abc: 12

tests/test1Formatted_spaced.expected

@@ -12,6 +12,7 @@ my_string=foo
 my_string.to_string()="foo"
 my_int=9
 my_int.to_string()=9
+my_null.to_string()=null
 my_array=
 	[0]=1
 	[1]=2
@@ -40,6 +41,19 @@ after del_idx(0,7)=0, my_array.to_string()=[]
 after del_idx(0,8)=-1, my_array.to_string()=[1,2,3,4,5,null,7]
 after del_idx(0,6)=0, my_array.to_string()=[7]
 after adding more entries, my_array.to_string()=[7,"s1","s2","s3"]
+my_array=
+	[0]=1
+	[1]=2
+	[2]=3
+	[3]=4
+	[4]=5
+	[5]=null
+	[6]=7
+my_array.to_string()=[1,2,3,4,5,null,7]
+put_idx(5,6)=0
+put_idx(63,0)=0
+put_idx(129,0)=0
+put_idx(SIZE_T_MAX,0)=-1
 my_array=
 	[0]=3
 	[1]=1
@@ -54,6 +68,7 @@ my_array=
 	[3]=2
 	[4]=3
 my_array.to_string()=[ null, 0, 1, 2, 3 ]
+find json_object(1) in my_array successfully: 1
 baz_obj.to_string()="fark"
 my_object=
 	abc: 12

tests/test1Formatted_spaced_pretty.expected

@@ -0,0 +1,101 @@
+my_string=	
+my_string.to_string()="\t"
+my_string=\
+my_string.to_string()="\\"
+my_string=/
+my_string.to_string()="\/"
+my_string.to_string(NOSLASHESCAPE)="/"
+my_string=/foo/bar/baz
+my_string.to_string()="\/foo\/bar\/baz"
+my_string.to_string(NOSLASHESCAPE)="/foo/bar/baz"
+my_string=foo
+my_string.to_string()="foo"
+my_int=9
+my_int.to_string()=9
+my_null.to_string()=null
+my_array=
+	[0]=1
+	[1]=2
+	[2]=3
+	[3]=null
+	[4]=5
+my_array.to_string()=[
+  1,
+  2,
+  3,
+  null,
+  5
+]
+my_array=
+	[0]=1
+	[1]=2
+	[2]=3
+	[3]=4
+	[4]=5
+	[5]=null
+	[6]=7
+my_array.to_string()=[1,2,3,4,5,null,7]
+after del_idx(0,1)=0, my_array.to_string()=[2,3,4,5,null,7]
+after del_idx(0,1)=0, my_array.to_string()=[3,4,5,null,7]
+after del_idx(0,1)=0, my_array.to_string()=[4,5,null,7]
+after del_idx(0,1)=0, my_array.to_string()=[5,null,7]
+after del_idx(0,1)=0, my_array.to_string()=[null,7]
+after del_idx(0,1)=0, my_array.to_string()=[7]
+after del_idx(0,1)=0, my_array.to_string()=[]
+after del_idx(0,1)=-1, my_array.to_string()=[]
+after del_idx(0,7)=0, my_array.to_string()=[]
+after del_idx(0,8)=-1, my_array.to_string()=[1,2,3,4,5,null,7]
+after del_idx(0,6)=0, my_array.to_string()=[7]
+after adding more entries, my_array.to_string()=[7,"s1","s2","s3"]
+my_array=
+	[0]=1
+	[1]=2
+	[2]=3
+	[3]=4
+	[4]=5
+	[5]=null
+	[6]=7
+my_array.to_string()=[1,2,3,4,5,null,7]
+put_idx(5,6)=0
+put_idx(63,0)=0
+put_idx(129,0)=0
+put_idx(SIZE_T_MAX,0)=-1
+my_array=
+	[0]=3
+	[1]=1
+	[2]=2
+	[3]=null
+	[4]=0
+my_array.to_string()=[
+  3,
+  1,
+  2,
+  null,
+  0
+]
+my_array=
+	[0]=null
+	[1]=0
+	[2]=1
+	[3]=2
+	[4]=3
+my_array.to_string()=[
+  null,
+  0,
+  1,
+  2,
+  3
+]
+find json_object(1) in my_array successfully: 1
+baz_obj.to_string()="fark"
+my_object=
+	abc: 12
+	foo: "bar"
+	bool0: false
+	bool1: true
+my_object.to_string()={
+  "abc": 12,
+  "foo": "bar",
+  "bool0": false,
+  "bool1": true
+}

tests/test1Formatted_spaced_pretty_pretty_tab.expected

@@ -0,0 +1,101 @@
+my_string=	
+my_string.to_string()="\t"
+my_string=\
+my_string.to_string()="\\"
+my_string=/
+my_string.to_string()="\/"
+my_string.to_string(NOSLASHESCAPE)="/"
+my_string=/foo/bar/baz
+my_string.to_string()="\/foo\/bar\/baz"
+my_string.to_string(NOSLASHESCAPE)="/foo/bar/baz"
+my_string=foo
+my_string.to_string()="foo"
+my_int=9
+my_int.to_string()=9
+my_null.to_string()=null
+my_array=
+	[0]=1
+	[1]=2
+	[2]=3
+	[3]=null
+	[4]=5
+my_array.to_string()=[
+	1,
+	2,
+	3,
+	null,
+	5
+]
+my_array=
+	[0]=1
+	[1]=2
+	[2]=3
+	[3]=4
+	[4]=5
+	[5]=null
+	[6]=7
+my_array.to_string()=[1,2,3,4,5,null,7]
+after del_idx(0,1)=0, my_array.to_string()=[2,3,4,5,null,7]
+after del_idx(0,1)=0, my_array.to_string()=[3,4,5,null,7]
+after del_idx(0,1)=0, my_array.to_string()=[4,5,null,7]
+after del_idx(0,1)=0, my_array.to_string()=[5,null,7]
+after del_idx(0,1)=0, my_array.to_string()=[null,7]
+after del_idx(0,1)=0, my_array.to_string()=[7]
+after del_idx(0,1)=0, my_array.to_string()=[]
+after del_idx(0,1)=-1, my_array.to_string()=[]
+after del_idx(0,7)=0, my_array.to_string()=[]
+after del_idx(0,8)=-1, my_array.to_string()=[1,2,3,4,5,null,7]
+after del_idx(0,6)=0, my_array.to_string()=[7]
+after adding more entries, my_array.to_string()=[7,"s1","s2","s3"]
+my_array=
+	[0]=1
+	[1]=2
+	[2]=3
+	[3]=4
+	[4]=5
+	[5]=null
+	[6]=7
+my_array.to_string()=[1,2,3,4,5,null,7]
+put_idx(5,6)=0
+put_idx(63,0)=0
+put_idx(129,0)=0
+put_idx(SIZE_T_MAX,0)=-1
+my_array=
+	[0]=3
+	[1]=1
+	[2]=2
+	[3]=null
+	[4]=0
+my_array.to_string()=[
+	3,
+	1,
+	2,
+	null,
+	0
+]
+my_array=
+	[0]=null
+	[1]=0
+	[2]=1
+	[3]=2
+	[4]=3
+my_array.to_string()=[
+	null,
+	0,
+	1,
+	2,
+	3
+]
+find json_object(1) in my_array successfully: 1
+baz_obj.to_string()="fark"
+my_object=
+	abc: 12
+	foo: "bar"
+	bool0: false
+	bool1: true
+my_object.to_string()={
+	"abc": 12,
+	"foo": "bar",
+	"bool0": false,
+	"bool1": true
+}

tests/test2.c

@@ -1,18 +1,17 @@
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stddef.h>
 #include <string.h>
 
 #include "json.h"
 #include "parse_flags.h"
 
 #ifdef TEST_FORMATTED
-#define json_object_to_json_string(obj) json_object_to_json_string_ext(obj,sflags)
+#define json_object_to_json_string(obj) json_object_to_json_string_ext(obj, sflags)
 #else
 /* no special define */
 #endif
 
-
 int main(int argc, char **argv)
 {
 	json_object *new_obj;
@@ -26,8 +25,13 @@ int main(int argc, char **argv)
 	sflags = parse_flags(argc, argv);
 #endif
 
-	new_obj = json_tokener_parse("/* more difficult test case */"
-				     "{ \"glossary\": { \"title\": \"example glossary\", \"GlossDiv\": { \"title\": \"S\", \"GlossList\": [ { \"ID\": \"SGML\", \"SortAs\": \"SGML\", \"GlossTerm\": \"Standard Generalized Markup Language\", \"Acronym\": \"SGML\", \"Abbrev\": \"ISO 8879:1986\", \"GlossDef\": \"A meta-markup language, used to create markup languages such as DocBook.\", \"GlossSeeAlso\": [\"GML\", \"XML\", \"markup\"] } ] } } }");
+	new_obj = json_tokener_parse(
+	    "/* more difficult test case */"
+	    "{ \"glossary\": { \"title\": \"example glossary\", \"GlossDiv\": { \"title\": \"S\", "
+	    "\"GlossList\": [ { \"ID\": \"SGML\", \"SortAs\": \"SGML\", \"GlossTerm\": \"Standard "
+	    "Generalized Markup Language\", \"Acronym\": \"SGML\", \"Abbrev\": \"ISO 8879:1986\", "
+	    "\"GlossDef\": \"A meta-markup language, used to create markup languages such as "
+	    "DocBook.\", \"GlossSeeAlso\": [\"GML\", \"XML\", \"markup\"] } ] } } }");
 	printf("new_obj.to_string()=%s\n", json_object_to_json_string(new_obj));
 	json_object_put(new_obj);
 

tests/test2.test

@@ -19,4 +19,20 @@ for flag in plain spaced pretty ; do
 	fi
 done
 
+# Spaced and pretty JSON string
+run_output_test -o test2Formatted_spaced_pretty \
+					test2Formatted spaced pretty
+_err2=$?
+if [ $_err -eq 0 ] ; then
+	_err=$_err2
+fi
+
+# Spaced and pretty JSON string using tabs
+run_output_test -o test2Formatted_spaced_pretty_pretty_tab \
+					test2Formatted spaced pretty pretty_tab
+_err2=$?
+if [ $_err -eq 0 ] ; then
+	_err=$_err2
+fi
+
 exit $_err

tests/test2Formatted_spaced_pretty.expected

@@ -0,0 +1,23 @@
+new_obj.to_string()={
+  "glossary": {
+    "title": "example glossary",
+    "GlossDiv": {
+      "title": "S",
+      "GlossList": [
+        {
+          "ID": "SGML",
+          "SortAs": "SGML",
+          "GlossTerm": "Standard Generalized Markup Language",
+          "Acronym": "SGML",
+          "Abbrev": "ISO 8879:1986",
+          "GlossDef": "A meta-markup language, used to create markup languages such as DocBook.",
+          "GlossSeeAlso": [
+            "GML",
+            "XML",
+            "markup"
+          ]
+        }
+      ]
+    }
+  }
+}

tests/test2Formatted_spaced_pretty_pretty_tab.expected

@@ -0,0 +1,23 @@
+new_obj.to_string()={
+	"glossary": {
+		"title": "example glossary",
+		"GlossDiv": {
+			"title": "S",
+			"GlossList": [
+				{
+					"ID": "SGML",
+					"SortAs": "SGML",
+					"GlossTerm": "Standard Generalized Markup Language",
+					"Acronym": "SGML",
+					"Abbrev": "ISO 8879:1986",
+					"GlossDef": "A meta-markup language, used to create markup languages such as DocBook.",
+					"GlossSeeAlso": [
+						"GML",
+						"XML",
+						"markup"
+					]
+				}
+			]
+		}
+	}
+}

tests/test4.c

@@ -2,44 +2,73 @@
  * gcc -o utf8 utf8.c -I/home/y/include -L./.libs -ljson
  */
 
-#include <stdio.h>
-#include <string.h>
 #include "config.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include "json_inttypes.h"
 #include "json_object.h"
 #include "json_tokener.h"
+#include "snprintf_compat.h"
 
-void print_hex(const char* s)
+void print_hex(const char *s)
 {
 	const char *iter = s;
 	unsigned char ch;
 	while ((ch = *iter++) != 0)
 	{
-		if( ',' != ch)
+		if (',' != ch)
 			printf("%x ", ch);
 		else
-			printf( ",");
+			printf(",");
 	}
 	putchar('\n');
 }
 
+static void test_lot_of_adds(void);
+static void test_lot_of_adds()
+{
+	int ii;
+	char key[50];
+	json_object *jobj = json_object_new_object();
+	assert(jobj != NULL);
+	for (ii = 0; ii < 500; ii++)
+	{
+		snprintf(key, sizeof(key), "k%d", ii);
+		json_object *iobj = json_object_new_int(ii);
+		assert(iobj != NULL);
+		if (json_object_object_add(jobj, key, iobj))
+		{
+			fprintf(stderr, "FAILED to add object #%d\n", ii);
+			abort();
+		}
+	}
+	printf("%s\n", json_object_to_json_string(jobj));
+	assert(json_object_object_length(jobj) == 500);
+	json_object_put(jobj);
+}
+
 int main(void)
 {
 	const char *input = "\"\\ud840\\udd26,\\ud840\\udd27,\\ud800\\udd26,\\ud800\\udd27\"";
-	const char *expected = "\xF0\xA0\x84\xA6,\xF0\xA0\x84\xA7,\xF0\x90\x84\xA6,\xF0\x90\x84\xA7";
+	const char *expected =
+	    "\xF0\xA0\x84\xA6,\xF0\xA0\x84\xA7,\xF0\x90\x84\xA6,\xF0\x90\x84\xA7";
 	struct json_object *parse_result = json_tokener_parse(input);
 	const char *unjson = json_object_get_string(parse_result);
 
 	printf("input: %s\n", input);
 
-	int strings_match = !strcmp( expected, unjson);
+	int strings_match = !strcmp(expected, unjson);
 	int retval = 0;
 	if (strings_match)
 	{
 		printf("JSON parse result is correct: %s\n", unjson);
 		puts("PASS");
-	} else {
+	}
+	else
+	{
 		printf("JSON parse result doesn't match expected string\n");
 		printf("expected string bytes: ");
 		print_hex(expected);
@@ -49,5 +78,8 @@ int main(void)
 		retval = 1;
 	}
 	json_object_put(parse_result);
+
+	test_lot_of_adds();
+
 	return retval;
 }

tests/testReplaceExisting.c

@@ -1,6 +1,6 @@
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stddef.h>
 #include <string.h>
 
 #include "json.h"
@@ -67,12 +67,12 @@ int main(int argc, char **argv)
 	}
 	if (new_count != orig_count)
 	{
-		printf("mismatch between original count (%d) and new count (%d)\n",
-		       orig_count, new_count);
+		printf("mismatch between original count (%d) and new count (%d)\n", orig_count,
+		       new_count);
 		retval = 1;
 	}
 
-	json_object_put( my_object );
+	json_object_put(my_object);
 
 	return retval;
 }

tests/test_cast.c

@@ -3,10 +3,10 @@
  * Also checks the json_object_get_type and json_object_is_type functions.
  */
 
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
 #include "config.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include "json_inttypes.h"
 #include "json_object.h"
@@ -25,10 +25,13 @@ int main(int argc, char **argv)
 		\"decimal_number\": 99.55,\n\
 		\"boolean_true\": true,\n\
 		\"boolean_false\": false,\n\
-		\"big_number\": 2147483649,\n\
+		\"int64_number\": 2147483649,\n\
+		\"negative_number\": -321321321,\n\
 		\"a_null\": null,\n\
 	}";
 	/* Note: 2147483649 = INT_MAX + 2 */
+	/* Note: 9223372036854775809 = INT64_MAX + 2 */
+	/* Note: 18446744073709551617 = UINT64_MAX + 2 */
 
 	struct json_object *new_obj;
 
@@ -43,7 +46,8 @@ int main(int argc, char **argv)
 	getit(new_obj, "decimal_number");
 	getit(new_obj, "boolean_true");
 	getit(new_obj, "boolean_false");
-	getit(new_obj, "big_number");
+	getit(new_obj, "int64_number");
+	getit(new_obj, "negative_number");
 	getit(new_obj, "a_null");
 
 	// Now check the behaviour of the json_object_is_type() function.
@@ -55,7 +59,8 @@ int main(int argc, char **argv)
 	checktype(new_obj, "decimal_number");
 	checktype(new_obj, "boolean_true");
 	checktype(new_obj, "boolean_false");
-	checktype(new_obj, "big_number");
+	checktype(new_obj, "int64_number");
+	checktype(new_obj, "negative_number");
 	checktype(new_obj, "a_null");
 
 	json_object_put(new_obj);
@@ -70,42 +75,31 @@ static void getit(struct json_object *new_obj, const char *field)
 		printf("Field %s does not exist\n", field);
 
 	enum json_type o_type = json_object_get_type(o);
-	printf("new_obj.%s json_object_get_type()=%s\n", field,
-	       json_type_to_name(o_type));
-	printf("new_obj.%s json_object_get_int()=%d\n", field,
-	       json_object_get_int(o));
-	printf("new_obj.%s json_object_get_int64()=%" PRId64 "\n", field,
-	       json_object_get_int64(o));
-	printf("new_obj.%s json_object_get_boolean()=%d\n", field,
-	       json_object_get_boolean(o));
-	printf("new_obj.%s json_object_get_double()=%f\n", field,
-	       json_object_get_double(o));
+	printf("new_obj.%s json_object_get_type()=%s\n", field, json_type_to_name(o_type));
+	printf("new_obj.%s json_object_get_int()=%d\n", field, json_object_get_int(o));
+	printf("new_obj.%s json_object_get_int64()=%" PRId64 "\n", field, json_object_get_int64(o));
+	printf("new_obj.%s json_object_get_uint64()=%" PRIu64 "\n", field,
+	       json_object_get_uint64(o));
+	printf("new_obj.%s json_object_get_boolean()=%d\n", field, json_object_get_boolean(o));
+	printf("new_obj.%s json_object_get_double()=%f\n", field, json_object_get_double(o));
 }
 
 static void checktype_header()
 {
-	printf("json_object_is_type: %s,%s,%s,%s,%s,%s,%s\n",
-		json_type_to_name(json_type_null),
-		json_type_to_name(json_type_boolean),
-		json_type_to_name(json_type_double),
-		json_type_to_name(json_type_int),
-		json_type_to_name(json_type_object),
-		json_type_to_name(json_type_array),
-		json_type_to_name(json_type_string));
+	printf("json_object_is_type: %s,%s,%s,%s,%s,%s,%s\n", json_type_to_name(json_type_null),
+	       json_type_to_name(json_type_boolean), json_type_to_name(json_type_double),
+	       json_type_to_name(json_type_int), json_type_to_name(json_type_object),
+	       json_type_to_name(json_type_array), json_type_to_name(json_type_string));
 }
 static void checktype(struct json_object *new_obj, const char *field)
 {
 	struct json_object *o = new_obj;
 	if (field && !json_object_object_get_ex(new_obj, field, &o))
 		printf("Field %s does not exist\n", field);
-			
-	printf("new_obj%s%-18s: %d,%d,%d,%d,%d,%d,%d\n",
-		field ? "." : " ", field ? field : "",
-		json_object_is_type(o, json_type_null),
-		json_object_is_type(o, json_type_boolean),
-		json_object_is_type(o, json_type_double),
-		json_object_is_type(o, json_type_int),
-		json_object_is_type(o, json_type_object),
-		json_object_is_type(o, json_type_array),
-		json_object_is_type(o, json_type_string));
+
+	printf("new_obj%s%-18s: %d,%d,%d,%d,%d,%d,%d\n", field ? "." : " ", field ? field : "",
+	       json_object_is_type(o, json_type_null), json_object_is_type(o, json_type_boolean),
+	       json_object_is_type(o, json_type_double), json_object_is_type(o, json_type_int),
+	       json_object_is_type(o, json_type_object), json_object_is_type(o, json_type_array),
+	       json_object_is_type(o, json_type_string));
 }

tests/test_cast.expected

@@ -4,43 +4,57 @@ Parsed input: {
 		"decimal_number": 99.55,
 		"boolean_true": true,
 		"boolean_false": false,
-		"big_number": 2147483649,
+		"int64_number": 2147483649,
+		"negative_number": -321321321,
 		"a_null": null,
 	}
 Result is not NULL
 new_obj.string_of_digits json_object_get_type()=string
 new_obj.string_of_digits json_object_get_int()=123
 new_obj.string_of_digits json_object_get_int64()=123
+new_obj.string_of_digits json_object_get_uint64()=123
 new_obj.string_of_digits json_object_get_boolean()=1
 new_obj.string_of_digits json_object_get_double()=123.000000
 new_obj.regular_number json_object_get_type()=int
 new_obj.regular_number json_object_get_int()=222
 new_obj.regular_number json_object_get_int64()=222
+new_obj.regular_number json_object_get_uint64()=222
 new_obj.regular_number json_object_get_boolean()=1
 new_obj.regular_number json_object_get_double()=222.000000
 new_obj.decimal_number json_object_get_type()=double
 new_obj.decimal_number json_object_get_int()=99
 new_obj.decimal_number json_object_get_int64()=99
+new_obj.decimal_number json_object_get_uint64()=99
 new_obj.decimal_number json_object_get_boolean()=1
 new_obj.decimal_number json_object_get_double()=99.550000
 new_obj.boolean_true json_object_get_type()=boolean
 new_obj.boolean_true json_object_get_int()=1
 new_obj.boolean_true json_object_get_int64()=1
+new_obj.boolean_true json_object_get_uint64()=1
 new_obj.boolean_true json_object_get_boolean()=1
 new_obj.boolean_true json_object_get_double()=1.000000
 new_obj.boolean_false json_object_get_type()=boolean
 new_obj.boolean_false json_object_get_int()=0
 new_obj.boolean_false json_object_get_int64()=0
+new_obj.boolean_false json_object_get_uint64()=0
 new_obj.boolean_false json_object_get_boolean()=0
 new_obj.boolean_false json_object_get_double()=0.000000
-new_obj.big_number json_object_get_type()=int
-new_obj.big_number json_object_get_int()=2147483647
-new_obj.big_number json_object_get_int64()=2147483649
-new_obj.big_number json_object_get_boolean()=1
-new_obj.big_number json_object_get_double()=2147483649.000000
+new_obj.int64_number json_object_get_type()=int
+new_obj.int64_number json_object_get_int()=2147483647
+new_obj.int64_number json_object_get_int64()=2147483649
+new_obj.int64_number json_object_get_uint64()=2147483649
+new_obj.int64_number json_object_get_boolean()=1
+new_obj.int64_number json_object_get_double()=2147483649.000000
+new_obj.negative_number json_object_get_type()=int
+new_obj.negative_number json_object_get_int()=-321321321
+new_obj.negative_number json_object_get_int64()=-321321321
+new_obj.negative_number json_object_get_uint64()=0
+new_obj.negative_number json_object_get_boolean()=1
+new_obj.negative_number json_object_get_double()=-321321321.000000
 new_obj.a_null json_object_get_type()=null
 new_obj.a_null json_object_get_int()=0
 new_obj.a_null json_object_get_int64()=0
+new_obj.a_null json_object_get_uint64()=0
 new_obj.a_null json_object_get_boolean()=0
 new_obj.a_null json_object_get_double()=0.000000
 
@@ -52,5 +66,6 @@ new_obj.regular_number    : 0,0,0,1,0,0,0
 new_obj.decimal_number    : 0,0,1,0,0,0,0
 new_obj.boolean_true      : 0,1,0,0,0,0,0
 new_obj.boolean_false     : 0,1,0,0,0,0,0
-new_obj.big_number        : 0,0,0,1,0,0,0
+new_obj.int64_number      : 0,0,0,1,0,0,0
+new_obj.negative_number   : 0,0,0,1,0,0,0
 new_obj.a_null            : 1,0,0,0,0,0,0