Merge pull request #448 from coreyfarrell/2.12

jansson 2.12
2018-11-26 09:10:04 +01:00 · 2018-11-25 03:40:56 -05:00 · 2018-11-25 02:40:09 -05:00 · 2018-11-24 23:29:14 -08:00 · 2018-11-24 23:27:23 -08:00 · 2018-11-08 16:00:32 -05:00
46 changed files with 1711 additions and 533 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -31,3 +31,5 @@ stamp-h1
 /jansson_private_config.h
 /build
 *.exe
+.idea
+cmake-build-debug/
--- a/82
+++ b/82
@@ -1,3 +1,85 @@
+Version 2.12
+
+Released 2018-11-25
+
+* Bug fixes:
+
+  - Fix error message in `json_pack()` for NULL object (#409).
+
+  - Avoid invalid memory read in `json_pack()` (#421).
+
+  - Call va_end after va_copy in `json_vsprintf()` (#427).
+
+  - Improve handling of formats with '?' and '*' in `json_pack()` (#438).
+
+  - Remove inappropriate `jsonp_free()` which caused segmentation fault in
+    error handling (#444).
+
+* Build:
+
+  - Add function attributes for GCC and CLANG to provide warnings on improper
+    use of jansson routines (#404).
+
+  - Many CMake fixes (#408, #412, #415).
+
+  - Enable -Bsymbolic-functions linker flag whenever possible.
+
+  - Resolve various compiler warnings (#423, #430, #435, #436).
+
+  - Fix code coverage ignored paths (#439).
+
+* Other:
+
+  - Test coverage improvements (#398, #400).
+
+  - Add VS 2017 to appveyor, update Visual Studio documentation (#417).
+
+  - Update copyright for 2018 (#424).
+
+  - Update install instructions in README (#401).
+
+Version 2.11
+============
+
+Released 2018-02-09
+
+* New features:
+
+  - Add `json_pack()` format specifiers s*, o* and O* for values that
+    can be omitted if null (#339).
+
+  - Add `json_error_code()` to retrieve numeric error codes (#365, #380,
+    #381).
+
+  - Enable thread safety for `json_dump()` on all systems.  Enable thread
+    safe `json_decref()` and `json_incref()` for modern compilers (#389).
+
+  - Add `json_sprintf()` and `json_vsprintf()` (#393).
+
+* Bug Fixes:
+
+  - Fix incorrect report of success from `json_dump_file()` when an error
+    is returned by `fclose()` (#359).
+
+  - Make json_equal() const-correct (#344).
+
+  - Fix incomplete stealing of references by `json_pack()` (#374).
+
+* Build:
+
+  - Work around gcc's -Wimplicit-fallthrough.
+
+  - Fix CMake detection of `sys/types.h` header (#375).
+
+  - Fix `jansson.pc` generated by CMake to be more consistent with the one
+    generated using GNU Autotools (#368).
+
+* Other:
+
+  - Miscellaneous documentation fixes (#356, #378, #395).
+
+  - Remove unnecessary reference actions from parsers (#377).
+
 Version 2.10
 ============

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -46,9 +46,8 @@



-cmake_minimum_required (VERSION 2.8)
-# required for exports? cmake_minimum_required (VERSION 2.8.6)
-project (jansson C)
+cmake_minimum_required (VERSION 3.1)
+project(jansson C)

 # Options
 option(JANSSON_BUILD_SHARED_LIBS "Build shared libraries." OFF)
@@ -70,26 +69,26 @@ if (UNIX)
 endif ()

 # Set some nicer output dirs.
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
-set(JANSSON_TEMP_DIR ${PROJECT_BINARY_DIR}/tmp)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib)
+set(JANSSON_TEMP_DIR ${CMAKE_CURRENT_BINARY_DIR}/tmp)

 # Give the debug version a different postfix for windows,
 # so both the debug and release version can be built in the
 # same build-tree on Windows (MSVC).
-if (WIN32)
+if (WIN32 AND NOT CMAKE_DEBUG_POSTFIX)
   set(CMAKE_DEBUG_POSTFIX "_d")
-endif (WIN32)
+endif()

 # This is how I thought it should go
 # set (JANSSON_VERSION "2.3.1")
 # set (JANSSON_SOVERSION 2)

-set(JANSSON_DISPLAY_VERSION "2.10")
+set(JANSSON_DISPLAY_VERSION "2.12")

 # This is what is required to match the same numbers as automake's
-set(JANSSON_VERSION "4.10.0")
+set(JANSSON_VERSION "4.11.1")
 set(JANSSON_SOVERSION 4)

 # for CheckFunctionKeywords
@@ -104,16 +103,11 @@ include (CheckTypeSize)
 if (MSVC)
   # Turn off Microsofts "security" warnings.
   add_definitions( "/W3 /D_CRT_SECURE_NO_WARNINGS /wd4005 /wd4996 /nologo" )
-   
+
   if (JANSSON_STATIC_CRT)
      set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /MT")
      set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /MTd")
   endif()
-   
-endif()
-
-if (NOT WIN32 AND (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX))
-   add_definitions("-fPIC")
 endif()

 message("C compiler: ${CMAKE_C_COMPILER_ID}")
@@ -138,7 +132,7 @@ check_include_files (unistd.h HAVE_UNISTD_H)
 check_include_files (sys/param.h HAVE_SYS_PARAM_H)
 check_include_files (sys/stat.h HAVE_SYS_STAT_H)
 check_include_files (sys/time.h HAVE_SYS_TIME_H)
-check_include_files (sys/time.h HAVE_SYS_TYPES_H)
+check_include_files (sys/types.h HAVE_SYS_TYPES_H)

 check_function_exists (close HAVE_CLOSE)
 check_function_exists (getpid HAVE_GETPID)
@@ -164,9 +158,9 @@ if (HAVE_INT32_T)
   set (JSON_INT32 int32_t)
 elseif (HAVE___INT32)
   set (JSON_INT32 __int32)
-elseif (HAVE_LONG_INT AND (${LONG_INT} EQUAL 4))
+elseif (HAVE_LONG_INT AND (LONG_INT EQUAL 4))
   set (JSON_INT32 long)
-elseif (HAVE_INT AND (${INT} EQUAL 4))
+elseif (HAVE_INT AND (INT EQUAL 4))
   set (JSON_INT32 int)
 else ()
   message (FATAL_ERROR "Could not detect a valid 32-bit integer type")
@@ -182,12 +176,12 @@ if (HAVE_UINT32_T)
   set (JSON_UINT32 uint32_t)
 elseif (HAVE___UINT32)
   set (JSON_UINT32 __uint32)
-elseif (HAVE_UNSIGNED_LONG_INT AND (${UNSIGNED_LONG_INT} EQUAL 4))
+elseif (HAVE_UNSIGNED_LONG_INT AND (UNSIGNED_LONG_INT EQUAL 4))
   set (JSON_UINT32 "unsigned long")
-elseif (HAVE_UNSIGNED_INT AND (${UNSIGNED_INT} EQUAL 4))
+elseif (HAVE_UNSIGNED_INT AND (UNSIGNED_INT EQUAL 4))
   set (JSON_UINT32 "unsigned int")
 else ()
-   message (FATAL_ERROR "Could not detect a valid unsigned 32-bit integer type")
+      message (FATAL_ERROR "Could not detect a valid unsigned 32-bit integer type")
 endif ()

 check_type_size (uint16_t UINT16_T)
@@ -196,12 +190,12 @@ if (HAVE_UINT16_T)
   set (JSON_UINT16 uint16_t)
 elseif (HAVE___UINT16)
   set (JSON_UINT16 __uint16)
-elseif (HAVE_UNSIGNED_INT AND (${UNSIGNED_INT} EQUAL 2))
+elseif (HAVE_UNSIGNED_INT AND (UNSIGNED_INT EQUAL 2))
   set (JSON_UINT16 "unsigned int")
-elseif (HAVE_UNSIGNED_SHORT AND (${UNSIGNED_SHORT} EQUAL 2))
+elseif (HAVE_UNSIGNED_SHORT AND (UNSIGNED_SHORT EQUAL 2))
   set (JSON_UINT16 "unsigned short")
 else ()
-   message (FATAL_ERROR "Could not detect a valid unsigned 16-bit integer type")
+      message (FATAL_ERROR "Could not detect a valid unsigned 16-bit integer type")
 endif ()

 check_type_size (uint8_t UINT8_T)
@@ -250,7 +244,7 @@ endif ()
 # detect what to use for the 64 bit type.
 # Note: I will prefer long long if I can get it, as that is what the automake system aimed for.
 if (NOT DEFINED JSON_INT_T)
-   if (HAVE_LONG_LONG_INT AND ((${LONG_LONG_INT}) EQUAL 8))
+   if (HAVE_LONG_LONG_INT AND (LONG_LONG_INT EQUAL 8))
      set (JSON_INT_T "long long")
   elseif (HAVE_INT64_T)
      set (JSON_INT_T int64_t)
@@ -303,8 +297,20 @@ else()
   set (JSON_INLINE)
 endif()

-check_c_source_compiles ("int main() { unsigned long val; __sync_bool_compare_and_swap(&val, 0, 1); return 0; } " HAVE_SYNC_BUILTINS)
-check_c_source_compiles ("int main() { char l; unsigned long v; __atomic_test_and_set(&l, __ATOMIC_RELAXED); __atomic_store_n(&v, 1, __ATOMIC_RELEASE); __atomic_load_n(&v, __ATOMIC_ACQUIRE); return 0; }" HAVE_ATOMIC_BUILTINS)
+check_c_source_compiles ("int main() { unsigned long val; __sync_bool_compare_and_swap(&val, 0, 1); __sync_add_and_fetch(&val, 1); __sync_sub_and_fetch(&val, 1); return 0; } " HAVE_SYNC_BUILTINS)
+check_c_source_compiles ("int main() { char l; unsigned long v; __atomic_test_and_set(&l, __ATOMIC_RELAXED); __atomic_store_n(&v, 1, __ATOMIC_RELEASE); __atomic_load_n(&v, __ATOMIC_ACQUIRE); __atomic_add_fetch(&v, 1, __ATOMIC_ACQUIRE); __atomic_sub_fetch(&v, 1, __ATOMIC_RELEASE); return 0; }" HAVE_ATOMIC_BUILTINS)
+
+if (HAVE_SYNC_BUILTINS)
+  set(JSON_HAVE_SYNC_BUILTINS 1)
+else()
+  set(JSON_HAVE_SYNC_BUILTINS 0)
+endif()
+
+if (HAVE_ATOMIC_BUILTINS)
+  set(JSON_HAVE_ATOMIC_BUILTINS 1)
+else()
+  set(JSON_HAVE_ATOMIC_BUILTINS 0)
+endif()

 set (JANSSON_INITIAL_HASHTABLE_ORDER 3 CACHE STRING "Number of buckets new object hashtables contain is 2 raised to this power. The default is 3, so empty hashtables contain 2^3 = 8 buckets.")

@@ -338,7 +344,7 @@ set(JANSSON_HDR_PRIVATE
   ${CMAKE_CURRENT_SOURCE_DIR}/src/utf.h
   ${CMAKE_CURRENT_BINARY_DIR}/private_include/jansson_private_config.h)

-set(JANSSON_HDR_PUBLIC 
+set(JANSSON_HDR_PUBLIC
   ${CMAKE_CURRENT_BINARY_DIR}/include/jansson_config.h
   ${CMAKE_CURRENT_SOURCE_DIR}/src/jansson.h)

@@ -347,24 +353,26 @@ source_group("Library Private Headers" FILES ${JANSSON_HDR_PRIVATE})
 source_group("Library Public Headers" FILES ${JANSSON_HDR_PUBLIC})

 if(JANSSON_BUILD_SHARED_LIBS)
-   add_library(jansson SHARED 
-      ${JANSSON_SRC} 
-      ${JANSSON_HDR_PRIVATE} 
-      ${JANSSON_HDR_PUBLIC} 
+   add_library(jansson SHARED
+      ${JANSSON_SRC}
+      ${JANSSON_HDR_PRIVATE}
+      ${JANSSON_HDR_PUBLIC}
      src/jansson.def)

   set_target_properties(jansson PROPERTIES
      VERSION ${JANSSON_VERSION}
      SOVERSION ${JANSSON_SOVERSION})
 else()
-   add_library(jansson 
+   add_library(jansson STATIC
      ${JANSSON_SRC}
-      ${JANSSON_HDR_PRIVATE} 
+      ${JANSSON_HDR_PRIVATE}
      ${JANSSON_HDR_PUBLIC})
+   set_target_properties(jansson PROPERTIES
+      POSITION_INDEPENDENT_CODE true)
 endif()

 if (JANSSON_EXAMPLES)
-	add_executable(simple_parse "${PROJECT_SOURCE_DIR}/examples/simple_parse.c")
+	add_executable(simple_parse "${CMAKE_CURRENT_SOURCE_DIR}/examples/simple_parse.c")
 	target_link_libraries(simple_parse jansson)
 endif()

@@ -374,12 +382,12 @@ if (JANSSON_BUILD_DOCS)
   find_package(Sphinx)

   if (NOT SPHINX_FOUND)
-      message(WARNING "Sphinx not found. Cannot generate documentation! 
+      message(WARNING "Sphinx not found. Cannot generate documentation!
      Set -DJANSSON_BUILD_DOCS=OFF to get rid of this message.")
   else()
      if (Sphinx_VERSION_STRING VERSION_LESS 1.0)
-         message(WARNING "Your Sphinx version is too old! 
-               This project requires Sphinx v1.0 or above to produce 
+         message(WARNING "Your Sphinx version is too old!
+               This project requires Sphinx v1.0 or above to produce
               proper documentation (you have v${Sphinx_VERSION_STRING}).
               You will get output but it will have errors.")
      endif()
@@ -432,7 +440,7 @@ if (JANSSON_BUILD_DOCS)
            list(APPEND DOC_TARGETS latex)
         endif()
      endif()
-      
+
      # The doc target will build all documentation targets.
      add_custom_target(doc)

@@ -487,15 +495,18 @@ if (NOT JANSSON_WITHOUT_TESTS)
   set(api_tests
         test_array
         test_copy
+         test_chaos
         test_dump
         test_dump_callback
         test_equal
         test_load
         test_loadb
+         test_load_callback
         test_number
         test_object
         test_pack
         test_simple
+         test_sprintf
         test_unpack)

   # Doing arithmetic on void pointers is not allowed by Microsofts compiler
@@ -513,7 +524,7 @@ if (NOT JANSSON_WITHOUT_TESTS)

   # Create executables and tests/valgrind tests for API tests.
   foreach (test ${api_tests})
-      build_testprog(${test} ${PROJECT_SOURCE_DIR}/test/suites/api)
+      build_testprog(${test} ${CMAKE_CURRENT_SOURCE_DIR}/test/suites/api)

      if (JANSSON_TEST_WITH_VALGRIND)
         add_test(memcheck__${test}
@@ -527,12 +538,12 @@ if (NOT JANSSON_WITHOUT_TESTS)
   endforeach ()

   # Test harness for the suites tests.
-   build_testprog(json_process ${PROJECT_SOURCE_DIR}/test/bin)
+   build_testprog(json_process ${CMAKE_CURRENT_SOURCE_DIR}/test/bin)

   set(SUITE_TEST_CMD ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/json_process)
   set(SUITES encoding-flags valid invalid invalid-unicode)
   foreach (SUITE ${SUITES})
-       file(GLOB TESTDIRS ${jansson_SOURCE_DIR}/test/suites/${SUITE}/*)
+       file(GLOB TESTDIRS test/suites/${SUITE}/*)

       foreach (TESTDIR ${TESTDIRS})
         if (IS_DIRECTORY ${TESTDIR})
@@ -574,7 +585,7 @@ if (NOT JANSSON_WITHOUT_TESTS)

   # Enable using "make check" just like the autotools project.
   # By default cmake creates a target "make test"
-   add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} 
+   add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND}
                     DEPENDS json_process ${api_tests})
 endif ()

@@ -599,86 +610,74 @@ set(JANSSON_INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH "Installation
 # (We use the same files as ./configure does, so we
 #  have to defined the same variables used there).
 set(prefix      ${CMAKE_INSTALL_PREFIX})
-set(exec_prefix ${CMAKE_INSTALL_PREFIX})
-set(libdir      ${CMAKE_INSTALL_PREFIX}/${JANSSON_INSTALL_LIB_DIR})
+set(exec_prefix "\${prefix}")
+set(libdir      "\${exec_prefix}/${JANSSON_INSTALL_LIB_DIR}")
+set(includedir  "\${prefix}/${JANSSON_INSTALL_INCLUDE_DIR}")
 set(VERSION     ${JANSSON_DISPLAY_VERSION})
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/jansson.pc.in
               ${CMAKE_CURRENT_BINARY_DIR}/jansson.pc @ONLY)

-# Make sure the paths are absolute.
+# Make sure the paths are relative.
 foreach(p LIB BIN INCLUDE CMAKE)
    set(var JANSSON_INSTALL_${p}_DIR)
-    if(NOT IS_ABSOLUTE "${${var}}")
-        set(${var} "${CMAKE_INSTALL_PREFIX}/${${var}}")
-    endif()
 endforeach()

-# Export targets (This is used for other CMake projects to easily find the libraries and include files).
-export(TARGETS jansson
-        FILE "${PROJECT_BINARY_DIR}/JanssonTargets.cmake")
-export(PACKAGE jansson)
-
 # Generate the config file for the build-tree.
-set(JANSSON__INCLUDE_DIRS 
-    "${PROJECT_SOURCE_DIR}/include"
-    "${PROJECT_BINARY_DIR}/include")
+set(JANSSON__INCLUDE_DIRS
+    "${CMAKE_CURRENT_SOURCE_DIR}/include"
+    "${CMAKE_CURRENT_BINARY_DIR}/include")
 set(JANSSON_INCLUDE_DIRS ${JANSSON__INCLUDE_DIRS} CACHE PATH "Jansson include directories")
-configure_file(${PROJECT_SOURCE_DIR}/cmake/JanssonConfig.cmake.in
-                ${PROJECT_BINARY_DIR}/JanssonConfig.cmake 
-                @ONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/janssonConfig.cmake.in
+               ${CMAKE_CURRENT_BINARY_DIR}/janssonConfig.cmake
+               @ONLY)
+

 # Generate the config file for the installation tree.
-file(RELATIVE_PATH 
-    REL_INCLUDE_DIR 
-    "${JANSSON_INSTALL_CMAKE_DIR}"
-    "${JANSSON_INSTALL_INCLUDE_DIR}") # Calculate the relative directory from the Cmake dir.
+include(CMakePackageConfigHelpers)

-# Note the EVENT_CMAKE_DIR is defined in JanssonConfig.cmake.in, 
-# we escape it here so it's evaluated when it is included instead
-# so that the include dirs are given relative to where the 
-# config file is located.
-set(JANSSON__INCLUDE_DIRS 
-    "\${JANSSON_CMAKE_DIR}/${REL_INCLUDE_DIR}") 
-configure_file(${PROJECT_SOURCE_DIR}/cmake/JanssonConfig.cmake.in
-                ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/JanssonConfig.cmake 
-                @ONLY)
+write_basic_package_version_file(
+  "${CMAKE_CURRENT_BINARY_DIR}/cmake/janssonConfigVersion.cmake"
+  VERSION ${JANSSON_VERSION}
+  COMPATIBILITY ExactVersion
+)

-# Generate version info for both build-tree and install-tree.
-configure_file(${PROJECT_SOURCE_DIR}/cmake/JanssonConfigVersion.cmake.in
-                ${PROJECT_BINARY_DIR}/JanssonConfigVersion.cmake 
-                @ONLY)
-
-# Define the public headers.
-set_target_properties(jansson PROPERTIES PUBLIC_HEADER "${JANSSON_HDR_PUBLIC}")
-#TODO: fix this.
+configure_package_config_file(
+    "cmake/janssonConfig.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/cmake/janssonConfig.cmake"
+    INSTALL_DESTINATION "${JANSSON_INSTALL_CMAKE_DIR}"
+)

 #
 # Install targets.
 #
 option(JANSSON_INSTALL "Generate installation target" ON)
 if (JANSSON_INSTALL)
-install(TARGETS jansson
-        EXPORT JanssonTargets
-        LIBRARY DESTINATION "${JANSSON_INSTALL_LIB_DIR}" COMPONENT lib
-        ARCHIVE DESTINATION "${JANSSON_INSTALL_LIB_DIR}" COMPONENT lib
-        RUNTIME DESTINATION "${JANSSON_INSTALL_BIN_DIR}" COMPONENT lib # Windows DLLs
-        PUBLIC_HEADER DESTINATION "${JANSSON_INSTALL_INCLUDE_DIR}" COMPONENT dev)
+  install(TARGETS jansson
+          EXPORT janssonTargets
+          LIBRARY DESTINATION "lib"
+          ARCHIVE DESTINATION "lib"
+          RUNTIME DESTINATION "bin"
+          INCLUDES DESTINATION "include")

-# Install the pkg-config.
-install (FILES 
-         ${CMAKE_CURRENT_BINARY_DIR}/jansson.pc
-         DESTINATION ${JANSSON_INSTALL_LIB_DIR}/pkgconfig COMPONENT dev)
+  install(FILES ${JANSSON_HDR_PUBLIC}
+          DESTINATION "include")

-# Install the configs.
-install(FILES
-    ${PROJECT_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}/JanssonConfig.cmake
-    ${PROJECT_BINARY_DIR}/JanssonConfigVersion.cmake
-    DESTINATION "${JANSSON_INSTALL_CMAKE_DIR}" COMPONENT dev)
+  # Install the pkg-config.
+  install(FILES
+          ${CMAKE_CURRENT_BINARY_DIR}/jansson.pc
+          DESTINATION lib/pkgconfig)

-# Install exports for the install-tree.
-install(EXPORT JanssonTargets 
-        DESTINATION "${JANSSON_INSTALL_CMAKE_DIR}" COMPONENT dev)
+  # Install the configs.
+  install(FILES
+      ${CMAKE_CURRENT_BINARY_DIR}/cmake/janssonConfig.cmake
+      ${CMAKE_CURRENT_BINARY_DIR}/cmake/janssonConfigVersion.cmake
+      DESTINATION "${JANSSON_INSTALL_CMAKE_DIR}")
+
+  # Install exports for the install-tree.
+  install(EXPORT janssonTargets
+          NAMESPACE jansson::
+          DESTINATION "${JANSSON_INSTALL_CMAKE_DIR}")
 endif()

 # For use when simply using add_library from a parent project to build jansson.
-set(JANSSON_LIBRARIES jansson CACHE STRING "Jansson libraries")
+set(JANSSON_LIBRARIES jansson CACHE STRING "jansson libraries")
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-Copyright (c) 2009-2016 Petri Lehtinen <petri@digip.org>
+Copyright (c) 2009-2018 Petri Lehtinen <petri@digip.org>

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/README.rst
+++ b/README.rst
@@ -30,8 +30,8 @@ source distribution for details.
 Compilation and Installation
 ----------------------------

-If you obtained a source tarball, just use the standard autotools
-commands::
+If you obtained a `source tarball`_ from the "Releases" section of the main
+site just use the standard autotools commands::

   $ ./configure
   $ make
@@ -65,4 +65,5 @@ Then, point your browser to ``doc/_build/html/index.html``. Sphinx_
 .. _Jansson: http://www.digip.org/jansson/
 .. _`Comprehensive documentation`: http://jansson.readthedocs.io/en/latest/
 .. _`MIT license`: http://www.opensource.org/licenses/mit-license.php
+.. _`source tarball`: http://www.digip.org/jansson#releases
 .. _Sphinx: http://sphinx.pocoo.org/
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -5,6 +5,8 @@ environment:
    - VS: Visual Studio 11 2012
    - VS: Visual Studio 12 2013
    - VS: Visual Studio 14 2015
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      VS: Visual Studio 15 2017

 build_script:
  - md build
--- a/cmake/CodeCoverage.cmake
+++ b/cmake/CodeCoverage.cmake
@@ -110,9 +110,9 @@ FUNCTION(SETUP_TARGET_FOR_COVERAGE _targetname _outputname _testrunner)
 		COMMAND ${_testrunner} ${ARGV3}
 		
 		# Capturing lcov counters and generating report
-		COMMAND ${LCOV_PATH} --directory . --capture --output-file ${_outputname}.info
-		COMMAND ${LCOV_PATH} --remove ${_outputname}.info 'tests/*' '/usr/*' --output-file ${_outputname}.info.cleaned
-		COMMAND ${GENHTML_PATH} -o ${_outputname} ${_outputname}.info.cleaned
+		COMMAND ${LCOV_PATH} --directory . --capture --output-file ${_outputname}.info --rc lcov_branch_coverage=1
+		COMMAND ${LCOV_PATH} --remove ${_outputname}.info '*/build/include/*' '*/test/*' '/usr/include/*' --output-file ${_outputname}.info.cleaned --rc lcov_branch_coverage=1
+		COMMAND ${GENHTML_PATH} --branch-coverage -o ${_outputname} ${_outputname}.info.cleaned
 		COMMAND ${CMAKE_COMMAND} -E remove ${_outputname}.info ${_outputname}.info.cleaned
 		
 		WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
--- a/cmake/JanssonConfig.cmake.in
+++ b/cmake/JanssonConfig.cmake.in
@@ -1,17 +0,0 @@
-# - Config file for the jansson package
-# It defines the following variables
-#  JANSSON_INCLUDE_DIRS - include directories for FooBar
-#  JANSSON_LIBRARIES    - libraries to link against
-
-# Get the path of the current file.
-get_filename_component(JANSSON_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
-
-# Set the include directories.
-set(JANSSON_INCLUDE_DIRS "@JANSSON__INCLUDE_DIRS@")
-
-# Include the project Targets file, this contains definitions for IMPORTED targets.
-include(${JANSSON_CMAKE_DIR}/JanssonTargets.cmake)
-
-# IMPORTED targets from JanssonTargets.cmake
-set(JANSSON_LIBRARIES jansson)
-
--- a/cmake/JanssonConfigVersion.cmake.in
+++ b/cmake/JanssonConfigVersion.cmake.in
@@ -1,11 +0,0 @@
-set(PACKAGE_VERSION "@JANSSON_DISPLAY_VERSION@")
-
-# Check whether the requested PACKAGE_FIND_VERSION is compatible
-if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")
-  set(PACKAGE_VERSION_COMPATIBLE FALSE)
-else()
-  set(PACKAGE_VERSION_COMPATIBLE TRUE)
-  if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}")
-    set(PACKAGE_VERSION_EXACT TRUE)
-  endif()
-endif()	
--- a/cmake/janssonConfig.cmake.in
+++ b/cmake/janssonConfig.cmake.in
@@ -0,0 +1,4 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/janssonTargets.cmake")
+check_required_components("@PROJECT_NAME@")
--- a/cmake/jansson_config.h.cmake
+++ b/cmake/jansson_config.h.cmake
@@ -59,10 +59,16 @@
 /* If locale.h and localeconv() are available, define to 1, otherwise to 0. */
 #define JSON_HAVE_LOCALECONV @JSON_HAVE_LOCALECONV@

+/* If __atomic builtins are available they will be used to manage
+   reference counts of json_t. */
+#define JSON_HAVE_ATOMIC_BUILTINS @JSON_HAVE_ATOMIC_BUILTINS@
+
+/* If __atomic builtins are not available we try using __sync builtins
+   to manage reference counts of json_t. */
+#define JSON_HAVE_SYNC_BUILTINS @JSON_HAVE_SYNC_BUILTINS@

 /* Maximum recursion depth for parsing JSON input.
   This limits the depth of e.g. array-within-array constructions. */
 #define JSON_PARSER_MAX_DEPTH 2048

-
 #endif
--- a/configure.ac
+++ b/configure.ac
@@ -1,5 +1,5 @@
 AC_PREREQ([2.60])
-AC_INIT([jansson], [2.10], [petri@digip.org])
+AC_INIT([jansson], [2.12], [petri@digip.org])

 AC_CONFIG_AUX_DIR([.])
 AM_INIT_AUTOMAKE([1.10 foreign])
@@ -38,25 +38,33 @@ AC_CHECK_FUNCS([close getpid gettimeofday localeconv open read sched_yield strto
 AC_MSG_CHECKING([for gcc __sync builtins])
 have_sync_builtins=no
 AC_TRY_LINK(
-  [], [unsigned long val; __sync_bool_compare_and_swap(&val, 0, 1);],
+  [], [unsigned long val; __sync_bool_compare_and_swap(&val, 0, 1); __sync_add_and_fetch(&val, 1); __sync_sub_and_fetch(&val, 1);],
  [have_sync_builtins=yes],
 )
 if test "x$have_sync_builtins" = "xyes"; then
  AC_DEFINE([HAVE_SYNC_BUILTINS], [1],
    [Define to 1 if gcc's __sync builtins are available])
+  json_have_sync_builtins=1
+else
+  json_have_sync_builtins=0
 fi
+AC_SUBST([json_have_sync_builtins])
 AC_MSG_RESULT([$have_sync_builtins])

 AC_MSG_CHECKING([for gcc __atomic builtins])
 have_atomic_builtins=no
 AC_TRY_LINK(
-  [], [char l; unsigned long v; __atomic_test_and_set(&l, __ATOMIC_RELAXED); __atomic_store_n(&v, 1, __ATOMIC_RELEASE); __atomic_load_n(&v, __ATOMIC_ACQUIRE);],
+  [], [char l; unsigned long v; __atomic_test_and_set(&l, __ATOMIC_RELAXED); __atomic_store_n(&v, 1, __ATOMIC_RELEASE); __atomic_load_n(&v, __ATOMIC_ACQUIRE); __atomic_add_fetch(&v, 1, __ATOMIC_ACQUIRE); __atomic_sub_fetch(&v, 1, __ATOMIC_RELEASE);],
  [have_atomic_builtins=yes],
 )
 if test "x$have_atomic_builtins" = "xyes"; then
  AC_DEFINE([HAVE_ATOMIC_BUILTINS], [1],
    [Define to 1 if gcc's __atomic builtins are available])
+  json_have_atomic_builtins=1
+else
+  json_have_atomic_builtins=0
 fi
+AC_SUBST([json_have_atomic_builtins])
 AC_MSG_RESULT([$have_atomic_builtins])

 case "$ac_cv_type_long_long_int$ac_cv_func_strtoll" in
@@ -99,8 +107,44 @@ AC_ARG_ENABLE([initial-hashtable-order],
 AC_DEFINE_UNQUOTED([INITIAL_HASHTABLE_ORDER], [$initial_hashtable_order],
  [Number of buckets new object hashtables contain is 2 raised to this power. E.g. 3 -> 2^3 = 8.])

+AC_ARG_ENABLE([Bsymbolic],
+  [AS_HELP_STRING([--disable-Bsymbolic],
+    [Avoid linking with -Bsymbolic-function])],
+  [], [with_Bsymbolic=check])
+
+if test "x$with_Bsymbolic" != "xno" ; then
+    AC_MSG_CHECKING([for -Bsymbolic-functions linker flag])
+    saved_LDFLAGS="${LDFLAGS}"
+    LDFLAGS=-Wl,-Bsymbolic-functions
+    AC_TRY_LINK(
+      [], [int main (void) { return 0; }],
+      [AC_MSG_RESULT([yes])
+       have_Bsymbolic=yes],
+      [AC_MSG_RESULT([no])
+       have_Bsymbolic=no]
+    )
+    LDFLAGS="${saved_LDFLAGS}"
+
+    if test "x$with_Bsymbolic" = "xcheck" ; then
+        with_Bsymbolic=$have_Bsymbolic;
+    fi
+    if test "x$with_Bsymbolic:x$have_Bsymbolic" = "xyes:xno" ; then
+        AC_MSG_ERROR([linker support is required for -Bsymbolic])
+    fi
+fi
+
+AS_IF([test "x$with_Bsymbolic" = "xyes"], [JSON_BSYMBOLIC_LDFLAGS=-Wl[,]-Bsymbolic-functions])
+AC_SUBST(JSON_BSYMBOLIC_LDFLAGS)
+
 if test x$GCC = xyes; then
-    AM_CFLAGS="-Wall -Wextra -Wdeclaration-after-statement"
+    AC_MSG_CHECKING(for -Wno-format-truncation)
+    wnoformat_truncation="-Wno-format-truncation"
+    AS_IF([${CC} -Wno-format-truncation -Werror -S -o /dev/null -xc /dev/null > /dev/null 2>&1],
+      [AC_MSG_RESULT(yes)],
+      [AC_MSG_RESULT(no)
+      wnoformat_truncation=""])
+
+    AM_CFLAGS="-Wall -Wextra -Wdeclaration-after-statement -Wshadow ${wnoformat_truncation}"
 fi
 AC_SUBST([AM_CFLAGS])

--- a/doc/apiref.rst
+++ b/doc/apiref.rst
@@ -58,6 +58,11 @@ the library:
      /* Code specific to version 1.3 and above */
      #endif

+``JANSSON_THREAD_SAFE_REFCOUNT``
+  If this value is defined all read-only operations and reference counting in
+  Jansson are thread safe.  This value is not defined for versions older than
+  ``2.11`` or when the compiler does not provide built-in atomic functions.
+

 Value Representation
 ====================
@@ -332,6 +337,8 @@ length-aware functions if you wish to embed null bytes in strings.
   Like :func:`json_string`, but with explicit length, so *value* may
   contain null characters or not be null terminated.

+   .. versionadded:: 2.7
+
 .. function:: json_t *json_string_nocheck(const char *value)

   .. refcounting:: new
@@ -347,6 +354,8 @@ length-aware functions if you wish to embed null bytes in strings.
   Like :func:`json_string_nocheck`, but with explicit length, so
   *value* may contain null characters or not be null terminated.

+   .. versionadded:: 2.7
+
 .. function:: const char *json_string_value(const json_t *string)

   Returns the associated value of *string* as a null terminated UTF-8
@@ -361,6 +370,8 @@ length-aware functions if you wish to embed null bytes in strings.
   Returns the length of *string* in its UTF-8 presentation, or zero
   if *string* is not a JSON string.

+   .. versionadded:: 2.7
+
 .. function:: int json_string_set(json_t *string, const char *value)

   Sets the associated value of *string* to *value*. *value* must be a
@@ -372,6 +383,8 @@ length-aware functions if you wish to embed null bytes in strings.
   Like :func:`json_string_set`, but with explicit length, so *value*
   may contain null characters or not be null terminated.

+   .. versionadded:: 2.7
+
 .. function:: int json_string_set_nocheck(json_t *string, const char *value)

   Like :func:`json_string_set`, but doesn't check that *value* is
@@ -384,6 +397,18 @@ length-aware functions if you wish to embed null bytes in strings.
   Like :func:`json_string_set_nocheck`, but with explicit length,
   so *value* may contain null characters or not be null terminated.

+   .. versionadded:: 2.7
+
+.. function:: json_t *json_sprintf(const char *format, ...)
+              json_t *json_vsprintf(const char *format, va_list ap)
+
+   .. refcounting:: new
+
+   Construct a JSON string from a format string and varargs, just like
+   :func:`printf()`.
+
+   .. versionadded:: 2.11
+

 Number
 ======
@@ -813,6 +838,9 @@ this struct.
      The error message (in UTF-8), or an empty string if a message is
      not available.

+      The last byte of this array contains a numeric error code.  Use
+      :func:`json_error_code()` to extract this code.
+
   .. member:: char source[]

      Source of the error. This can be (a part of) the file name or a
@@ -855,6 +883,97 @@ success. See :ref:`apiref-decoding` for more info.
 All functions also accept *NULL* as the :type:`json_error_t` pointer,
 in which case no error information is returned to the caller.

+.. type:: enum json_error_code
+
+   An enumeration containing numeric error codes.  The following errors are
+   currently defined:
+
+   ``json_error_unknown``
+
+       Unknown error.  This should only be returned for non-errorneous
+       :type:`json_error_t` structures.
+
+   ``json_error_out_of_memory``
+
+       The library couldn’t allocate any heap memory.
+
+   ``json_error_stack_overflow``
+
+       Nesting too deep.
+
+   ``json_error_cannot_open_file``
+
+       Couldn’t open input file.
+
+   ``json_error_invalid_argument``
+
+       A function argument was invalid.
+
+   ``json_error_invalid_utf8``
+
+       The input string isn’t valid UTF-8.
+
+   ``json_error_premature_end_of_input``
+
+       The input ended in the middle of a JSON value.
+
+   ``json_error_end_of_input_expected``
+
+       There was some text after the end of a JSON value.  See the
+       ``JSON_DISABLE_EOF_CHECK`` flag.
+
+   ``json_error_invalid_syntax``
+
+       JSON syntax error.
+
+   ``json_error_invalid_format``
+
+       Invalid format string for packing or unpacking.
+
+   ``json_error_wrong_type``
+
+       When packing or unpacking, the actual type of a value differed from the
+       one specified in the format string.
+
+   ``json_error_null_character``
+
+       A null character was detected in a JSON string.  See the
+       ``JSON_ALLOW_NUL`` flag.
+
+   ``json_error_null_value``
+
+       When packing or unpacking, some key or value was ``NULL``.
+
+   ``json_error_null_byte_in_key``
+
+       An object key would contain a null byte.  Jansson can’t represent such
+       keys; see :ref:`rfc-conformance`.
+
+   ``json_error_duplicate_key``
+
+       Duplicate key in object.  See the ``JSON_REJECT_DUPLICATES`` flag.
+
+   ``json_error_numeric_overflow``
+
+       When converting a JSON number to a C numeric type, a numeric overflow
+       was detected.
+
+   ``json_error_item_not_found``
+
+       Key in object not found.
+
+   ``json_error_index_out_of_range``
+
+       Array index is out of range.
+
+   .. versionadded:: 2.11
+
+.. function:: enum json_error_code json_error_code(const json_error_t *error)
+
+   Returns the error code embedded in ``error->text``.
+
+   .. versionadded:: 2.11
+

 Encoding
 ========
@@ -1019,6 +1138,10 @@ These functions output UTF-8:
   the length of the buffer, and *data* is the corresponding
   :func:`json_dump_callback()` argument passed through.

+   *buffer* is guaranteed to be a valid UTF-8 string (i.e. multi-byte
+   code unit sequences are preserved). *buffer* never contains
+   embedded null bytes.
+
   On error, the function should return -1 to stop the encoding
   process. On success, it should return 0.

@@ -1214,11 +1337,19 @@ If no error or position information is needed, you can pass *NULL*.
   *buffer* points to a buffer of *buflen* bytes, and *data* is the
   corresponding :func:`json_load_callback()` argument passed through.

-   On success, the function should return the number of bytes read; a
-   returned value of 0 indicates that no data was read and that the
-   end of file has been reached. On error, the function should return
+   On success, the function should write at most *buflen* bytes to
+   *buffer*, and return the number of bytes written; a returned value
+   of 0 indicates that no data was produced and that the end of file
+   has been reached. On error, the function should return
   ``(size_t)-1`` to abort the decoding process.

+   In UTF-8, some code points are encoded as multi-byte sequences. The
+   callback function doesn't need to worry about this, as Jansson
+   handles it at a higher level. For example, you can safely read a
+   fixed number of bytes from a network connection without having to
+   care about code unit sequences broken apart by the chunk
+   boundaries.
+
   .. versionadded:: 2.4

 .. function:: json_t *json_load_callback(json_load_callback_t callback, void *data, size_t flags, json_error_t *error)
@@ -1269,6 +1400,14 @@ arguments.

    .. versionadded:: 2.8

+``s*`` (string) [const char \*]
+    Like ``s``, but if the argument is *NULL*, do not output any value.
+    This format can only be used inside an object or an array. If used
+    inside an object, the corresponding key is additionally suppressed
+    when the value is omitted. See below for an example.
+
+    .. versionadded:: 2.11
+
 ``s#`` (string) [const char \*, int]
    Convert a UTF-8 buffer of a given length to a JSON string.

@@ -1324,11 +1463,20 @@ arguments.
    yourself.

 ``o?``, ``O?`` (any value) [json_t \*]
-    Like ``o`` and ``O?``, respectively, but if the argument is
+    Like ``o`` and ``O``, respectively, but if the argument is
    *NULL*, output a JSON null value.

    .. versionadded:: 2.8

+``o*``, ``O*`` (any value) [json_t \*]
+    Like ``o`` and ``O``, respectively, but if the argument is
+    *NULL*, do not output any value. This format can only be used
+    inside an object or an array. If used inside an object, the
+    corresponding key is additionally suppressed. See below for an
+    example.
+
+    .. versionadded:: 2.11
+
 ``[fmt]`` (array)
    Build an array with contents from the inner format string. ``fmt``
    may contain objects and arrays, i.e. recursive value building is
@@ -1387,6 +1535,10 @@ More examples::
  /* Concatenate strings together to build the JSON string "foobarbaz" */
  json_pack("s++", "foo", "bar", "baz");

+  /* Create an empty object or array when optional members are missing */
+  json_pack("{s:s*,s:o*,s:O*}", "foo", NULL, "bar", NULL, "baz", NULL);
+  json_pack("[s*,o*,O*]", NULL, NULL, NULL);
+

 .. _apiref-unpack:

@@ -1443,7 +1595,10 @@ type whose address should be passed.
    Store a JSON value with no conversion to a :type:`json_t` pointer.

 ``O`` (any value) [json_t \*]
-    Like ``O``, but the JSON value's reference count is incremented.
+    Like ``o``, but the JSON value's reference count is incremented.
+    Storage pointers should be initialized NULL before using unpack.
+    The caller is responsible for releasing all references incremented
+    by unpack, even when an error occurs.

 ``[fmt]`` (array)
    Convert each item in the JSON array according to the inner format
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -48,7 +48,7 @@ copyright = u'2009-2016, Petri Lehtinen'
 # built documents.
 #
 # The short X.Y version.
-version = '2.10'
+version = '2.12'
 # The full version, including alpha/beta/rc tags.
 release = version

--- a/doc/gettingstarted.rst
+++ b/doc/gettingstarted.rst
@@ -101,7 +101,22 @@ Creating Visual Studio project files from the command line:

    md build
    cd build
-    cmake -G "Visual Studio 10" ..
+    cmake -G "Visual Studio 15 2017" ..
+
+.. note::
+
+   You should replace the name of the generator (``-G`` flag) matching
+   the Visual Studio version installed on your system. Currently, the
+   following versions are supported:
+
+   - ``Visual Studio 9 2008``
+   - ``Visual Studio 10 2010``
+   - ``Visual Studio 11 2012``
+   - ``Visual Studio 12 2013``
+   - ``Visual Studio 14 2015``
+   - ``Visual Studio 15 2017``
+
+   Any later version should also work.

 You will now have a *Visual Studio Solution* in your build directory.
 To run the unit tests build the ``RUN_TESTS`` project.
--- a/doc/portability.rst
+++ b/doc/portability.rst
@@ -7,29 +7,31 @@ Portability
 Thread safety
 -------------

-Jansson is thread safe and has no mutable global state. The only
-exceptions are the hash function seed and memory allocation functions,
-see below.
+Jansson as a library is thread safe and has no mutable global state.
+The only exceptions are the hash function seed and memory allocation
+functions, see below.

-There's no locking performed inside Jansson's code, so a multithreaded
-program must perform its own locking if JSON values are shared by
-multiple threads. Jansson's reference counting semantics may make this
-a bit harder than it seems, as it's possible to have a reference to a
-value that's also stored inside a list or object. Modifying the
-container (adding or removing values) may trigger concurrent access to
-such values, as containers manage the reference count of their
-contained values. Bugs involving concurrent incrementing or
-decrementing of deference counts may be hard to track.
+There's no locking performed inside Jansson's code. **Read-only**
+access to JSON values shared by multiple threads is safe, but
+**mutating** a JSON value that's shared by multiple threads is not. A
+multithreaded program must perform its own locking if JSON values
+shared by multiple threads are mutated.

-The encoding functions (:func:`json_dumps()` and friends) track
-reference loops by modifying the internal state of objects and arrays.
-For this reason, encoding functions must not be run on the same JSON
-values in two separate threads at the same time. As already noted
-above, be especially careful if two arrays or objects share their
-contained values with another array or object.
+However, **reference count manipulation** (:func:`json_incref()`,
+:func:`json_decref()`) is usually thread-safe, and can be performed on
+JSON values that are shared among threads. The thread-safety of
+reference counting can be checked with the
+``JANSSON_THREAD_SAFE_REFCOUNT`` preprocessor constant. Thread-safe
+reference count manipulation is achieved using compiler built-in
+atomic functions, which are available in most modern compilers.

-If you want to make sure that two JSON value hierarchies do not
-contain shared values, use :func:`json_deep_copy()` to make copies.
+If compiler support is not available (``JANSSON_THREAD_SAFE_REFCOUNT``
+is not defined), it may be very difficult to ensure thread safety of
+reference counting. It's possible to have a reference to a value
+that's also stored inside an array or object in another thread.
+Modifying the container (adding or removing values) may trigger
+concurrent access to such values, as containers manage the reference
+count of their contained values.


 Hash function seed
--- a/doc/tutorial.rst
+++ b/doc/tutorial.rst
@@ -10,7 +10,7 @@ In this tutorial, we create a program that fetches the latest commits
 of a repository in GitHub_ over the web. `GitHub API`_ uses JSON, so
 the result can be parsed using Jansson.

-To stick to the the scope of this tutorial, we will only cover the the
+To stick to the scope of this tutorial, we will only cover the
 parts of the program related to handling JSON data. For the best user
 experience, the full source code is available:
 :download:`github_commits.c`. To compile it (on Unix-like systems with
@@ -238,7 +238,7 @@ from a JSON string using :func:`json_string_value()`::

        message_text = json_string_value(message);
        printf("%.8s %.*s\n",
-               json_string_value(id),
+               json_string_value(sha),
               newline_offset(message_text),
               message_text);
    }
--- a/jansson.pc.in
+++ b/jansson.pc.in
@@ -1,7 +1,7 @@
 prefix=@prefix@
 exec_prefix=@exec_prefix@
 libdir=@libdir@
-includedir=${prefix}/include
+includedir=@includedir@

 Name: Jansson
 Description: Library for encoding, decoding and manipulating JSON data
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -24,4 +24,5 @@ libjansson_la_SOURCES = \
 libjansson_la_LDFLAGS = \
 	-no-undefined \
 	-export-symbols-regex '^json_' \
-	-version-info 14:0:10
+	-version-info 15:1:11 \
+	@JSON_BSYMBOLIC_LDFLAGS@
--- a/src/dump.c
+++ b/src/dump.c
@@ -61,8 +61,8 @@ static int dump_to_file(const char *buffer, size_t size, void *data)

 static int dump_to_fd(const char *buffer, size_t size, void *data)
 {
-    int *dest = (int *)data;
 #ifdef HAVE_UNISTD_H
+    int *dest = (int *)data;
    if(write(*dest, buffer, size) == (ssize_t)size)
        return 0;
 #endif
@@ -101,7 +101,7 @@ static int dump_indent(size_t flags, int depth, int space, json_dump_callback_t
 static int dump_string(const char *str, size_t len, json_dump_callback_t dump, void *data, size_t flags)
 {
    const char *pos, *end, *lim;
-    int32_t codepoint;
+    int32_t codepoint = 0;

    if(dump("\"", 1, data))
        return -1;
@@ -196,8 +196,17 @@ static int compare_keys(const void *key1, const void *key2)
    return strcmp(*(const char **)key1, *(const char **)key2);
 }

+static int loop_check(hashtable_t *parents, const json_t *json, char *key, size_t key_size)
+{
+    snprintf(key, key_size, "%p", json);
+    if (hashtable_get(parents, key))
+        return -1;
+
+    return hashtable_set(parents, key, json_null());
+}
+
 static int do_dump(const json_t *json, size_t flags, int depth,
-                   json_dump_callback_t dump, void *data)
+                   hashtable_t *parents, json_dump_callback_t dump, void *data)
 {
    int embed = flags & JSON_EMBED;

@@ -251,58 +260,53 @@ static int do_dump(const json_t *json, size_t flags, int depth,
        {
            size_t n;
            size_t i;
-
-            json_array_t *array;
+            /* Space for "0x", double the sizeof a pointer for the hex and a terminator. */
+            char key[2 + (sizeof(json) * 2) + 1];

            /* detect circular references */
-            array = json_to_array(json);
-            if(array->visited)
-                goto array_error;
-            array->visited = 1;
+            if (loop_check(parents, json, key, sizeof(key)))
+                return -1;

            n = json_array_size(json);

            if(!embed && dump("[", 1, data))
-                goto array_error;
+                return -1;
            if(n == 0) {
-                array->visited = 0;
+                hashtable_del(parents, key);
                return embed ? 0 : dump("]", 1, data);
            }
            if(dump_indent(flags, depth + 1, 0, dump, data))
-                goto array_error;
+                return -1;

            for(i = 0; i < n; ++i) {
                if(do_dump(json_array_get(json, i), flags, depth + 1,
-                           dump, data))
-                    goto array_error;
+                           parents, dump, data))
+                    return -1;

                if(i < n - 1)
                {
                    if(dump(",", 1, data) ||
                       dump_indent(flags, depth + 1, 1, dump, data))
-                        goto array_error;
+                        return -1;
                }
                else
                {
                    if(dump_indent(flags, depth, 0, dump, data))
-                        goto array_error;
+                        return -1;
                }
            }

-            array->visited = 0;
+            hashtable_del(parents, key);
            return embed ? 0 : dump("]", 1, data);
-
-        array_error:
-            array->visited = 0;
-            return -1;
        }

        case JSON_OBJECT:
        {
-            json_object_t *object;
            void *iter;
            const char *separator;
            int separator_length;
+            /* Space for "0x", double the sizeof a pointer for the hex and a terminator. */
+            char loop_key[2 + (sizeof(json) * 2) + 1];

            if(flags & JSON_COMPACT) {
                separator = ":";
@@ -314,21 +318,19 @@ static int do_dump(const json_t *json, size_t flags, int depth,
            }

            /* detect circular references */
-            object = json_to_object(json);
-            if(object->visited)
-                goto object_error;
-            object->visited = 1;
+            if (loop_check(parents, json, loop_key, sizeof(loop_key)))
+                return -1;

            iter = json_object_iter((json_t *)json);

            if(!embed && dump("{", 1, data))
-                goto object_error;
+                return -1;
            if(!iter) {
-                object->visited = 0;
+                hashtable_del(parents, loop_key);
                return embed ? 0 : dump("}", 1, data);
            }
            if(dump_indent(flags, depth + 1, 0, dump, data))
-                goto object_error;
+                return -1;

            if(flags & JSON_SORT_KEYS)
            {
@@ -338,7 +340,7 @@ static int do_dump(const json_t *json, size_t flags, int depth,
                size = json_object_size(json);
                keys = jsonp_malloc(size * sizeof(const char *));
                if(!keys)
-                    goto object_error;
+                    return -1;

                i = 0;
                while(iter)
@@ -362,10 +364,10 @@ static int do_dump(const json_t *json, size_t flags, int depth,

                    dump_string(key, strlen(key), dump, data, flags);
                    if(dump(separator, separator_length, data) ||
-                       do_dump(value, flags, depth + 1, dump, data))
+                       do_dump(value, flags, depth + 1, parents, dump, data))
                    {
                        jsonp_free(keys);
-                        goto object_error;
+                        return -1;
                    }

                    if(i < size - 1)
@@ -374,7 +376,7 @@ static int do_dump(const json_t *json, size_t flags, int depth,
                           dump_indent(flags, depth + 1, 1, dump, data))
                        {
                            jsonp_free(keys);
-                            goto object_error;
+                            return -1;
                        }
                    }
                    else
@@ -382,7 +384,7 @@ static int do_dump(const json_t *json, size_t flags, int depth,
                        if(dump_indent(flags, depth, 0, dump, data))
                        {
                            jsonp_free(keys);
-                            goto object_error;
+                            return -1;
                        }
                    }
                }
@@ -401,31 +403,27 @@ static int do_dump(const json_t *json, size_t flags, int depth,
                    dump_string(key, strlen(key), dump, data, flags);
                    if(dump(separator, separator_length, data) ||
                       do_dump(json_object_iter_value(iter), flags, depth + 1,
-                               dump, data))
-                        goto object_error;
+                               parents, dump, data))
+                        return -1;

                    if(next)
                    {
                        if(dump(",", 1, data) ||
                           dump_indent(flags, depth + 1, 1, dump, data))
-                            goto object_error;
+                            return -1;
                    }
                    else
                    {
                        if(dump_indent(flags, depth, 0, dump, data))
-                            goto object_error;
+                            return -1;
                    }

                    iter = next;
                }
            }

-            object->visited = 0;
+            hashtable_del(parents, loop_key);
            return embed ? 0 : dump("}", 1, data);
-
-        object_error:
-            object->visited = 0;
-            return -1;
        }

        default:
@@ -481,16 +479,26 @@ int json_dump_file(const json_t *json, const char *path, size_t flags)

    result = json_dumpf(json, output, flags);

-    fclose(output);
+    if(fclose(output) != 0)
+        return -1;
+
    return result;
 }

 int json_dump_callback(const json_t *json, json_dump_callback_t callback, void *data, size_t flags)
 {
+    int res;
+    hashtable_t parents_set;
+
    if(!(flags & JSON_ENCODE_ANY)) {
        if(!json_is_array(json) && !json_is_object(json))
           return -1;
    }

-    return do_dump(json, flags, 0, callback, data);
+    if (hashtable_init(&parents_set))
+        return -1;
+    res = do_dump(json, flags, 0, &parents_set, callback, data);
+    hashtable_close(&parents_set);
+
+    return res;
 }
--- a/src/error.c
+++ b/src/error.c
@@ -28,23 +28,25 @@ void jsonp_error_set_source(json_error_t *error, const char *source)
        strncpy(error->source, source, length + 1);
    else {
        size_t extra = length - JSON_ERROR_SOURCE_LENGTH + 4;
-        strncpy(error->source, "...", 3);
+        memcpy(error->source, "...", 3);
        strncpy(error->source + 3, source + extra, length - extra + 1);
    }
 }

 void jsonp_error_set(json_error_t *error, int line, int column,
-                     size_t position, const char *msg, ...)
+                     size_t position, enum json_error_code code,
+                     const char *msg, ...)
 {
    va_list ap;

    va_start(ap, msg);
-    jsonp_error_vset(error, line, column, position, msg, ap);
+    jsonp_error_vset(error, line, column, position, code, msg, ap);
    va_end(ap);
 }

 void jsonp_error_vset(json_error_t *error, int line, int column,
-                      size_t position, const char *msg, va_list ap)
+                      size_t position, enum json_error_code code,
+                      const char *msg, va_list ap)
 {
    if(!error)
        return;
@@ -58,6 +60,7 @@ void jsonp_error_vset(json_error_t *error, int line, int column,
    error->column = column;
    error->position = (int)position;

-    vsnprintf(error->text, JSON_ERROR_TEXT_LENGTH, msg, ap);
-    error->text[JSON_ERROR_TEXT_LENGTH - 1] = '\0';
+    vsnprintf(error->text, JSON_ERROR_TEXT_LENGTH - 1, msg, ap);
+    error->text[JSON_ERROR_TEXT_LENGTH - 2] = '\0';
+    error->text[JSON_ERROR_TEXT_LENGTH - 1] = code;
 }
--- a/src/hashtable.h
+++ b/src/hashtable.h
@@ -55,7 +55,7 @@ typedef struct hashtable {
 *
 * Returns 0 on success, -1 on error (out of memory).
 */
-int hashtable_init(hashtable_t *hashtable);
+int hashtable_init(hashtable_t *hashtable) JANSSON_ATTRS(warn_unused_result);

 /**
 * hashtable_close - Release all resources used by a hashtable object
--- a/src/hashtable_seed.c
+++ b/src/hashtable_seed.c
@@ -164,7 +164,7 @@ static int seed_from_timestamp_and_pid(uint32_t *seed) {
 }

 static uint32_t generate_seed() {
-    uint32_t seed;
+    uint32_t seed = 0;
    int done = 0;

 #if !defined(_WIN32) && defined(USE_URANDOM)
--- a/src/jansson.def
+++ b/src/jansson.def
@@ -3,6 +3,8 @@ EXPORTS
    json_true
    json_false
    json_null
+    json_sprintf
+    json_vsprintf
    json_string
    json_stringn
    json_string_nocheck
--- a/src/jansson.h
+++ b/src/jansson.h
@@ -21,11 +21,11 @@ extern "C" {
 /* version */

 #define JANSSON_MAJOR_VERSION  2
-#define JANSSON_MINOR_VERSION  10
+#define JANSSON_MINOR_VERSION  12
 #define JANSSON_MICRO_VERSION  0

 /* Micro version is omitted if it's 0 */
-#define JANSSON_VERSION  "2.10"
+#define JANSSON_VERSION  "2.12"

 /* Version as a 3-byte hex number, e.g. 0x010201 == 1.2.1. Use this
   for numeric comparisons, e.g. #if JANSSON_VERSION_HEX >= ... */
@@ -33,6 +33,17 @@ extern "C" {
                              (JANSSON_MINOR_VERSION << 8)  |   \
                              (JANSSON_MICRO_VERSION << 0))

+/* If __atomic or __sync builtins are available the library is thread
+ * safe for all read-only functions plus reference counting. */
+#if JSON_HAVE_ATOMIC_BUILTINS || JSON_HAVE_SYNC_BUILTINS
+#define JANSSON_THREAD_SAFE_REFCOUNT 1
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+#define JANSSON_ATTRS(...) __attribute__((__VA_ARGS__))
+#else
+#define JANSSON_ATTRS(...)
+#endif

 /* types */

@@ -49,7 +60,7 @@ typedef enum {

 typedef struct json_t {
    json_type type;
-    size_t refcount;
+    volatile size_t refcount;
 } json_t;

 #ifndef JANSSON_USING_CMAKE /* disabled if using cmake */
@@ -94,11 +105,23 @@ json_t *json_false(void);
 #define json_boolean(val)      ((val) ? json_true() : json_false())
 json_t *json_null(void);

+/* do not call JSON_INTERNAL_INCREF or JSON_INTERNAL_DECREF directly */
+#if JSON_HAVE_ATOMIC_BUILTINS
+#define JSON_INTERNAL_INCREF(json) __atomic_add_fetch(&json->refcount, 1, __ATOMIC_ACQUIRE)
+#define JSON_INTERNAL_DECREF(json) __atomic_sub_fetch(&json->refcount, 1, __ATOMIC_RELEASE)
+#elif JSON_HAVE_SYNC_BUILTINS
+#define JSON_INTERNAL_INCREF(json) __sync_add_and_fetch(&json->refcount, 1)
+#define JSON_INTERNAL_DECREF(json) __sync_sub_and_fetch(&json->refcount, 1)
+#else
+#define JSON_INTERNAL_INCREF(json) (++json->refcount)
+#define JSON_INTERNAL_DECREF(json) (--json->refcount)
+#endif
+
 static JSON_INLINE
 json_t *json_incref(json_t *json)
 {
    if(json && json->refcount != (size_t)-1)
-        ++json->refcount;
+        JSON_INTERNAL_INCREF(json);
    return json;
 }

@@ -108,7 +131,7 @@ void json_delete(json_t *json);
 static JSON_INLINE
 void json_decref(json_t *json)
 {
-    if(json && json->refcount != (size_t)-1 && --json->refcount == 0)
+    if(json && json->refcount != (size_t)-1 && JSON_INTERNAL_DECREF(json) == 0)
        json_delete(json);
 }

@@ -131,7 +154,7 @@ void json_decrefp(json_t **json)
 #define JSON_ERROR_TEXT_LENGTH    160
 #define JSON_ERROR_SOURCE_LENGTH   80

-typedef struct {
+typedef struct json_error_t {
    int line;
    int column;
    int position;
@@ -139,12 +162,36 @@ typedef struct {
    char text[JSON_ERROR_TEXT_LENGTH];
 } json_error_t;

+enum json_error_code {
+    json_error_unknown,
+    json_error_out_of_memory,
+    json_error_stack_overflow,
+    json_error_cannot_open_file,
+    json_error_invalid_argument,
+    json_error_invalid_utf8,
+    json_error_premature_end_of_input,
+    json_error_end_of_input_expected,
+    json_error_invalid_syntax,
+    json_error_invalid_format,
+    json_error_wrong_type,
+    json_error_null_character,
+    json_error_null_value,
+    json_error_null_byte_in_key,
+    json_error_duplicate_key,
+    json_error_numeric_overflow,
+    json_error_item_not_found,
+    json_error_index_out_of_range
+};
+
+static JSON_INLINE enum json_error_code json_error_code(const json_error_t *e) {
+    return (enum json_error_code)e->text[JSON_ERROR_TEXT_LENGTH - 1];
+}

 /* getters, setters, manipulation */

 void json_object_seed(size_t seed);
 size_t json_object_size(const json_t *object);
-json_t *json_object_get(const json_t *object, const char *key);
+json_t *json_object_get(const json_t *object, const char *key) JANSSON_ATTRS(warn_unused_result);
 int json_object_set_new(json_t *object, const char *key, json_t *value);
 int json_object_set_new_nocheck(json_t *object, const char *key, json_t *value);
 int json_object_del(json_t *object, const char *key);
@@ -196,7 +243,7 @@ int json_object_iter_set(json_t *object, void *iter, json_t *value)
 }

 size_t json_array_size(const json_t *array);
-json_t *json_array_get(const json_t *array, size_t index);
+json_t *json_array_get(const json_t *array, size_t index) JANSSON_ATTRS(warn_unused_result);
 int json_array_set_new(json_t *array, size_t index, json_t *value);
 int json_array_append_new(json_t *array, json_t *value);
 int json_array_insert_new(json_t *array, size_t index, json_t *value);
@@ -237,9 +284,9 @@ int json_real_set(json_t *real, double value);

 /* pack, unpack */

-json_t *json_pack(const char *fmt, ...);
-json_t *json_pack_ex(json_error_t *error, size_t flags, const char *fmt, ...);
-json_t *json_vpack_ex(json_error_t *error, size_t flags, const char *fmt, va_list ap);
+json_t *json_pack(const char *fmt, ...) JANSSON_ATTRS(warn_unused_result);
+json_t *json_pack_ex(json_error_t *error, size_t flags, const char *fmt, ...) JANSSON_ATTRS(warn_unused_result);
+json_t *json_vpack_ex(json_error_t *error, size_t flags, const char *fmt, va_list ap) JANSSON_ATTRS(warn_unused_result);

 #define JSON_VALIDATE_ONLY  0x1
 #define JSON_STRICT         0x2
@@ -248,16 +295,21 @@ int json_unpack(json_t *root, const char *fmt, ...);
 int json_unpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, ...);
 int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, va_list ap);

+/* sprintf */
+
+json_t *json_sprintf(const char *fmt, ...) JANSSON_ATTRS(warn_unused_result, format(printf, 1, 2));
+json_t *json_vsprintf(const char *fmt, va_list ap) JANSSON_ATTRS(warn_unused_result, format(printf, 1, 0));
+

 /* equality */

-int json_equal(json_t *value1, json_t *value2);
+int json_equal(const json_t *value1, const json_t *value2);


 /* copying */

-json_t *json_copy(json_t *value);
-json_t *json_deep_copy(const json_t *value);
+json_t *json_copy(json_t *value) JANSSON_ATTRS(warn_unused_result);
+json_t *json_deep_copy(const json_t *value) JANSSON_ATTRS(warn_unused_result);


 /* decoding */
@@ -270,12 +322,12 @@ json_t *json_deep_copy(const json_t *value);

 typedef size_t (*json_load_callback_t)(void *buffer, size_t buflen, void *data);

-json_t *json_loads(const char *input, size_t flags, json_error_t *error);
-json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t *error);
-json_t *json_loadf(FILE *input, size_t flags, json_error_t *error);
-json_t *json_loadfd(int input, size_t flags, json_error_t *error);
-json_t *json_load_file(const char *path, size_t flags, json_error_t *error);
-json_t *json_load_callback(json_load_callback_t callback, void *data, size_t flags, json_error_t *error);
+json_t *json_loads(const char *input, size_t flags, json_error_t *error) JANSSON_ATTRS(warn_unused_result);
+json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t *error) JANSSON_ATTRS(warn_unused_result);
+json_t *json_loadf(FILE *input, size_t flags, json_error_t *error) JANSSON_ATTRS(warn_unused_result);
+json_t *json_loadfd(int input, size_t flags, json_error_t *error) JANSSON_ATTRS(warn_unused_result);
+json_t *json_load_file(const char *path, size_t flags, json_error_t *error) JANSSON_ATTRS(warn_unused_result);
+json_t *json_load_callback(json_load_callback_t callback, void *data, size_t flags, json_error_t *error) JANSSON_ATTRS(warn_unused_result);


 /* encoding */
@@ -293,7 +345,7 @@ json_t *json_load_callback(json_load_callback_t callback, void *data, size_t fla

 typedef int (*json_dump_callback_t)(const char *buffer, size_t size, void *data);

-char *json_dumps(const json_t *json, size_t flags);
+char *json_dumps(const json_t *json, size_t flags) JANSSON_ATTRS(warn_unused_result);
 size_t json_dumpb(const json_t *json, char *buffer, size_t size, size_t flags);
 int json_dumpf(const json_t *json, FILE *output, size_t flags);
 int json_dumpfd(const json_t *json, int output, size_t flags);
--- a/src/jansson_config.h.in
+++ b/src/jansson_config.h.in
@@ -36,6 +36,14 @@
   otherwise to 0. */
 #define JSON_HAVE_LOCALECONV @json_have_localeconv@

+/* If __atomic builtins are available they will be used to manage
+   reference counts of json_t. */
+#define JSON_HAVE_ATOMIC_BUILTINS @json_have_atomic_builtins@
+
+/* If __atomic builtins are not available we try using __sync builtins
+   to manage reference counts of json_t. */
+#define JSON_HAVE_SYNC_BUILTINS @json_have_sync_builtins@
+
 /* Maximum recursion depth for parsing JSON input.
   This limits the depth of e.g. array-within-array constructions. */
 #define JSON_PARSER_MAX_DEPTH 2048
--- a/src/jansson_private.h
+++ b/src/jansson_private.h
@@ -35,7 +35,6 @@
 typedef struct {
    json_t json;
    hashtable_t hashtable;
-    int visited;
 } json_object_t;

 typedef struct {
@@ -43,7 +42,6 @@ typedef struct {
    size_t size;
    size_t entries;
    json_t **table;
-    int visited;
 } json_array_t;

 typedef struct {
@@ -75,20 +73,22 @@ json_t *jsonp_stringn_nocheck_own(const char *value, size_t len);
 void jsonp_error_init(json_error_t *error, const char *source);
 void jsonp_error_set_source(json_error_t *error, const char *source);
 void jsonp_error_set(json_error_t *error, int line, int column,
-                     size_t position, const char *msg, ...);
+                     size_t position, enum json_error_code code,
+                     const char *msg, ...);
 void jsonp_error_vset(json_error_t *error, int line, int column,
-                      size_t position, const char *msg, va_list ap);
+                      size_t position, enum json_error_code code,
+                      const char *msg, va_list ap);

 /* Locale independent string<->double conversions */
 int jsonp_strtod(strbuffer_t *strbuffer, double *out);
 int jsonp_dtostr(char *buffer, size_t size, double value, int prec);

 /* Wrappers for custom memory functions */
-void* jsonp_malloc(size_t size);
+void* jsonp_malloc(size_t size) JANSSON_ATTRS(warn_unused_result);
 void jsonp_free(void *ptr);
-char *jsonp_strndup(const char *str, size_t length);
-char *jsonp_strdup(const char *str);
-char *jsonp_strndup(const char *str, size_t len);
+char *jsonp_strndup(const char *str, size_t length) JANSSON_ATTRS(warn_unused_result);
+char *jsonp_strdup(const char *str) JANSSON_ATTRS(warn_unused_result);
+char *jsonp_strndup(const char *str, size_t len) JANSSON_ATTRS(warn_unused_result);


 /* Windows compatibility */
--- a/src/load.c
+++ b/src/load.c
@@ -84,6 +84,7 @@ typedef struct {
 /*** error reporting ***/

 static void error_set(json_error_t *error, const lex_t *lex,
+                      enum json_error_code code,
                      const char *msg, ...)
 {
    va_list ap;
@@ -121,6 +122,10 @@ static void error_set(json_error_t *error, const lex_t *lex,
        }
        else
        {
+            if(code == json_error_invalid_syntax) {
+                /* More specific error code for premature end of file. */
+                code = json_error_premature_end_of_input;
+            }
            if(lex->stream.state == STREAM_STATE_ERROR) {
                /* No context for UTF-8 decoding errors */
                result = msg_text;
@@ -134,7 +139,7 @@ static void error_set(json_error_t *error, const lex_t *lex,
        }
    }

-    jsonp_error_set(error, line, col, pos, "%s", result);
+    jsonp_error_set(error, line, col, pos, code, "%s", result);
 }


@@ -213,7 +218,7 @@ static int stream_get(stream_t *stream, json_error_t *error)

 out:
    stream->state = STREAM_STATE_ERROR;
-    error_set(error, stream_to_lex(stream), "unable to decode byte 0x%x", c);
+    error_set(error, stream_to_lex(stream), json_error_invalid_utf8, "unable to decode byte 0x%x", c);
    return STREAM_STATE_ERROR;
 }

@@ -336,7 +341,7 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
            goto out;

        else if(c == STREAM_STATE_EOF) {
-            error_set(error, lex, "premature end of input");
+            error_set(error, lex, json_error_premature_end_of_input, "premature end of input");
            goto out;
        }

@@ -344,9 +349,9 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
            /* control character */
            lex_unget_unsave(lex, c);
            if(c == '\n')
-                error_set(error, lex, "unexpected newline");
+                error_set(error, lex, json_error_invalid_syntax, "unexpected newline");
            else
-                error_set(error, lex, "control character 0x%x", c);
+                error_set(error, lex, json_error_invalid_syntax, "control character 0x%x", c);
            goto out;
        }

@@ -356,7 +361,7 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
                c = lex_get_save(lex, error);
                for(i = 0; i < 4; i++) {
                    if(!l_isxdigit(c)) {
-                        error_set(error, lex, "invalid escape");
+                        error_set(error, lex, json_error_invalid_syntax, "invalid escape");
                        goto out;
                    }
                    c = lex_get_save(lex, error);
@@ -366,7 +371,7 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
                    c == 'f' || c == 'n' || c == 'r' || c == 't')
                c = lex_get_save(lex, error);
            else {
-                error_set(error, lex, "invalid escape");
+                error_set(error, lex, json_error_invalid_syntax, "invalid escape");
                goto out;
            }
        }
@@ -400,7 +405,7 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)

                value = decode_unicode_escape(p);
                if(value < 0) {
-                    error_set(error, lex, "invalid Unicode escape '%.6s'", p - 1);
+                    error_set(error, lex, json_error_invalid_syntax, "invalid Unicode escape '%.6s'", p - 1);
                    goto out;
                }
                p += 5;
@@ -410,7 +415,7 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
                    if(*p == '\\' && *(p + 1) == 'u') {
                        int32_t value2 = decode_unicode_escape(++p);
                        if(value2 < 0) {
-                            error_set(error, lex, "invalid Unicode escape '%.6s'", p - 1);
+                            error_set(error, lex, json_error_invalid_syntax, "invalid Unicode escape '%.6s'", p - 1);
                            goto out;
                        }
                        p += 5;
@@ -425,6 +430,7 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
                        else {
                            /* invalid second surrogate */
                            error_set(error, lex,
+                                      json_error_invalid_syntax,
                                      "invalid Unicode '\\u%04X\\u%04X'",
                                      value, value2);
                            goto out;
@@ -432,13 +438,13 @@ static void lex_scan_string(lex_t *lex, json_error_t *error)
                    }
                    else {
                        /* no second surrogate */
-                        error_set(error, lex, "invalid Unicode '\\u%04X'",
+                        error_set(error, lex, json_error_invalid_syntax, "invalid Unicode '\\u%04X'",
                                  value);
                        goto out;
                    }
                }
                else if(0xDC00 <= value && value <= 0xDFFF) {
-                    error_set(error, lex, "invalid Unicode '\\u%04X'", value);
+                    error_set(error, lex, json_error_invalid_syntax, "invalid Unicode '\\u%04X'", value);
                    goto out;
                }

@@ -526,9 +532,9 @@ static int lex_scan_number(lex_t *lex, int c, json_error_t *error)
        intval = json_strtoint(saved_text, &end, 10);
        if(errno == ERANGE) {
            if(intval < 0)
-                error_set(error, lex, "too big negative integer");
+                error_set(error, lex, json_error_numeric_overflow, "too big negative integer");
            else
-                error_set(error, lex, "too big integer");
+                error_set(error, lex, json_error_numeric_overflow, "too big integer");
            goto out;
        }

@@ -570,7 +576,7 @@ static int lex_scan_number(lex_t *lex, int c, json_error_t *error)
    lex_unget_unsave(lex, c);

    if(jsonp_strtod(&lex->saved_text, &doubleval)) {
-        error_set(error, lex, "real number overflow");
+        error_set(error, lex, json_error_numeric_overflow, "real number overflow");
        goto out;
    }

@@ -701,7 +707,7 @@ static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
        json_t *value;

        if(lex->token != TOKEN_STRING) {
-            error_set(error, lex, "string or '}' expected");
+            error_set(error, lex, json_error_invalid_syntax, "string or '}' expected");
            goto error;
        }

@@ -710,14 +716,14 @@ static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
            return NULL;
        if (memchr(key, '\0', len)) {
            jsonp_free(key);
-            error_set(error, lex, "NUL byte in object key not supported");
+            error_set(error, lex, json_error_null_byte_in_key, "NUL byte in object key not supported");
            goto error;
        }

        if(flags & JSON_REJECT_DUPLICATES) {
            if(json_object_get(object, key)) {
                jsonp_free(key);
-                error_set(error, lex, "duplicate object key");
+                error_set(error, lex, json_error_duplicate_key, "duplicate object key");
                goto error;
            }
        }
@@ -725,7 +731,7 @@ static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
        lex_scan(lex, error);
        if(lex->token != ':') {
            jsonp_free(key);
-            error_set(error, lex, "':' expected");
+            error_set(error, lex, json_error_invalid_syntax, "':' expected");
            goto error;
        }

@@ -736,13 +742,11 @@ static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
            goto error;
        }

-        if(json_object_set_nocheck(object, key, value)) {
+        if(json_object_set_new_nocheck(object, key, value)) {
            jsonp_free(key);
-            json_decref(value);
            goto error;
        }

-        json_decref(value);
        jsonp_free(key);

        lex_scan(lex, error);
@@ -753,7 +757,7 @@ static json_t *parse_object(lex_t *lex, size_t flags, json_error_t *error)
    }

    if(lex->token != '}') {
-        error_set(error, lex, "'}' expected");
+        error_set(error, lex, json_error_invalid_syntax, "'}' expected");
        goto error;
    }

@@ -779,11 +783,9 @@ static json_t *parse_array(lex_t *lex, size_t flags, json_error_t *error)
        if(!elem)
            goto error;

-        if(json_array_append(array, elem)) {
-            json_decref(elem);
+        if(json_array_append_new(array, elem)) {
            goto error;
        }
-        json_decref(elem);

        lex_scan(lex, error);
        if(lex->token != ',')
@@ -793,7 +795,7 @@ static json_t *parse_array(lex_t *lex, size_t flags, json_error_t *error)
    }

    if(lex->token != ']') {
-        error_set(error, lex, "']' expected");
+        error_set(error, lex, json_error_invalid_syntax, "']' expected");
        goto error;
    }

@@ -810,7 +812,7 @@ static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error)

    lex->depth++;
    if(lex->depth > JSON_PARSER_MAX_DEPTH) {
-        error_set(error, lex, "maximum parsing depth reached");
+        error_set(error, lex, json_error_stack_overflow, "maximum parsing depth reached");
        return NULL;
    }

@@ -821,16 +823,14 @@ static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error)

            if(!(flags & JSON_ALLOW_NUL)) {
                if(memchr(value, '\0', len)) {
-                    error_set(error, lex, "\\u0000 is not allowed without JSON_ALLOW_NUL");
+                    error_set(error, lex, json_error_null_character, "\\u0000 is not allowed without JSON_ALLOW_NUL");
                    return NULL;
                }
            }

            json = jsonp_stringn_nocheck_own(value, len);
-            if(json) {
-                lex->value.string.val = NULL;
-                lex->value.string.len = 0;
-            }
+            lex->value.string.val = NULL;
+            lex->value.string.len = 0;
            break;
        }

@@ -865,11 +865,11 @@ static json_t *parse_value(lex_t *lex, size_t flags, json_error_t *error)
            break;

        case TOKEN_INVALID:
-            error_set(error, lex, "invalid token");
+            error_set(error, lex, json_error_invalid_syntax, "invalid token");
            return NULL;

        default:
-            error_set(error, lex, "unexpected token");
+            error_set(error, lex, json_error_invalid_syntax, "unexpected token");
            return NULL;
    }

@@ -889,7 +889,7 @@ static json_t *parse_json(lex_t *lex, size_t flags, json_error_t *error)
    lex_scan(lex, error);
    if(!(flags & JSON_DECODE_ANY)) {
        if(lex->token != '[' && lex->token != '{') {
-            error_set(error, lex, "'[' or '{' expected");
+            error_set(error, lex, json_error_invalid_syntax, "'[' or '{' expected");
            return NULL;
        }
    }
@@ -901,7 +901,7 @@ static json_t *parse_json(lex_t *lex, size_t flags, json_error_t *error)
    if(!(flags & JSON_DISABLE_EOF_CHECK)) {
        lex_scan(lex, error);
        if(lex->token != TOKEN_EOF) {
-            error_set(error, lex, "end of file expected");
+            error_set(error, lex, json_error_end_of_input_expected, "end of file expected");
            json_decref(result);
            return NULL;
        }
@@ -944,7 +944,7 @@ json_t *json_loads(const char *string, size_t flags, json_error_t *error)
    jsonp_error_init(error, "<string>");

    if (string == NULL) {
-        error_set(error, NULL, "wrong arguments");
+        error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
        return NULL;
    }

@@ -988,7 +988,7 @@ json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t
    jsonp_error_init(error, "<buffer>");

    if (buffer == NULL) {
-        error_set(error, NULL, "wrong arguments");
+        error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
        return NULL;
    }

@@ -1019,7 +1019,7 @@ json_t *json_loadf(FILE *input, size_t flags, json_error_t *error)
    jsonp_error_init(error, source);

    if (input == NULL) {
-        error_set(error, NULL, "wrong arguments");
+        error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
        return NULL;
    }

@@ -1034,8 +1034,8 @@ json_t *json_loadf(FILE *input, size_t flags, json_error_t *error)

 static int fd_get_func(int *fd)
 {
-    uint8_t c;
 #ifdef HAVE_UNISTD_H
+    uint8_t c;
    if (read(*fd, &c, 1) == 1)
        return c;
 #endif
@@ -1058,7 +1058,7 @@ json_t *json_loadfd(int input, size_t flags, json_error_t *error)
    jsonp_error_init(error, source);

    if (input < 0) {
-        error_set(error, NULL, "wrong arguments");
+        error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
        return NULL;
    }

@@ -1079,14 +1079,14 @@ json_t *json_load_file(const char *path, size_t flags, json_error_t *error)
    jsonp_error_init(error, path);

    if (path == NULL) {
-        error_set(error, NULL, "wrong arguments");
+        error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
        return NULL;
    }

    fp = fopen(path, "rb");
    if(!fp)
    {
-        error_set(error, NULL, "unable to open %s: %s",
+        error_set(error, NULL, json_error_cannot_open_file, "unable to open %s: %s",
                  path, strerror(errno));
        return NULL;
    }
@@ -1139,7 +1139,7 @@ json_t *json_load_callback(json_load_callback_t callback, void *arg, size_t flag
    jsonp_error_init(error, "<callback>");

    if (callback == NULL) {
-        error_set(error, NULL, "wrong arguments");
+        error_set(error, NULL, json_error_invalid_argument, "wrong arguments");
        return NULL;
    }

--- a/src/lookup3.h
+++ b/src/lookup3.h
@@ -359,17 +359,17 @@ static uint32_t hashlittle(const void *key, size_t length, uint32_t initval)
    /*-------------------------------- last block: affect all 32 bits of (c) */
    switch(length)                   /* all the case statements fall through */
    {
-    case 12: c+=((uint32_t)k[11])<<24;
-    case 11: c+=((uint32_t)k[10])<<16;
-    case 10: c+=((uint32_t)k[9])<<8;
-    case 9 : c+=k[8];
-    case 8 : b+=((uint32_t)k[7])<<24;
-    case 7 : b+=((uint32_t)k[6])<<16;
-    case 6 : b+=((uint32_t)k[5])<<8;
-    case 5 : b+=k[4];
-    case 4 : a+=((uint32_t)k[3])<<24;
-    case 3 : a+=((uint32_t)k[2])<<16;
-    case 2 : a+=((uint32_t)k[1])<<8;
+    case 12: c+=((uint32_t)k[11])<<24; /* fall through */
+    case 11: c+=((uint32_t)k[10])<<16; /* fall through */
+    case 10: c+=((uint32_t)k[9])<<8; /* fall through */
+    case 9 : c+=k[8]; /* fall through */
+    case 8 : b+=((uint32_t)k[7])<<24; /* fall through */
+    case 7 : b+=((uint32_t)k[6])<<16; /* fall through */
+    case 6 : b+=((uint32_t)k[5])<<8; /* fall through */
+    case 5 : b+=k[4]; /* fall through */
+    case 4 : a+=((uint32_t)k[3])<<24; /* fall through */
+    case 3 : a+=((uint32_t)k[2])<<16; /* fall through */
+    case 2 : a+=((uint32_t)k[1])<<8; /* fall through */
    case 1 : a+=k[0];
             break;
    case 0 : return c;
--- a/src/pack_unpack.c
+++ b/src/pack_unpack.c
@@ -29,6 +29,7 @@ typedef struct {
    int line;
    int column;
    size_t pos;
+    int has_error;
 } scanner_t;

 #define token(scanner) ((scanner)->token.token)
@@ -60,6 +61,7 @@ static void scanner_init(scanner_t *s, json_error_t *error,
    s->line = 1;
    s->column = 0;
    s->pos = 0;
+    s->has_error = 0;
 }

 static void next_token(scanner_t *s)
@@ -73,6 +75,9 @@ static void next_token(scanner_t *s)
        return;
    }

+    if (!token(s) && !*s->fmt)
+        return;
+
    t = s->fmt;
    s->column++;
    s->pos++;
@@ -95,7 +100,7 @@ static void next_token(scanner_t *s)
    s->token.column = s->column;
    s->token.pos = s->pos;

-    t++;
+    if (*t) t++;
    s->fmt = t;
 }

@@ -105,13 +110,14 @@ static void prev_token(scanner_t *s)
    s->token = s->prev_token;
 }

-static void set_error(scanner_t *s, const char *source, const char *fmt, ...)
+static void set_error(scanner_t *s, const char *source, enum json_error_code code,
+                      const char *fmt, ...)
 {
    va_list ap;
    va_start(ap, fmt);

    jsonp_error_vset(s->error, s->token.line, s->token.column, s->token.pos,
-                     fmt, ap);
+                     code, fmt, ap);

    jsonp_error_set_source(s->error, source);

@@ -124,7 +130,7 @@ static json_t *pack(scanner_t *s, va_list *ap);
 /* ours will be set to 1 if jsonp_free() must be called for the result
   afterwards */
 static char *read_string(scanner_t *s, va_list *ap,
-                         const char *purpose, size_t *out_len, int *ours)
+                         const char *purpose, size_t *out_len, int *ours, int optional)
 {
    char t;
    strbuffer_t strbuff;
@@ -135,35 +141,46 @@ static char *read_string(scanner_t *s, va_list *ap,
    t = token(s);
    prev_token(s);

+    *ours = 0;
    if(t != '#' && t != '%' && t != '+') {
        /* Optimize the simple case */
        str = va_arg(*ap, const char *);

        if(!str) {
-            set_error(s, "<args>", "NULL string argument");
+            if (!optional) {
+                set_error(s, "<args>", json_error_null_value, "NULL %s", purpose);
+                s->has_error = 1;
+            }
            return NULL;
        }

        length = strlen(str);

        if(!utf8_check_string(str, length)) {
-            set_error(s, "<args>", "Invalid UTF-8 %s", purpose);
+            set_error(s, "<args>", json_error_invalid_utf8, "Invalid UTF-8 %s", purpose);
+            s->has_error = 1;
            return NULL;
        }

        *out_len = length;
-        *ours = 0;
        return (char *)str;
+    } else if (optional) {
+        set_error(s, "<format>", json_error_invalid_format, "Cannot use '%c' on optional strings", t);
+        s->has_error = 1;
+
+        return NULL;
    }

-    strbuffer_init(&strbuff);
+    if(strbuffer_init(&strbuff)) {
+        set_error(s, "<internal>", json_error_out_of_memory, "Out of memory");
+        s->has_error = 1;
+    }

    while(1) {
        str = va_arg(*ap, const char *);
        if(!str) {
-            set_error(s, "<args>", "NULL string argument");
-            strbuffer_close(&strbuff);
-            return NULL;
+            set_error(s, "<args>", json_error_null_value, "NULL %s", purpose);
+            s->has_error = 1;
        }

        next_token(s);
@@ -176,13 +193,12 @@ static char *read_string(scanner_t *s, va_list *ap,
        }
        else {
            prev_token(s);
-            length = strlen(str);
+            length = s->has_error ? 0 : strlen(str);
        }

-        if(strbuffer_append_bytes(&strbuff, str, length) == -1) {
-            set_error(s, "<internal>", "Out of memory");
-            strbuffer_close(&strbuff);
-            return NULL;
+        if(!s->has_error && strbuffer_append_bytes(&strbuff, str, length) == -1) {
+            set_error(s, "<internal>", json_error_out_of_memory, "Out of memory");
+            s->has_error = 1;
        }

        next_token(s);
@@ -192,12 +208,18 @@ static char *read_string(scanner_t *s, va_list *ap,
        }
    }

-    if(!utf8_check_string(strbuff.value, strbuff.length)) {
-        set_error(s, "<args>", "Invalid UTF-8 %s", purpose);
+    if(s->has_error) {
        strbuffer_close(&strbuff);
        return NULL;
    }

+    if(!utf8_check_string(strbuff.value, strbuff.length)) {
+        set_error(s, "<args>", json_error_invalid_utf8, "Invalid UTF-8 %s", purpose);
+        strbuffer_close(&strbuff);
+        s->has_error = 1;
+        return NULL;
+    }
+
    *out_len = strbuff.length;
    *ours = 1;
    return strbuffer_steal_value(&strbuff);
@@ -213,37 +235,46 @@ static json_t *pack_object(scanner_t *s, va_list *ap)
        size_t len;
        int ours;
        json_t *value;
+        char valueOptional;

        if(!token(s)) {
-            set_error(s, "<format>", "Unexpected end of format string");
+            set_error(s, "<format>", json_error_invalid_format, "Unexpected end of format string");
            goto error;
        }

        if(token(s) != 's') {
-            set_error(s, "<format>", "Expected format 's', got '%c'", token(s));
+            set_error(s, "<format>", json_error_invalid_format, "Expected format 's', got '%c'", token(s));
            goto error;
        }

-        key = read_string(s, ap, "object key", &len, &ours);
-        if(!key)
-            goto error;
+        key = read_string(s, ap, "object key", &len, &ours, 0);

        next_token(s);

+        next_token(s);
+        valueOptional = token(s);
+        prev_token(s);
+
        value = pack(s, ap);
        if(!value) {
            if(ours)
                jsonp_free(key);

-            goto error;
+            if(valueOptional != '*') {
+                set_error(s, "<args>", json_error_null_value, "NULL object value");
+                s->has_error = 1;
+            }
+
+            next_token(s);
+            continue;
        }

-        if(json_object_set_new_nocheck(object, key, value)) {
-            set_error(s, "<internal>", "Unable to add key \"%s\"", key);
-            if(ours)
-                jsonp_free(key);
+        if(s->has_error)
+            json_decref(value);

-            goto error;
+        if(!s->has_error && json_object_set_new_nocheck(object, key, value)) {
+            set_error(s, "<internal>", json_error_out_of_memory, "Unable to add key \"%s\"", key);
+            s->has_error = 1;
        }

        if(ours)
@@ -252,7 +283,8 @@ static json_t *pack_object(scanner_t *s, va_list *ap)
        next_token(s);
    }

-    return object;
+    if(!s->has_error)
+        return object;

 error:
    json_decref(object);
@@ -266,24 +298,41 @@ static json_t *pack_array(scanner_t *s, va_list *ap)

    while(token(s) != ']') {
        json_t *value;
+        char valueOptional;

        if(!token(s)) {
-            set_error(s, "<format>", "Unexpected end of format string");
-            goto error;
-        }
-
-        value = pack(s, ap);
-        if(!value)
-            goto error;
-
-        if(json_array_append_new(array, value)) {
-            set_error(s, "<internal>", "Unable to append to array");
+            set_error(s, "<format>", json_error_invalid_format, "Unexpected end of format string");
+            /* Format string errors are unrecoverable. */
            goto error;
        }

+        next_token(s);
+        valueOptional = token(s);
+        prev_token(s);
+
+        value = pack(s, ap);
+        if(!value) {
+            if(valueOptional != '*') {
+                s->has_error = 1;
+            }
+
+            next_token(s);
+            continue;
+        }
+
+        if(s->has_error)
+            json_decref(value);
+
+        if(!s->has_error && json_array_append_new(array, value)) {
+            set_error(s, "<internal>", json_error_out_of_memory, "Unable to append to array");
+            s->has_error = 1;
+        }
+
        next_token(s);
    }
-    return array;
+
+    if(!s->has_error)
+        return array;

 error:
    json_decref(array);
@@ -293,23 +342,97 @@ error:
 static json_t *pack_string(scanner_t *s, va_list *ap)
 {
    char *str;
+    char t;
    size_t len;
    int ours;
-    int nullable;
+    int optional;

    next_token(s);
-    nullable = token(s) == '?';
-    if (!nullable)
+    t = token(s);
+    optional = t == '?' || t == '*';
+    if (!optional)
        prev_token(s);

-    str = read_string(s, ap, "string", &len, &ours);
-    if (!str) {
-        return nullable ? json_null() : NULL;
-    } else if (ours) {
-        return jsonp_stringn_nocheck_own(str, len);
-    } else {
-        return json_stringn_nocheck(str, len);
+    str = read_string(s, ap, "string", &len, &ours, optional);
+
+    if (!str)
+        return t == '?' && !s->has_error ? json_null() : NULL;
+
+    if (s->has_error) {
+        /* It's impossible to reach this point if ours != 0, do not free str. */
+        return NULL;
    }
+
+    if (ours)
+        return jsonp_stringn_nocheck_own(str, len);
+
+    return json_stringn_nocheck(str, len);
+}
+
+static json_t *pack_object_inter(scanner_t *s, va_list *ap, int need_incref)
+{
+    json_t *json;
+    char ntoken;
+
+    next_token(s);
+    ntoken = token(s);
+
+    if (ntoken != '?' && ntoken != '*')
+        prev_token(s);
+
+    json = va_arg(*ap, json_t *);
+
+    if (json)
+        return need_incref ? json_incref(json) : json;
+
+    switch (ntoken) {
+        case '?':
+            return json_null();
+        case '*':
+            return NULL;
+        default:
+            break;
+    }
+
+    set_error(s, "<args>", json_error_null_value, "NULL object");
+    s->has_error = 1;
+    return NULL;
+}
+
+static json_t *pack_integer(scanner_t *s, json_int_t value)
+{
+    json_t *json = json_integer(value);
+
+    if (!json) {
+        set_error(s, "<internal>", json_error_out_of_memory, "Out of memory");
+        s->has_error = 1;
+    }
+
+    return json;
+}
+
+static json_t *pack_real(scanner_t *s, double value)
+{
+    /* Allocate without setting value so we can identify OOM error. */
+    json_t *json = json_real(0.0);
+
+    if (!json) {
+        set_error(s, "<internal>", json_error_out_of_memory, "Out of memory");
+        s->has_error = 1;
+
+        return NULL;
+    }
+
+    if (json_real_set(json, value)) {
+        json_decref(json);
+
+        set_error(s, "<args>", json_error_numeric_overflow, "Invalid floating point value");
+        s->has_error = 1;
+
+        return NULL;
+    }
+
+    return json;
 }

 static json_t *pack(scanner_t *s, va_list *ap)
@@ -331,53 +454,24 @@ static json_t *pack(scanner_t *s, va_list *ap)
            return va_arg(*ap, int) ? json_true() : json_false();

        case 'i': /* integer from int */
-            return json_integer(va_arg(*ap, int));
+            return pack_integer(s, va_arg(*ap, int));

        case 'I': /* integer from json_int_t */
-            return json_integer(va_arg(*ap, json_int_t));
+            return pack_integer(s, va_arg(*ap, json_int_t));

        case 'f': /* real */
-            return json_real(va_arg(*ap, double));
+            return pack_real(s, va_arg(*ap, double));

        case 'O': /* a json_t object; increments refcount */
-        {
-            int nullable;
-            json_t *json;
-
-            next_token(s);
-            nullable = token(s) == '?';
-            if (!nullable)
-                prev_token(s);
-
-            json = va_arg(*ap, json_t *);
-            if (!json && nullable) {
-                return json_null();
-            } else {
-                return json_incref(json);
-            }
-        }
+            return pack_object_inter(s, ap, 1);

        case 'o': /* a json_t object; doesn't increment refcount */
-        {
-            int nullable;
-            json_t *json;
-
-            next_token(s);
-            nullable = token(s) == '?';
-            if (!nullable)
-                prev_token(s);
-
-            json = va_arg(*ap, json_t *);
-            if (!json && nullable) {
-                return json_null();
-            } else {
-                return json;
-            }
-        }
+            return pack_object_inter(s, ap, 0);

        default:
-            set_error(s, "<format>", "Unexpected format character '%c'",
+            set_error(s, "<format>", json_error_invalid_format, "Unexpected format character '%c'",
                      token(s));
+            s->has_error = 1;
            return NULL;
    }
 }
@@ -398,12 +492,12 @@ static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
    hashtable_t key_set;

    if(hashtable_init(&key_set)) {
-        set_error(s, "<internal>", "Out of memory");
+        set_error(s, "<internal>", json_error_out_of_memory, "Out of memory");
        return -1;
    }

    if(root && !json_is_object(root)) {
-        set_error(s, "<validation>", "Expected object, got %s",
+        set_error(s, "<validation>", json_error_wrong_type, "Expected object, got %s",
                  type_name(root));
        goto out;
    }
@@ -415,13 +509,13 @@ static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
        int opt = 0;

        if(strict != 0) {
-            set_error(s, "<format>", "Expected '}' after '%c', got '%c'",
+            set_error(s, "<format>", json_error_invalid_format, "Expected '}' after '%c', got '%c'",
                      (strict == 1 ? '!' : '*'), token(s));
            goto out;
        }

        if(!token(s)) {
-            set_error(s, "<format>", "Unexpected end of format string");
+            set_error(s, "<format>", json_error_invalid_format, "Unexpected end of format string");
            goto out;
        }

@@ -432,13 +526,13 @@ static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
        }

        if(token(s) != 's') {
-            set_error(s, "<format>", "Expected format 's', got '%c'", token(s));
+            set_error(s, "<format>", json_error_invalid_format, "Expected format 's', got '%c'", token(s));
            goto out;
        }

        key = va_arg(*ap, const char *);
        if(!key) {
-            set_error(s, "<args>", "NULL object key");
+            set_error(s, "<args>", json_error_null_value, "NULL object key");
            goto out;
        }

@@ -456,7 +550,7 @@ static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
        else {
            value = json_object_get(root, key);
            if(!value && !opt) {
-                set_error(s, "<validation>", "Object item not found: %s", key);
+                set_error(s, "<validation>", json_error_item_not_found, "Object item not found: %s", key);
                goto out;
            }
        }
@@ -474,48 +568,34 @@ static int unpack_object(scanner_t *s, json_t *root, va_list *ap)
    if(root && strict == 1) {
        /* We need to check that all non optional items have been parsed */
        const char *key;
-        int have_unrecognized_keys = 0;
+        /* keys_res is 1 for uninitialized, 0 for success, -1 for error. */
+        int keys_res = 1;
        strbuffer_t unrecognized_keys;
        json_t *value;
        long unpacked = 0;
-        if (gotopt) {
-            /* We have optional keys, we need to iter on each key */
+
+        if (gotopt || json_object_size(root) != key_set.size) {
            json_object_foreach(root, key, value) {
                if(!hashtable_get(&key_set, key)) {
                    unpacked++;

                    /* Save unrecognized keys for the error message */
-                    if (!have_unrecognized_keys) {
-                        strbuffer_init(&unrecognized_keys);
-                        have_unrecognized_keys = 1;
-                    } else {
-                        strbuffer_append_bytes(&unrecognized_keys, ", ", 2);
+                    if (keys_res == 1) {
+                        keys_res = strbuffer_init(&unrecognized_keys);
+                    } else if (!keys_res) {
+                        keys_res = strbuffer_append_bytes(&unrecognized_keys, ", ", 2);
                    }
-                    strbuffer_append_bytes(&unrecognized_keys, key, strlen(key));
+
+                    if (!keys_res)
+                        keys_res = strbuffer_append_bytes(&unrecognized_keys, key, strlen(key));
                }
            }
-        } else {
-            /* No optional keys, we can just compare the number of items */
-            unpacked = (long)json_object_size(root) - (long)key_set.size;
        }
        if (unpacked) {
-            if (!gotopt) {
-                /* Save unrecognized keys for the error message */
-                json_object_foreach(root, key, value) {
-                    if(!hashtable_get(&key_set, key)) {
-                        if (!have_unrecognized_keys) {
-                            strbuffer_init(&unrecognized_keys);
-                            have_unrecognized_keys = 1;
-                        } else {
-                            strbuffer_append_bytes(&unrecognized_keys, ", ", 2);
-                        }
-                        strbuffer_append_bytes(&unrecognized_keys, key, strlen(key));
-                    }
-                }
-            }
-            set_error(s, "<validation>",
+            set_error(s, "<validation>", json_error_end_of_input_expected,
                      "%li object item(s) left unpacked: %s",
-                      unpacked, strbuffer_value(&unrecognized_keys));
+                      unpacked,
+                      keys_res ? "<unknown>" : strbuffer_value(&unrecognized_keys));
            strbuffer_close(&unrecognized_keys);
            goto out;
        }
@@ -534,7 +614,7 @@ static int unpack_array(scanner_t *s, json_t *root, va_list *ap)
    int strict = 0;

    if(root && !json_is_array(root)) {
-        set_error(s, "<validation>", "Expected array, got %s", type_name(root));
+        set_error(s, "<validation>", json_error_wrong_type, "Expected array, got %s", type_name(root));
        return -1;
    }
    next_token(s);
@@ -543,14 +623,14 @@ static int unpack_array(scanner_t *s, json_t *root, va_list *ap)
        json_t *value;

        if(strict != 0) {
-            set_error(s, "<format>", "Expected ']' after '%c', got '%c'",
+            set_error(s, "<format>", json_error_invalid_format, "Expected ']' after '%c', got '%c'",
                      (strict == 1 ? '!' : '*'),
                      token(s));
            return -1;
        }

        if(!token(s)) {
-            set_error(s, "<format>", "Unexpected end of format string");
+            set_error(s, "<format>", json_error_invalid_format, "Unexpected end of format string");
            return -1;
        }

@@ -561,7 +641,7 @@ static int unpack_array(scanner_t *s, json_t *root, va_list *ap)
        }

        if(!strchr(unpack_value_starters, token(s))) {
-            set_error(s, "<format>", "Unexpected format character '%c'",
+            set_error(s, "<format>", json_error_invalid_format, "Unexpected format character '%c'",
                      token(s));
            return -1;
        }
@@ -573,7 +653,7 @@ static int unpack_array(scanner_t *s, json_t *root, va_list *ap)
        else {
            value = json_array_get(root, i);
            if(!value) {
-                set_error(s, "<validation>", "Array index %lu out of range",
+                set_error(s, "<validation>", json_error_index_out_of_range, "Array index %lu out of range",
                          (unsigned long)i);
                return -1;
            }
@@ -591,7 +671,7 @@ static int unpack_array(scanner_t *s, json_t *root, va_list *ap)

    if(root && strict == 1 && i != json_array_size(root)) {
        long diff = (long)json_array_size(root) - (long)i;
-        set_error(s, "<validation>", "%li array item(s) left unpacked", diff);
+        set_error(s, "<validation>", json_error_end_of_input_expected, "%li array item(s) left unpacked", diff);
        return -1;
    }

@@ -610,7 +690,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)

        case 's':
            if(root && !json_is_string(root)) {
-                set_error(s, "<validation>", "Expected string, got %s",
+                set_error(s, "<validation>", json_error_wrong_type, "Expected string, got %s",
                          type_name(root));
                return -1;
            }
@@ -621,7 +701,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)

                str_target = va_arg(*ap, const char **);
                if(!str_target) {
-                    set_error(s, "<args>", "NULL string argument");
+                    set_error(s, "<args>", json_error_null_value, "NULL string argument");
                    return -1;
                }

@@ -630,7 +710,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)
                if(token(s) == '%') {
                    len_target = va_arg(*ap, size_t *);
                    if(!len_target) {
-                        set_error(s, "<args>", "NULL string length argument");
+                        set_error(s, "<args>", json_error_null_value, "NULL string length argument");
                        return -1;
                    }
                }
@@ -647,7 +727,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)

        case 'i':
            if(root && !json_is_integer(root)) {
-                set_error(s, "<validation>", "Expected integer, got %s",
+                set_error(s, "<validation>", json_error_wrong_type, "Expected integer, got %s",
                          type_name(root));
                return -1;
            }
@@ -662,7 +742,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)

        case 'I':
            if(root && !json_is_integer(root)) {
-                set_error(s, "<validation>", "Expected integer, got %s",
+                set_error(s, "<validation>", json_error_wrong_type, "Expected integer, got %s",
                          type_name(root));
                return -1;
            }
@@ -677,7 +757,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)

        case 'b':
            if(root && !json_is_boolean(root)) {
-                set_error(s, "<validation>", "Expected true or false, got %s",
+                set_error(s, "<validation>", json_error_wrong_type, "Expected true or false, got %s",
                          type_name(root));
                return -1;
            }
@@ -692,7 +772,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)

        case 'f':
            if(root && !json_is_real(root)) {
-                set_error(s, "<validation>", "Expected real, got %s",
+                set_error(s, "<validation>", json_error_wrong_type, "Expected real, got %s",
                          type_name(root));
                return -1;
            }
@@ -707,7 +787,7 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)

        case 'F':
            if(root && !json_is_number(root)) {
-                set_error(s, "<validation>", "Expected real or integer, got %s",
+                set_error(s, "<validation>", json_error_wrong_type, "Expected real or integer, got %s",
                          type_name(root));
                return -1;
            }
@@ -737,14 +817,14 @@ static int unpack(scanner_t *s, json_t *root, va_list *ap)
        case 'n':
            /* Never assign, just validate */
            if(root && !json_is_null(root)) {
-                set_error(s, "<validation>", "Expected null, got %s",
+                set_error(s, "<validation>", json_error_wrong_type, "Expected null, got %s",
                          type_name(root));
                return -1;
            }
            return 0;

        default:
-            set_error(s, "<format>", "Unexpected format character '%c'",
+            set_error(s, "<format>", json_error_invalid_format, "Unexpected format character '%c'",
                      token(s));
            return -1;
    }
@@ -759,7 +839,7 @@ json_t *json_vpack_ex(json_error_t *error, size_t flags,

    if(!fmt || !*fmt) {
        jsonp_error_init(error, "<format>");
-        jsonp_error_set(error, -1, -1, 0, "NULL or empty format string");
+        jsonp_error_set(error, -1, -1, 0, json_error_invalid_argument, "NULL or empty format string");
        return NULL;
    }
    jsonp_error_init(error, NULL);
@@ -771,13 +851,14 @@ json_t *json_vpack_ex(json_error_t *error, size_t flags,
    value = pack(&s, &ap_copy);
    va_end(ap_copy);

+    /* This will cover all situations where s.has_error is true */
    if(!value)
        return NULL;

    next_token(&s);
    if(token(&s)) {
        json_decref(value);
-        set_error(&s, "<format>", "Garbage after format string");
+        set_error(&s, "<format>", json_error_invalid_format, "Garbage after format string");
        return NULL;
    }

@@ -816,13 +897,13 @@ int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags,

    if(!root) {
        jsonp_error_init(error, "<root>");
-        jsonp_error_set(error, -1, -1, 0, "NULL root value");
+        jsonp_error_set(error, -1, -1, 0, json_error_null_value, "NULL root value");
        return -1;
    }

    if(!fmt || !*fmt) {
        jsonp_error_init(error, "<format>");
-        jsonp_error_set(error, -1, -1, 0, "NULL or empty format string");
+        jsonp_error_set(error, -1, -1, 0, json_error_invalid_argument, "NULL or empty format string");
        return -1;
    }
    jsonp_error_init(error, NULL);
@@ -839,7 +920,7 @@ int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags,

    next_token(&s);
    if(token(&s)) {
-        set_error(&s, "<format>", "Garbage after format string");
+        set_error(&s, "<format>", json_error_invalid_format, "Garbage after format string");
        return -1;
    }

--- a/src/strbuffer.h
+++ b/src/strbuffer.h
@@ -16,7 +16,7 @@ typedef struct {
    size_t size;     /* bytes allocated */
 } strbuffer_t;

-int strbuffer_init(strbuffer_t *strbuff);
+int strbuffer_init(strbuffer_t *strbuff) JANSSON_ATTRS(warn_unused_result);
 void strbuffer_close(strbuffer_t *strbuff);

 void strbuffer_clear(strbuffer_t *strbuff);
--- a/src/value.c
+++ b/src/value.c
@@ -67,8 +67,6 @@ json_t *json_object(void)
        return NULL;
    }

-    object->visited = 0;
-
    return &object->json;
 }

@@ -258,7 +256,10 @@ json_t *json_object_iter_value(void *iter)
 int json_object_iter_set_new(json_t *json, void *iter, json_t *value)
 {
    if(!json_is_object(json) || !iter || !value)
+    {
+        json_decref(value);
        return -1;
+    }

    hashtable_iter_set(iter, value);
    return 0;
@@ -272,15 +273,15 @@ void *json_object_key_to_iter(const char *key)
    return hashtable_key_to_iter(key);
 }

-static int json_object_equal(json_t *object1, json_t *object2)
+static int json_object_equal(const json_t *object1, const json_t *object2)
 {
    const char *key;
-    json_t *value1, *value2;
+    const json_t *value1, *value2;

    if(json_object_size(object1) != json_object_size(object2))
        return 0;

-    json_object_foreach(object1, key, value1) {
+    json_object_foreach((json_t *)object1, key, value1) {
        value2 = json_object_get(object2, key);

        if(!json_equal(value1, value2))
@@ -351,8 +352,6 @@ json_t *json_array(void)
        return NULL;
    }

-    array->visited = 0;
-
    return &array->json;
 }

@@ -581,7 +580,7 @@ int json_array_extend(json_t *json, json_t *other_json)
    return 0;
 }

-static int json_array_equal(json_t *array1, json_t *array2)
+static int json_array_equal(const json_t *array1, const json_t *array2)
 {
    size_t i, size;

@@ -653,8 +652,7 @@ static json_t *string_create(const char *value, size_t len, int own)

    string = jsonp_malloc(sizeof(json_string_t));
    if(!string) {
-        if(!own)
-            jsonp_free(v);
+        jsonp_free(v);
        return NULL;
    }
    json_init(&string->json, JSON_STRING);
@@ -765,13 +763,10 @@ static void json_delete_string(json_string_t *string)
    jsonp_free(string);
 }

-static int json_string_equal(json_t *string1, json_t *string2)
+static int json_string_equal(const json_t *string1, const json_t *string2)
 {
    json_string_t *s1, *s2;

-    if(!json_is_string(string1) || !json_is_string(string2))
-        return 0;
-
    s1 = json_to_string(string1);
    s2 = json_to_string(string2);
    return s1->length == s2->length && !memcmp(s1->value, s2->value, s1->length);
@@ -781,13 +776,51 @@ static json_t *json_string_copy(const json_t *string)
 {
    json_string_t *s;

-    if(!json_is_string(string))
-        return NULL;
-
    s = json_to_string(string);
    return json_stringn_nocheck(s->value, s->length);
 }

+json_t *json_vsprintf(const char *fmt, va_list ap) {
+    json_t *json = NULL;
+    int length;
+    char *buf;
+    va_list aq;
+    va_copy(aq, ap);
+
+    length = vsnprintf(NULL, 0, fmt, ap);
+    if (length == 0) {
+        json = json_string("");
+        goto out;
+    }
+
+    buf = jsonp_malloc(length + 1);
+    if (!buf)
+        goto out;
+
+    vsnprintf(buf, length + 1, fmt, aq);
+    if (!utf8_check_string(buf, length)) {
+        jsonp_free(buf);
+        goto out;
+    }
+
+    json = jsonp_stringn_nocheck_own(buf, length);
+
+out:
+    va_end(aq);
+    return json;
+}
+
+json_t *json_sprintf(const char *fmt, ...) {
+    json_t *result;
+    va_list ap;
+
+    va_start(ap, fmt);
+    result = json_vsprintf(fmt, ap);
+    va_end(ap);
+
+    return result;
+}
+

 /*** integer ***/

@@ -825,7 +858,7 @@ static void json_delete_integer(json_integer_t *integer)
    jsonp_free(integer);
 }

-static int json_integer_equal(json_t *integer1, json_t *integer2)
+static int json_integer_equal(const json_t *integer1, const json_t *integer2)
 {
    return json_integer_value(integer1) == json_integer_value(integer2);
 }
@@ -877,7 +910,7 @@ static void json_delete_real(json_real_t *real)
    jsonp_free(real);
 }

-static int json_real_equal(json_t *real1, json_t *real2)
+static int json_real_equal(const json_t *real1, const json_t *real2)
 {
    return json_real_value(real1) == json_real_value(real2);
 }
@@ -957,7 +990,7 @@ void json_delete(json_t *json)

 /*** equality ***/

-int json_equal(json_t *json1, json_t *json2)
+int json_equal(const json_t *json1, const json_t *json2)
 {
    if(!json1 || !json2)
        return 0;
@@ -1011,8 +1044,6 @@ json_t *json_copy(json_t *json)
        default:
            return NULL;
    }
-
-    return NULL;
 }

 json_t *json_deep_copy(const json_t *json)
@@ -1040,6 +1071,4 @@ json_t *json_deep_copy(const json_t *json)
        default:
            return NULL;
    }
-
-    return NULL;
 }
--- a/test/.gitignore
+++ b/test/.gitignore
@@ -1,20 +1,22 @@
 logs
 bin/json_process
 suites/api/test_array
+suites/api/test_chaos
 suites/api/test_copy
 suites/api/test_cpp
 suites/api/test_dump
 suites/api/test_dump_callback
 suites/api/test_equal
 suites/api/test_load
+suites/api/test_load_callback
 suites/api/test_loadb
 suites/api/test_memory_funcs
 suites/api/test_number
 suites/api/test_object
 suites/api/test_pack
 suites/api/test_simple
+suites/api/test_sprintf
 suites/api/test_unpack
-suites/api/test_load_callback
 run-suites.log
 run-suites.trs
 test-suite.log
--- a/test/suites/api/Makefile.am
+++ b/test/suites/api/Makefile.am
@@ -2,6 +2,7 @@ EXTRA_DIST = run check-exports

 check_PROGRAMS = \
 	test_array \
+	test_chaos \
 	test_copy \
 	test_dump \
 	test_dump_callback \
@@ -14,9 +15,11 @@ check_PROGRAMS = \
 	test_object \
 	test_pack \
 	test_simple \
+	test_sprintf \
 	test_unpack

 test_array_SOURCES = test_array.c util.h
+test_chaos_SOURCES = test_chaos.c util.h
 test_copy_SOURCES = test_copy.c util.h
 test_dump_SOURCES = test_dump.c util.h
 test_dump_callback_SOURCES = test_dump_callback.c util.h
@@ -27,6 +30,7 @@ test_number_SOURCES = test_number.c util.h
 test_object_SOURCES = test_object.c util.h
 test_pack_SOURCES = test_pack.c util.h
 test_simple_SOURCES = test_simple.c util.h
+test_sprintf_SOURCES = test_sprintf.c util.h
 test_unpack_SOURCES = test_unpack.c util.h

 AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src
--- a/test/suites/api/test_array.c
+++ b/test/suites/api/test_array.c
@@ -419,6 +419,78 @@ static void test_array_foreach()
    json_decref(array2);
 }

+static void test_bad_args(void)
+{
+    json_t *arr = json_array();
+    json_t *num = json_integer(1);
+
+    if(!arr || !num)
+        fail("failed to create required objects");
+
+    if(json_array_size(NULL) != 0)
+        fail("NULL array has nonzero size");
+    if(json_array_size(num) != 0)
+        fail("non-array has nonzero array size");
+
+    if(json_array_get(NULL, 0))
+        fail("json_array_get did not return NULL for non-array");
+    if(json_array_get(num, 0))
+        fail("json_array_get did not return NULL for non-array");
+
+    if(!json_array_set_new(NULL, 0, json_incref(num)))
+        fail("json_array_set_new did not return error for non-array");
+    if(!json_array_set_new(num, 0, json_incref(num)))
+        fail("json_array_set_new did not return error for non-array");
+    if(!json_array_set_new(arr, 0, NULL))
+        fail("json_array_set_new did not return error for NULL value");
+    if(!json_array_set_new(arr, 0, json_incref(arr)))
+        fail("json_array_set_new did not return error for value == array");
+
+    if(!json_array_remove(NULL, 0))
+        fail("json_array_remove did not return error for non-array");
+    if(!json_array_remove(num, 0))
+        fail("json_array_remove did not return error for non-array");
+
+    if(!json_array_clear(NULL))
+        fail("json_array_clear did not return error for non-array");
+    if(!json_array_clear(num))
+        fail("json_array_clear did not return error for non-array");
+
+    if(!json_array_append_new(NULL, json_incref(num)))
+        fail("json_array_append_new did not return error for non-array");
+    if(!json_array_append_new(num, json_incref(num)))
+        fail("json_array_append_new did not return error for non-array");
+    if(!json_array_append_new(arr, NULL))
+        fail("json_array_append_new did not return error for NULL value");
+    if(!json_array_append_new(arr, json_incref(arr)))
+        fail("json_array_append_new did not return error for value == array");
+
+    if(!json_array_insert_new(NULL, 0, json_incref(num)))
+        fail("json_array_insert_new did not return error for non-array");
+    if(!json_array_insert_new(num, 0, json_incref(num)))
+        fail("json_array_insert_new did not return error for non-array");
+    if(!json_array_insert_new(arr, 0, NULL))
+        fail("json_array_insert_new did not return error for NULL value");
+    if(!json_array_insert_new(arr, 0, json_incref(arr)))
+        fail("json_array_insert_new did not return error for value == array");
+
+    if(!json_array_extend(NULL, arr))
+        fail("json_array_extend did not return error for first argument non-array");
+    if(!json_array_extend(num, arr))
+        fail("json_array_extend did not return error for first argument non-array");
+    if(!json_array_extend(arr, NULL))
+        fail("json_array_extend did not return error for second arguemnt non-array");
+    if(!json_array_extend(arr, num))
+        fail("json_array_extend did not return error for second arguemnt non-array");
+
+    if(num->refcount != 1)
+        fail("unexpected reference count on num");
+    if(arr->refcount != 1)
+        fail("unexpected reference count on arr");
+
+    json_decref(num);
+    json_decref(arr);
+}

 static void run_tests()
 {
@@ -429,4 +501,5 @@ static void run_tests()
    test_extend();
    test_circular();
    test_array_foreach();
+    test_bad_args();
 }
--- a/test/suites/api/test_chaos.c
+++ b/test/suites/api/test_chaos.c
@@ -0,0 +1,177 @@
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <jansson.h>
+#include "util.h"
+
+static int chaos_pos = 0;
+static int chaos_fail = 0;
+#define CHAOS_MAX_FAILURE 100
+
+void *chaos_malloc(size_t size)
+{
+    if (chaos_pos == chaos_fail)
+        return NULL;
+
+    chaos_pos++;
+
+    return malloc(size);
+}
+
+void chaos_free(void *obj)
+{
+    free(obj);
+}
+
+/* Test all potential allocation failures. */
+#define chaos_loop(condition, code, cleanup) \
+    { \
+        chaos_pos = chaos_fail = 0; \
+        while (condition) { \
+            if (chaos_fail > CHAOS_MAX_FAILURE) \
+                fail("too many chaos failures"); \
+            code \
+            chaos_pos = 0; \
+            chaos_fail++; \
+        } \
+        cleanup \
+    }
+
+#define chaos_loop_new_value(json, initcall) \
+    chaos_loop(!json, json = initcall;, json_decref(json); json = NULL;)
+
+int test_unpack()
+{
+    int ret = -1;
+    int v1;
+    int v2;
+    json_error_t error;
+    json_t *root = json_pack("{s:i, s:i, s:i, s:i}", "n1", 1, "n2", 2, "n3", 3, "n4", 4);
+
+    if (!root)
+        return -1;
+
+    if (!json_unpack_ex(root, &error, JSON_STRICT, "{s:i, s:i}", "n1", &v1, "n2", &v2))
+        fail("Unexpected success");
+
+    if (json_error_code(&error) != json_error_end_of_input_expected) {
+        if (json_error_code(&error) != json_error_out_of_memory)
+            fail("Unexpected error code");
+
+        goto out;
+    }
+
+    if (strcmp(error.text, "2 object item(s) left unpacked: n3, n4"))
+        goto out;
+
+    ret = 0;
+
+out:
+    json_decref(root);
+    return ret;
+}
+
+int dump_chaos_callback(const char *buffer, size_t size, void *data)
+{
+    json_t *obj = json_object();
+
+    (void)buffer;
+    (void)size;
+    (void)data;
+
+    if (!obj)
+        return -1;
+
+    json_decref(obj);
+
+    return 0;
+}
+
+static void test_chaos()
+{
+    json_malloc_t orig_malloc;
+    json_free_t orig_free;
+    json_t *json = NULL;
+    json_t *obj = json_object();
+    json_t *arr1 = json_array();
+    json_t *arr2 = json_array();
+    json_t *txt = json_string("test");
+    json_t *intnum = json_integer(1);
+    json_t *dblnum = json_real(0.5);
+    char *dumptxt = NULL;
+    json_t *dumpobj = json_pack("{s:[iiis], s:s}",
+        "key1", 1, 2, 3, "txt",
+        "key2", "v2");
+    int keyno;
+
+    if (!obj || !arr1 || !arr2 || !txt || !intnum || !dblnum || !dumpobj)
+        fail("failed to allocate basic objects");
+
+    json_get_alloc_funcs(&orig_malloc, &orig_free);
+    json_set_alloc_funcs(chaos_malloc, chaos_free);
+
+    chaos_loop_new_value(json, json_pack("{s:s}", "key", "value"));
+    chaos_loop_new_value(json, json_pack("{s:[]}", "key"));
+    chaos_loop_new_value(json, json_pack("[biIf]", 1, 1, (json_int_t)1, 1.0));
+    chaos_loop_new_value(json, json_pack("[s*,s*]", "v1", "v2"));
+    chaos_loop_new_value(json, json_pack("o", json_incref(txt)));
+    chaos_loop_new_value(json, json_pack("O", txt));
+    chaos_loop_new_value(json, json_pack("s++", "a",
+        "long string to force realloc",
+        "another long string to force yet another reallocation of the string because "
+        "that's what we are testing."));
+
+    chaos_loop(test_unpack(),,);
+
+    chaos_loop(json_dump_callback(dumpobj, dump_chaos_callback, NULL, JSON_INDENT(1)),,);
+    chaos_loop(json_dump_callback(dumpobj, dump_chaos_callback, NULL, JSON_INDENT(1) | JSON_SORT_KEYS),,);
+    chaos_loop(!dumptxt, dumptxt = json_dumps(dumpobj, JSON_COMPACT);, free(dumptxt); dumptxt = NULL;);
+
+    chaos_loop_new_value(json, json_copy(obj));
+    chaos_loop_new_value(json, json_deep_copy(obj));
+
+    chaos_loop_new_value(json, json_copy(arr1));
+    chaos_loop_new_value(json, json_deep_copy(arr1));
+
+    chaos_loop_new_value(json, json_copy(txt));
+    chaos_loop_new_value(json, json_copy(intnum));
+    chaos_loop_new_value(json, json_copy(dblnum));
+
+#define JSON_LOAD_TXT "{\"n\":[1,2,3,4,5,6,7,8,9,10]}"
+    chaos_loop_new_value(json, json_loads(JSON_LOAD_TXT, 0, NULL));
+    chaos_loop_new_value(json, json_loadb(JSON_LOAD_TXT, strlen(JSON_LOAD_TXT), 0, NULL));
+
+    chaos_loop_new_value(json, json_sprintf("%s", "string"));
+
+    for (keyno = 0; keyno < 100; ++keyno) {
+#if !defined(_MSC_VER) || _MSC_VER >= 1900
+        /* Skip this test on old Windows compilers. */
+        char testkey[10];
+
+        snprintf(testkey, sizeof(testkey), "test%d", keyno);
+        chaos_loop(json_object_set_new_nocheck(obj, testkey, json_object()),,);
+#endif
+        chaos_loop(json_array_append_new(arr1, json_null()),,);
+        chaos_loop(json_array_insert_new(arr2, 0, json_null()),,);
+    }
+
+    chaos_loop(json_array_extend(arr1, arr2),,);
+    chaos_loop(json_string_set_nocheck(txt, "test"),,);
+
+    json_set_alloc_funcs(orig_malloc, orig_free);
+    json_decref(obj);
+    json_decref(arr1);
+    json_decref(arr2);
+    json_decref(txt);
+    json_decref(intnum);
+    json_decref(dblnum);
+    json_decref(dumpobj);
+}
+
+static void run_tests()
+{
+    test_chaos();
+}
--- a/test/suites/api/test_equal.c
+++ b/test/suites/api/test_equal.c
@@ -74,6 +74,13 @@ static void test_equal_simple()
        fail("unable to create an string");
    if(json_equal(value1, value2))
        fail("json_equal fails for two inequal strings");
+    json_decref(value2);
+
+    value2 = json_string("bar2");
+    if(!value2)
+        fail("unable to create an string");
+    if(json_equal(value1, value2))
+        fail("json_equal fails for two inequal length strings");

    json_decref(value1);
    json_decref(value2);
--- a/test/suites/api/test_load.c
+++ b/test/suites/api/test_load.c
@@ -32,6 +32,8 @@ static void file_not_found()

    if(strcmp(error.text, "unable to open /path/to/nonexistent/file.json") != 0)
        fail("json_load_file returned an invalid error message");
+    if(json_error_code(&error) != json_error_cannot_open_file)
+        fail("json_load_file returned an invalid error code");
 }

 static void very_long_file_name() {
@@ -46,6 +48,8 @@ static void very_long_file_name() {

    if (strncmp(error.source, "...aaa", 6) != 0)
        fail("error source was set incorrectly");
+    if(json_error_code(&error) != json_error_cannot_open_file)
+        fail("error code was set incorrectly");
 }

 static void reject_duplicates()
@@ -54,7 +58,7 @@ static void reject_duplicates()

    if(json_loads("{\"foo\": 1, \"foo\": 2}", JSON_REJECT_DUPLICATES, &error))
        fail("json_loads did not detect a duplicate key");
-    check_error("duplicate object key near '\"foo\"'", "<string>", 1, 16, 16);
+    check_error(json_error_duplicate_key, "duplicate object key near '\"foo\"'", "<string>", 1, 16, 16);
 }

 static void disable_eof_check()
@@ -66,7 +70,7 @@ static void disable_eof_check()

    if(json_loads(text, 0, &error))
        fail("json_loads did not detect garbage after JSON text");
-    check_error("end of file expected near 'garbage'", "<string>", 1, 18, 18);
+    check_error(json_error_end_of_input_expected, "end of file expected near 'garbage'", "<string>", 1, 18, 18);

    json = json_loads(text, JSON_DISABLE_EOF_CHECK, &error);
    if(!json)
@@ -137,7 +141,8 @@ static void decode_int_as_real()
    big[310] = '\0';

    json = json_loads(big, JSON_DECODE_INT_AS_REAL | JSON_DECODE_ANY, &error);
-    if (json || strcmp(error.text, "real number overflow") != 0)
+    if (json || strcmp(error.text, "real number overflow") != 0 ||
+        json_error_code(&error) != json_error_numeric_overflow)
        fail("json_load decode int as real failed - expected overflow");
    json_decref(json);

@@ -206,6 +211,26 @@ static void position()
    json_decref(json);
 }

+static void error_code()
+{
+    json_error_t error;
+    json_t *json = json_loads("[123] garbage", 0, &error);
+    if(json != NULL)
+        fail("json_loads returned not NULL");
+    if(strlen(error.text) >= JSON_ERROR_TEXT_LENGTH)
+        fail("error.text longer than expected");
+    if(json_error_code(&error) != json_error_end_of_input_expected)
+        fail("json_loads returned incorrect error code");
+
+    json = json_loads("{\"foo\": ", 0, &error);
+    if(json != NULL)
+        fail("json_loads returned not NULL");
+    if(strlen(error.text) >= JSON_ERROR_TEXT_LENGTH)
+        fail("error.text longer than expected");
+    if(json_error_code(&error) != json_error_premature_end_of_input)
+        fail("json_loads returned incorrect error code");
+}
+
 static void run_tests()
 {
    file_not_found();
@@ -217,4 +242,5 @@ static void run_tests()
    allow_nul();
    load_wrong_args();
    position();
+    error_code();
 }
--- a/test/suites/api/test_memory_funcs.c
+++ b/test/suites/api/test_memory_funcs.c
@@ -122,9 +122,16 @@ static void test_secure_funcs(void)
    create_and_free_complex_object();
 }

+static void test_bad_args(void)
+{
+    /* The result of this test is not crashing. */
+    json_get_alloc_funcs(NULL, NULL);
+}
+
 static void run_tests()
 {
    test_simple();
    test_secure_funcs();
    test_oom();
+    test_bad_args();
 }
--- a/test/suites/api/test_number.c
+++ b/test/suites/api/test_number.c
@@ -37,6 +37,41 @@ static void test_inifity()
 }
 #endif // INFINITY

+static void test_bad_args(void)
+{
+    json_t *txt = json_string("test");
+
+    if(json_integer_value(NULL) != 0)
+        fail("json_integer_value did not return 0 for non-integer");
+    if(json_integer_value(txt) != 0)
+        fail("json_integer_value did not return 0 for non-integer");
+
+    if(!json_integer_set(NULL, 0))
+        fail("json_integer_set did not return error for non-integer");
+    if(!json_integer_set(txt, 0))
+        fail("json_integer_set did not return error for non-integer");
+
+    if(json_real_value(NULL) != 0.0)
+        fail("json_real_value did not return 0.0 for non-real");
+    if(json_real_value(txt) != 0.0)
+        fail("json_real_value did not return 0.0 for non-real");
+
+    if(!json_real_set(NULL, 0.0))
+        fail("json_real_set did not return error for non-real");
+    if(!json_real_set(txt, 0.0))
+        fail("json_real_set did not return error for non-real");
+
+    if(json_number_value(NULL) != 0.0)
+        fail("json_number_value did not return 0.0 for non-numeric");
+    if(json_number_value(txt) != 0.0)
+        fail("json_number_value did not return 0.0 for non-numeric");
+
+    if (txt->refcount != 1)
+        fail("unexpected reference count for txt");
+
+    json_decref(txt);
+}
+
 static void run_tests()
 {
    json_t *integer, *real;
@@ -87,4 +122,5 @@ static void run_tests()
 #ifdef INFINITY
    test_inifity();
 #endif
+    test_bad_args();
 }
--- a/test/suites/api/test_object.c
+++ b/test/suites/api/test_object.c
@@ -539,6 +539,127 @@ static void test_object_foreach_safe()
    json_decref(object);
 }

+static void test_bad_args(void)
+{
+    json_t *obj = json_object();
+    json_t *num = json_integer(1);
+    void *iter;
+
+    if (!obj || !num)
+        fail("failed to allocate test objects");
+
+    if (json_object_set(obj, "testkey", json_null()))
+        fail("failed to set testkey on object");
+
+    iter = json_object_iter(obj);
+    if (!iter)
+        fail("failed to retrieve test iterator");
+
+    if(json_object_size(NULL) != 0)
+        fail("json_object_size with non-object argument returned non-zero");
+    if(json_object_size(num) != 0)
+        fail("json_object_size with non-object argument returned non-zero");
+
+    if(json_object_get(NULL, "test") != NULL)
+        fail("json_object_get with non-object argument returned non-NULL");
+    if(json_object_get(num, "test") != NULL)
+        fail("json_object_get with non-object argument returned non-NULL");
+    if(json_object_get(obj, NULL) != NULL)
+        fail("json_object_get with NULL key returned non-NULL");
+
+    if(!json_object_set_new_nocheck(NULL, "test", json_null()))
+        fail("json_object_set_new_nocheck with non-object argument did not return error");
+    if(!json_object_set_new_nocheck(num, "test", json_null()))
+        fail("json_object_set_new_nocheck with non-object argument did not return error");
+    if(!json_object_set_new_nocheck(obj, "test", json_incref(obj)))
+        fail("json_object_set_new_nocheck with object == value did not return error");
+    if(!json_object_set_new_nocheck(obj, NULL, json_object()))
+        fail("json_object_set_new_nocheck with NULL key did not return error");
+
+    if(!json_object_del(NULL, "test"))
+        fail("json_object_del with non-object argument did not return error");
+    if(!json_object_del(num, "test"))
+        fail("json_object_del with non-object argument did not return error");
+    if(!json_object_del(obj, NULL))
+        fail("json_object_del with NULL key did not return error");
+
+    if(!json_object_clear(NULL))
+        fail("json_object_clear with non-object argument did not return error");
+    if(!json_object_clear(num))
+        fail("json_object_clear with non-object argument did not return error");
+
+    if(!json_object_update(NULL, obj))
+        fail("json_object_update with non-object first argument did not return error");
+    if(!json_object_update(num, obj))
+        fail("json_object_update with non-object first argument did not return error");
+    if(!json_object_update(obj, NULL))
+        fail("json_object_update with non-object second argument did not return error");
+    if(!json_object_update(obj, num))
+        fail("json_object_update with non-object second argument did not return error");
+
+    if(!json_object_update_existing(NULL, obj))
+        fail("json_object_update_existing with non-object first argument did not return error");
+    if(!json_object_update_existing(num, obj))
+        fail("json_object_update_existing with non-object first argument did not return error");
+    if(!json_object_update_existing(obj, NULL))
+        fail("json_object_update_existing with non-object second argument did not return error");
+    if(!json_object_update_existing(obj, num))
+        fail("json_object_update_existing with non-object second argument did not return error");
+
+    if(!json_object_update_missing(NULL, obj))
+        fail("json_object_update_missing with non-object first argument did not return error");
+    if(!json_object_update_missing(num, obj))
+        fail("json_object_update_missing with non-object first argument did not return error");
+    if(!json_object_update_missing(obj, NULL))
+        fail("json_object_update_missing with non-object second argument did not return error");
+    if(!json_object_update_missing(obj, num))
+        fail("json_object_update_missing with non-object second argument did not return error");
+
+    if(json_object_iter(NULL) != NULL)
+        fail("json_object_iter with non-object argument returned non-NULL");
+    if(json_object_iter(num) != NULL)
+        fail("json_object_iter with non-object argument returned non-NULL");
+
+    if(json_object_iter_at(NULL, "test") != NULL)
+        fail("json_object_iter_at with non-object argument returned non-NULL");
+    if(json_object_iter_at(num, "test") != NULL)
+        fail("json_object_iter_at with non-object argument returned non-NULL");
+    if(json_object_iter_at(obj, NULL) != NULL)
+        fail("json_object_iter_at with NULL iter returned non-NULL");
+
+    if(json_object_iter_next(obj, NULL) != NULL)
+        fail("json_object_iter_next with NULL iter returned non-NULL");
+    if(json_object_iter_next(num, iter) != NULL)
+        fail("json_object_iter_next with non-object argument returned non-NULL");
+
+    if(json_object_iter_key(NULL) != NULL)
+        fail("json_object_iter_key with NULL iter returned non-NULL");
+
+    if(json_object_key_to_iter(NULL) != NULL)
+        fail("json_object_key_to_iter with NULL iter returned non-NULL");
+
+    if(json_object_iter_value(NULL) != NULL)
+        fail("json_object_iter_value with NULL iter returned non-NULL");
+
+    if(!json_object_iter_set_new(NULL, iter, json_incref(num)))
+        fail("json_object_iter_set_new with non-object argument did not return error");
+    if(!json_object_iter_set_new(num, iter, json_incref(num)))
+        fail("json_object_iter_set_new with non-object argument did not return error");
+    if(!json_object_iter_set_new(obj, NULL, json_incref(num)))
+        fail("json_object_iter_set_new with NULL iter did not return error");
+    if(!json_object_iter_set_new(obj, iter, NULL))
+        fail("json_object_iter_set_new with NULL value did not return error");
+
+    if (obj->refcount != 1)
+        fail("unexpected reference count for obj");
+
+    if (num->refcount != 1)
+        fail("unexpected reference count for num");
+
+    json_decref(obj);
+    json_decref(num);
+}
+
 static void run_tests()
 {
    test_misc();
@@ -552,4 +673,5 @@ static void run_tests()
    test_preserve_order();
    test_object_foreach();
    test_object_foreach_safe();
+    test_bad_args();
 }
--- a/test/suites/api/test_pack.c
+++ b/test/suites/api/test_pack.c
@@ -15,8 +15,39 @@
 #include <string.h>
 #include <jansson.h>
 #include <stdio.h>
+#include <math.h>
 #include "util.h"

+#ifdef INFINITY
+// This test triggers "warning C4756: overflow in constant arithmetic"
+// in Visual Studio. This warning is triggered here by design, so disable it.
+// (This can only be done on function level so we keep these tests separate)
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning (disable: 4756)
+#endif
+static void test_inifity()
+{
+    json_error_t error;
+
+    if (json_pack_ex(&error, 0, "f", INFINITY))
+       fail("json_pack infinity incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, 1, 1);
+
+    if (json_pack_ex(&error, 0, "[f]", INFINITY))
+       fail("json_pack infinity array element incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, 2, 2);
+
+    if (json_pack_ex(&error, 0, "{s:f}", "key", INFINITY))
+       fail("json_pack infinity object value incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, 4, 4);
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+}
+#endif // INFINITY
+
 static void run_tests()
 {
    json_t *value;
@@ -99,6 +130,16 @@ static void run_tests()
        fail("json_pack nullable string (NULL case) refcount failed");
    json_decref(value);

+    /* nullable string concatenation */
+    if(json_pack_ex(&error, 0, "s?+", "test", "ing"))
+        fail("json_pack failed to catch invalid format 's?+'");
+    check_error(json_error_invalid_format, "Cannot use '+' on optional strings", "<format>", 1, 2, 2);
+
+    /* nullable string with integer length */
+    if(json_pack_ex(&error, 0, "s?#", "test", 4))
+        fail("json_pack failed to catch invalid format 's?#'");
+    check_error(json_error_invalid_format, "Cannot use '#' on optional strings", "<format>", 1, 2, 2);
+
    /* string and length (int) */
    value = json_pack("s#", "test asdf", 4);
    if(!json_is_string(value) || strcmp("test", json_string_value(value)))
@@ -132,6 +173,9 @@ static void run_tests()
    json_decref(value);

    /* string concatenation */
+    if (json_pack("s+", "test", NULL))
+        fail("json_pack string concatenation succeeded with NULL string");
+
    value = json_pack("s++", "te", "st", "ing");
    if(!json_is_string(value) || strcmp("testing", json_string_value(value)))
        fail("json_pack string concatenation failed");
@@ -240,6 +284,36 @@ static void run_tests()
        fail("json_pack object refcount failed");
    json_decref(value);

+    /* object with optional members */
+    value = json_pack("{s:s,s:o,s:O}", "a", NULL, "b", NULL, "c", NULL);
+    if(value)
+        fail("json_pack object optional incorrectly succeeded");
+
+    value = json_pack("{s:**}", "a", NULL);
+    if(value)
+        fail("json_pack object optional invalid incorrectly succeeded");
+
+    if (json_pack_ex(&error, 0, "{s:i*}", "a", 1))
+        fail("json_pack object optional invalid incorrectly succeeded");
+    check_error(json_error_invalid_format, "Expected format 's', got '*'", "<format>", 1, 5, 5);
+
+    value = json_pack("{s:s*,s:o*,s:O*}", "a", NULL, "b", NULL, "c", NULL);
+    if(!json_is_object(value) || json_object_size(value) != 0)
+        fail("json_pack object optional failed");
+    json_decref(value);
+
+    value = json_pack("{s:s*}", "key", "\xff\xff");
+    if(value)
+        fail("json_pack object optional with invalid UTF-8 incorrectly succeeded");
+
+    if(json_pack_ex(&error, 0, "{s: s*#}", "key", "test", 1))
+        fail("json_pack failed to catch invalid format 's*#'");
+    check_error(json_error_invalid_format, "Cannot use '#' on optional strings", "<format>", 1, 6, 6);
+
+    if(json_pack_ex(&error, 0, "{s: s*+}", "key", "test", "ing"))
+        fail("json_pack failed to catch invalid format 's*+'");
+    check_error(json_error_invalid_format, "Cannot use '+' on optional strings", "<format>", 1, 6, 6);
+
    /* simple array */
    value = json_pack("[i,i,i]", 0, 1, 2);
    if(!json_is_array(value) || json_array_size(value) != 3)
@@ -253,8 +327,44 @@ static void run_tests()
    }
    json_decref(value);

+    /* simple array with optional members */
+    value = json_pack("[s,o,O]", NULL, NULL, NULL);
+    if(value)
+        fail("json_pack array optional incorrectly succeeded");
+
+    if (json_pack_ex(&error, 0, "[i*]", 1))
+        fail("json_pack array optional invalid incorrectly succeeded");
+    check_error(json_error_invalid_format, "Unexpected format character '*'", "<format>", 1, 3, 3);
+
+    value = json_pack("[**]", NULL);
+    if(value)
+        fail("json_pack array optional invalid incorrectly succeeded");
+    value = json_pack("[s*,o*,O*]", NULL, NULL, NULL);
+    if(!json_is_array(value) || json_array_size(value) != 0)
+        fail("json_pack array optional failed");
+    json_decref(value);
+
+#ifdef NAN
+    /* Invalid float values */
+    if (json_pack_ex(&error, 0, "f", NAN))
+        fail("json_pack NAN incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, 1, 1);
+
+    if (json_pack_ex(&error, 0, "[f]", NAN))
+       fail("json_pack NAN array element incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, 2, 2);
+
+    if (json_pack_ex(&error, 0, "{s:f}", "key", NAN))
+       fail("json_pack NAN object value incorrectly succeeded");
+    check_error(json_error_numeric_overflow, "Invalid floating point value", "<args>", 1, 4, 4);
+#endif
+
+#ifdef INFINITY
+    test_inifity();
+#endif
+
    /* Whitespace; regular string */
-    value = json_pack(" s ", "test");
+    value = json_pack(" s\t ", "test");
    if(!json_is_string(value) || strcmp("test", json_string_value(value)))
        fail("json_pack string (with whitespace) failed");
    json_decref(value);
@@ -278,78 +388,131 @@ static void run_tests()
    /* newline in format string */
    if(json_pack_ex(&error, 0, "{\n\n1"))
        fail("json_pack failed to catch invalid format '1'");
-    check_error("Expected format 's', got '1'", "<format>", 3, 1, 4);
+    check_error(json_error_invalid_format, "Expected format 's', got '1'", "<format>", 3, 1, 4);

    /* mismatched open/close array/object */
    if(json_pack_ex(&error, 0, "[}"))
        fail("json_pack failed to catch mismatched '}'");
-    check_error("Unexpected format character '}'", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", 1, 2, 2);

    if(json_pack_ex(&error, 0, "{]"))
        fail("json_pack failed to catch mismatched ']'");
-    check_error("Expected format 's', got ']'", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Expected format 's', got ']'", "<format>", 1, 2, 2);

    /* missing close array */
    if(json_pack_ex(&error, 0, "["))
        fail("json_pack failed to catch missing ']'");
-    check_error("Unexpected end of format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", 1, 2, 2);

    /* missing close object */
    if(json_pack_ex(&error, 0, "{"))
        fail("json_pack failed to catch missing '}'");
-    check_error("Unexpected end of format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", 1, 2, 2);

    /* garbage after format string */
    if(json_pack_ex(&error, 0, "[i]a", 42))
        fail("json_pack failed to catch garbage after format string");
-    check_error("Garbage after format string", "<format>", 1, 4, 4);
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, 4, 4);

    if(json_pack_ex(&error, 0, "ia", 42))
        fail("json_pack failed to catch garbage after format string");
-    check_error("Garbage after format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, 2, 2);

    /* NULL string */
    if(json_pack_ex(&error, 0, "s", NULL))
        fail("json_pack failed to catch null argument string");
-    check_error("NULL string argument", "<args>", 1, 1, 1);
+    check_error(json_error_null_value, "NULL string", "<args>", 1, 1, 1);

    /* + on its own */
    if(json_pack_ex(&error, 0, "+", NULL))
        fail("json_pack failed to a lone +");
-    check_error("Unexpected format character '+'", "<format>", 1, 1, 1);
+    check_error(json_error_invalid_format, "Unexpected format character '+'", "<format>", 1, 1, 1);
+
+    /* Empty format */
+    if(json_pack_ex(&error, 0, ""))
+        fail("json_pack failed to catch empty format string");
+    check_error(json_error_invalid_argument, "NULL or empty format string", "<format>", -1, -1, 0);

    /* NULL format */
    if(json_pack_ex(&error, 0, NULL))
        fail("json_pack failed to catch NULL format string");
-    check_error("NULL or empty format string", "<format>", -1, -1, 0);
+    check_error(json_error_invalid_argument, "NULL or empty format string", "<format>", -1, -1, 0);

    /* NULL key */
    if(json_pack_ex(&error, 0, "{s:i}", NULL, 1))
        fail("json_pack failed to catch NULL key");
-    check_error("NULL string argument", "<args>", 1, 2, 2);
+    check_error(json_error_null_value, "NULL object key", "<args>", 1, 2, 2);
+
+    /* NULL value followed by object still steals the object's ref */
+    value = json_incref(json_object());
+    if(json_pack_ex(&error, 0, "{s:s,s:o}", "badnull", NULL, "dontleak", value))
+        fail("json_pack failed to catch NULL value");
+    check_error(json_error_null_value, "NULL string", "<args>", 1, 4, 4);
+    if(value->refcount != (size_t)1)
+        fail("json_pack failed to steal reference after error.");
+    json_decref(value);

    /* More complicated checks for row/columns */
    if(json_pack_ex(&error, 0, "{ {}: s }", "foo"))
        fail("json_pack failed to catch object as key");
-    check_error("Expected format 's', got '{'", "<format>", 1, 3, 3);
+    check_error(json_error_invalid_format, "Expected format 's', got '{'", "<format>", 1, 3, 3);

    /* Complex object */
    if(json_pack_ex(&error, 0, "{ s: {},  s:[ii{} }", "foo", "bar", 12, 13))
        fail("json_pack failed to catch missing ]");
-    check_error("Unexpected format character '}'", "<format>", 1, 19, 19);
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", 1, 19, 19);

    /* Complex array */
    if(json_pack_ex(&error, 0, "[[[[[   [[[[[  [[[[ }]]]] ]]]] ]]]]]"))
        fail("json_pack failed to catch extra }");
-    check_error("Unexpected format character '}'", "<format>", 1, 21, 21);
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", 1, 21, 21);

    /* Invalid UTF-8 in object key */
    if(json_pack_ex(&error, 0, "{s:i}", "\xff\xff", 42))
        fail("json_pack failed to catch invalid UTF-8 in an object key");
-    check_error("Invalid UTF-8 object key", "<args>", 1, 2, 2);
+    check_error(json_error_invalid_utf8, "Invalid UTF-8 object key", "<args>", 1, 2, 2);

    /* Invalid UTF-8 in a string */
    if(json_pack_ex(&error, 0, "{s:s}", "foo", "\xff\xff"))
        fail("json_pack failed to catch invalid UTF-8 in a string");
-    check_error("Invalid UTF-8 string", "<args>", 1, 4, 4);
+    check_error(json_error_invalid_utf8, "Invalid UTF-8 string", "<args>", 1, 4, 4);
+
+    /* Invalid UTF-8 in an optional '?' string */
+    if(json_pack_ex(&error, 0, "{s:s?}", "foo", "\xff\xff"))
+        fail("json_pack failed to catch invalid UTF-8 in an optional '?' string");
+    check_error(json_error_invalid_utf8, "Invalid UTF-8 string", "<args>", 1, 5, 5);
+
+    /* Invalid UTF-8 in an optional '*' string */
+    if(json_pack_ex(&error, 0, "{s:s*}", "foo", "\xff\xff"))
+        fail("json_pack failed to catch invalid UTF-8 in an optional '*' string");
+    check_error(json_error_invalid_utf8, "Invalid UTF-8 string", "<args>", 1, 5, 5);
+
+    /* Invalid UTF-8 in a concatenated key */
+    if(json_pack_ex(&error, 0, "{s+:i}", "\xff\xff", "concat", 42))
+        fail("json_pack failed to catch invalid UTF-8 in an object key");
+    check_error(json_error_invalid_utf8, "Invalid UTF-8 object key", "<args>", 1, 3, 3);
+
+    if(json_pack_ex(&error, 0, "{s:o}", "foo", NULL))
+        fail("json_pack failed to catch nullable object");
+    check_error(json_error_null_value, "NULL object", "<args>", 1, 4, 4);
+
+    if(json_pack_ex(&error, 0, "{s:O}", "foo", NULL))
+        fail("json_pack failed to catch nullable incref object");
+    check_error(json_error_null_value, "NULL object", "<args>", 1, 4, 4);
+
+    if(json_pack_ex(&error, 0, "{s+:o}", "foo", "bar", NULL))
+        fail("json_pack failed to catch non-nullable object value");
+    check_error(json_error_null_value, "NULL object", "<args>", 1, 5, 5);
+
+    if(json_pack_ex(&error, 0, "[1s", "Hi"))
+        fail("json_pack failed to catch invalid format");
+    check_error(json_error_invalid_format, "Unexpected format character '1'", "<format>", 1, 2, 2);
+
+    if(json_pack_ex(&error, 0, "[1s+", "Hi", "ya"))
+        fail("json_pack failed to catch invalid format");
+    check_error(json_error_invalid_format, "Unexpected format character '1'", "<format>", 1, 2, 2);
+
+    if(json_pack_ex(&error, 0, "[so]", NULL, json_object()))
+        fail("json_pack failed to catch NULL value");
+    check_error(json_error_null_value, "NULL string", "<args>", 1, 2, 2);
 }
--- a/test/suites/api/test_simple.c
+++ b/test/suites/api/test_simple.c
@@ -9,6 +9,56 @@
 #include <jansson.h>
 #include "util.h"

+static void test_bad_args(void)
+{
+    json_t *num = json_integer(1);
+    json_t *txt = json_string("test");
+
+    if (!num || !txt)
+        fail("failed to allocate test objects");
+
+    if(json_string_nocheck(NULL) != NULL)
+        fail("json_string_nocheck with NULL argument did not return NULL");
+    if(json_stringn_nocheck(NULL, 0) != NULL)
+        fail("json_stringn_nocheck with NULL argument did not return NULL");
+    if(json_string(NULL) != NULL)
+        fail("json_string with NULL argument did not return NULL");
+    if(json_stringn(NULL, 0) != NULL)
+        fail("json_stringn with NULL argument did not return NULL");
+
+    if(json_string_length(NULL) != 0)
+        fail("json_string_length with non-string argument did not return 0");
+    if(json_string_length(num) != 0)
+        fail("json_string_length with non-string argument did not return 0");
+
+    if(json_string_value(NULL) != NULL)
+        fail("json_string_value with non-string argument did not return NULL");
+    if(json_string_value(num) != NULL)
+        fail("json_string_value with non-string argument did not return NULL");
+
+    if(!json_string_setn_nocheck(NULL, "", 0))
+        fail("json_string_setn with non-string argument did not return error");
+    if(!json_string_setn_nocheck(num, "", 0))
+        fail("json_string_setn with non-string argument did not return error");
+    if(!json_string_setn_nocheck(txt, NULL, 0))
+        fail("json_string_setn_nocheck with NULL value did not return error");
+
+    if(!json_string_set_nocheck(txt, NULL))
+        fail("json_string_set_nocheck with NULL value did not return error");
+    if(!json_string_set(txt, NULL))
+        fail("json_string_set with NULL value did not return error");
+    if(!json_string_setn(txt, NULL, 0))
+        fail("json_string_setn with NULL value did not return error");
+
+    if(num->refcount != 1)
+        fail("unexpected reference count for num");
+    if(txt->refcount != 1)
+        fail("unexpected reference count for txt");
+
+    json_decref(num);
+    json_decref(txt);
+}
+
 /* Call the simple functions not covered by other tests of the public API */
 static void run_tests()
 {
@@ -237,4 +287,6 @@ static void run_tests()
 	fail("automatic decrement failed");
    json_decref(value);
 #endif
+
+    test_bad_args();
 }
--- a/test/suites/api/test_sprintf.c
+++ b/test/suites/api/test_sprintf.c
@@ -0,0 +1,34 @@
+#include <string.h>
+#include <jansson.h>
+#include "util.h"
+
+
+static void test_sprintf() {
+    json_t *s = json_sprintf("foo bar %d", 42);
+    if (!s)
+        fail("json_sprintf returned NULL");
+    if (!json_is_string(s))
+        fail("json_sprintf didn't return a JSON string");
+    if (strcmp(json_string_value(s), "foo bar 42"))
+        fail("json_sprintf generated an unexpected string");
+
+    json_decref(s);
+
+    s = json_sprintf("%s", "");
+    if (!s)
+        fail("json_sprintf returned NULL");
+    if (!json_is_string(s))
+        fail("json_sprintf didn't return a JSON string");
+    if (json_string_length(s) != 0)
+        fail("string is not empty");
+    json_decref(s);
+
+    if (json_sprintf("%s", "\xff\xff"))
+        fail("json_sprintf unexpected success with invalid UTF");
+}
+
+
+static void run_tests()
+{
+    test_sprintf();
+}
--- a/test/suites/api/test_unpack.c
+++ b/test/suites/api/test_unpack.c
@@ -144,65 +144,65 @@ static void run_tests()
    j = json_integer(42);
    if(!json_unpack_ex(j, &error, 0, "z"))
        fail("json_unpack succeeded with invalid format character");
-    check_error("Unexpected format character 'z'", "<format>", 1, 1, 1);
+    check_error(json_error_invalid_format, "Unexpected format character 'z'", "<format>", 1, 1, 1);

    if(!json_unpack_ex(NULL, &error, 0, "[i]"))
        fail("json_unpack succeeded with NULL root");
-    check_error("NULL root value", "<root>", -1, -1, 0);
+    check_error(json_error_null_value, "NULL root value", "<root>", -1, -1, 0);
    json_decref(j);

    /* mismatched open/close array/object */
    j = json_pack("[]");
    if(!json_unpack_ex(j, &error, 0, "[}"))
        fail("json_unpack failed to catch mismatched ']'");
-    check_error("Unexpected format character '}'", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected format character '}'", "<format>", 1, 2, 2);
    json_decref(j);

    j = json_pack("{}");
    if(!json_unpack_ex(j, &error, 0, "{]"))
        fail("json_unpack failed to catch mismatched '}'");
-    check_error("Expected format 's', got ']'", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Expected format 's', got ']'", "<format>", 1, 2, 2);
    json_decref(j);

    /* missing close array */
    j = json_pack("[]");
    if(!json_unpack_ex(j, &error, 0, "["))
        fail("json_unpack failed to catch missing ']'");
-    check_error("Unexpected end of format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", 1, 2, 2);
    json_decref(j);

    /* missing close object */
    j = json_pack("{}");
    if(!json_unpack_ex(j, &error, 0, "{"))
        fail("json_unpack failed to catch missing '}'");
-    check_error("Unexpected end of format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Unexpected end of format string", "<format>", 1, 2, 2);
    json_decref(j);

    /* garbage after format string */
    j = json_pack("[i]", 42);
    if(!json_unpack_ex(j, &error, 0, "[i]a", &i1))
        fail("json_unpack failed to catch garbage after format string");
-    check_error("Garbage after format string", "<format>", 1, 4, 4);
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, 4, 4);
    json_decref(j);

    j = json_integer(12345);
    if(!json_unpack_ex(j, &error, 0, "ia", &i1))
        fail("json_unpack failed to catch garbage after format string");
-    check_error("Garbage after format string", "<format>", 1, 2, 2);
+    check_error(json_error_invalid_format, "Garbage after format string", "<format>", 1, 2, 2);
    json_decref(j);

    /* NULL format string */
    j = json_pack("[]");
    if(!json_unpack_ex(j, &error, 0, NULL))
        fail("json_unpack failed to catch null format string");
-    check_error("NULL or empty format string", "<format>", -1, -1, 0);
+    check_error(json_error_invalid_argument, "NULL or empty format string", "<format>", -1, -1, 0);
    json_decref(j);

    /* NULL string pointer */
    j = json_string("foobie");
    if(!json_unpack_ex(j, &error, 0, "s", NULL))
        fail("json_unpack failed to catch null string pointer");
-    check_error("NULL string argument", "<args>", 1, 1, 1);
+    check_error(json_error_null_value, "NULL string argument", "<args>", 1, 1, 1);
    json_decref(j);

    /* invalid types */
@@ -210,39 +210,39 @@ static void run_tests()
    j2 = json_string("foo");
    if(!json_unpack_ex(j, &error, 0, "s"))
        fail("json_unpack failed to catch invalid type");
-    check_error("Expected string, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected string, got integer", "<validation>", 1, 1, 1);

    if(!json_unpack_ex(j, &error, 0, "n"))
        fail("json_unpack failed to catch invalid type");
-    check_error("Expected null, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected null, got integer", "<validation>", 1, 1, 1);

    if(!json_unpack_ex(j, &error, 0, "b"))
        fail("json_unpack failed to catch invalid type");
-    check_error("Expected true or false, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected true or false, got integer", "<validation>", 1, 1, 1);

    if(!json_unpack_ex(j2, &error, 0, "i"))
        fail("json_unpack failed to catch invalid type");
-    check_error("Expected integer, got string", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected integer, got string", "<validation>", 1, 1, 1);

    if(!json_unpack_ex(j2, &error, 0, "I"))
        fail("json_unpack failed to catch invalid type");
-    check_error("Expected integer, got string", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected integer, got string", "<validation>", 1, 1, 1);

    if(!json_unpack_ex(j, &error, 0, "f"))
        fail("json_unpack failed to catch invalid type");
-    check_error("Expected real, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected real, got integer", "<validation>", 1, 1, 1);

    if(!json_unpack_ex(j2, &error, 0, "F"))
        fail("json_unpack failed to catch invalid type");
-    check_error("Expected real or integer, got string", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected real or integer, got string", "<validation>", 1, 1, 1);

    if(!json_unpack_ex(j, &error, 0, "[i]"))
        fail("json_unpack failed to catch invalid type");
-    check_error("Expected array, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected array, got integer", "<validation>", 1, 1, 1);

    if(!json_unpack_ex(j, &error, 0, "{si}", "foo"))
        fail("json_unpack failed to catch invalid type");
-    check_error("Expected object, got integer", "<validation>", 1, 1, 1);
+    check_error(json_error_wrong_type, "Expected object, got integer", "<validation>", 1, 1, 1);

    json_decref(j);
    json_decref(j2);
@@ -251,21 +251,21 @@ static void run_tests()
    j = json_pack("[i]", 1);
    if(!json_unpack_ex(j, &error, 0, "[ii]", &i1, &i2))
        fail("json_unpack failed to catch index out of array bounds");
-    check_error("Array index 1 out of range", "<validation>", 1, 3, 3);
+    check_error(json_error_index_out_of_range, "Array index 1 out of range", "<validation>", 1, 3, 3);
    json_decref(j);

    /* NULL object key */
    j = json_pack("{si}", "foo", 42);
    if(!json_unpack_ex(j, &error, 0, "{si}", NULL, &i1))
        fail("json_unpack failed to catch null string pointer");
-    check_error("NULL object key", "<args>", 1, 2, 2);
+    check_error(json_error_null_value, "NULL object key", "<args>", 1, 2, 2);
    json_decref(j);

    /* Object key not found */
    j = json_pack("{si}", "foo", 42);
    if(!json_unpack_ex(j, &error, 0, "{si}", "baz", &i1))
        fail("json_unpack failed to catch null string pointer");
-    check_error("Object item not found: baz", "<validation>", 1, 3, 3);
+    check_error(json_error_item_not_found, "Object item not found: baz", "<validation>", 1, 3, 3);
    json_decref(j);

    /*
@@ -281,14 +281,14 @@ static void run_tests()
    j = json_pack("[iii]", 1, 2, 3);
    if(!json_unpack_ex(j, &error, 0, "[ii!]", &i1, &i2))
        fail("json_unpack array with strict validation failed");
-    check_error("1 array item(s) left unpacked", "<validation>", 1, 5, 5);
+    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", "<validation>", 1, 5, 5);
    json_decref(j);

    /* Like above, but with JSON_STRICT instead of '!' format */
    j = json_pack("[iii]", 1, 2, 3);
    if(!json_unpack_ex(j, &error, JSON_STRICT, "[ii]", &i1, &i2))
        fail("json_unpack array with strict validation failed");
-    check_error("1 array item(s) left unpacked", "<validation>", 1, 4, 4);
+    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", "<validation>", 1, 4, 4);
    json_decref(j);

    j = json_pack("{s:s, s:i}", "foo", "bar", "baz", 42);
@@ -306,7 +306,7 @@ static void run_tests()
            "2 object item(s) left unpacked: baz, quux",
            "2 object item(s) left unpacked: quux, baz"
        };
-        check_errors(possible_errors, 2, "<validation>", 1, 10, 10);
+        check_errors(json_error_end_of_input_expected, possible_errors, 2, "<validation>", 1, 10, 10);
    }
    json_decref(j);

@@ -320,35 +320,35 @@ static void run_tests()
    j = json_pack("[ii]", 1, 2);
    if(!json_unpack_ex(j, &error, 0, "[i!i]", &i1, &i2))
        fail("json_unpack failed to catch ! in the middle of an array");
-    check_error("Expected ']' after '!', got 'i'", "<format>", 1, 4, 4);
+    check_error(json_error_invalid_format, "Expected ']' after '!', got 'i'", "<format>", 1, 4, 4);

    if(!json_unpack_ex(j, &error, 0, "[i*i]", &i1, &i2))
        fail("json_unpack failed to catch * in the middle of an array");
-    check_error("Expected ']' after '*', got 'i'", "<format>", 1, 4, 4);
+    check_error(json_error_invalid_format, "Expected ']' after '*', got 'i'", "<format>", 1, 4, 4);
    json_decref(j);

    j = json_pack("{sssi}", "foo", "bar", "baz", 42);
    if(!json_unpack_ex(j, &error, 0, "{ss!si}", "foo", &s, "baz", &i1))
        fail("json_unpack failed to catch ! in the middle of an object");
-    check_error("Expected '}' after '!', got 's'", "<format>", 1, 5, 5);
+    check_error(json_error_invalid_format, "Expected '}' after '!', got 's'", "<format>", 1, 5, 5);

    if(!json_unpack_ex(j, &error, 0, "{ss*si}", "foo", &s, "baz", &i1))
        fail("json_unpack failed to catch ! in the middle of an object");
-    check_error("Expected '}' after '*', got 's'", "<format>", 1, 5, 5);
+    check_error(json_error_invalid_format, "Expected '}' after '*', got 's'", "<format>", 1, 5, 5);
    json_decref(j);

    /* Error in nested object */
    j = json_pack("{s{snsn}}", "foo", "bar", "baz");
    if(!json_unpack_ex(j, &error, 0, "{s{sn!}}", "foo", "bar"))
        fail("json_unpack nested object with strict validation failed");
-    check_error("1 object item(s) left unpacked: baz", "<validation>", 1, 7, 7);
+    check_error(json_error_end_of_input_expected, "1 object item(s) left unpacked: baz", "<validation>", 1, 7, 7);
    json_decref(j);

    /* Error in nested array */
    j = json_pack("[[ii]]", 1, 2);
    if(!json_unpack_ex(j, &error, 0, "[[i!]]", &i1))
        fail("json_unpack nested array with strict validation failed");
-    check_error("1 array item(s) left unpacked", "<validation>", 1, 5, 5);
+    check_error(json_error_end_of_input_expected, "1 array item(s) left unpacked", "<validation>", 1, 5, 5);
    json_decref(j);

    /* Optional values */
@@ -401,6 +401,6 @@ static void run_tests()
    i1 = i2 = i3 = 0;
    if(!json_unpack_ex(j, &error, 0, "{sis?i!}", "foo", &i1, "bar", &i2))
        fail("json_unpack failed for optional values with strict mode and compensation");
-    check_error("1 object item(s) left unpacked: baz", "<validation>", 1, 8, 8);
+    check_error(json_error_end_of_input_expected, "1 object item(s) left unpacked: baz", "<validation>", 1, 8, 8);
    json_decref(j);
 }
--- a/test/suites/api/util.h
+++ b/test/suites/api/util.h
@@ -30,9 +30,16 @@
    } while(0)

 /* Assumes json_error_t error */
-#define check_errors(texts_, num_, source_, line_, column_, position_)  \
+#define check_errors(code_, texts_, num_, source_,                      \
+    line_, column_, position_)                                          \
    do {                                                                \
        int i_, found_ = 0;                                             \
+        if(json_error_code(&error) != code_) {                          \
+            failhdr;                                                    \
+            fprintf(stderr, "code: %d != %d\n",                         \
+                    json_error_code(&error), code_);                    \
+            exit(1);                                                    \
+        }                                                               \
        for(i_ = 0; i_ < num_; i_++) {                                  \
            if(strcmp(error.text, texts_[i_]) == 0) {                   \
                found_ = 1;                                             \
@@ -73,8 +80,8 @@


 /* Assumes json_error_t error */
-#define check_error(text_, source_, line_, column_, position_)          \
-    check_errors(&text_, 1, source_, line_, column_, position_)
+#define check_error(code_, text_, source_, line_, column_, position_)   \
+    check_errors(code_, &text_, 1, source_, line_, column_, position_)


 static void run_tests();
Author	SHA1	Message	Date
Petri Lehtinen	71c4e8ec21	Merge pull request #448 from coreyfarrell/2.12 jansson 2.12	2018-11-26 09:10:04 +01:00
Corey Farrell	10afd33efb	jansson 2.12	2018-11-25 03:40:56 -05:00
Corey Farrell	2a31c4f475	Merge pull request #447 from vsoch/update/install-readme Update/install readme	2018-11-25 02:40:09 -05:00
vsoch	f44c137a84	extra comma!	2018-11-24 23:29:14 -08:00
vsoch	7197810714	small updates to README	2018-11-24 23:27:23 -08:00
Corey Farrell	4ba5c7cc5d	Merge pull request #445 from coreyfarrell/fix-444 Remove inappropriate jsonp_free which caused segmentation fault.	2018-11-08 16:00:32 -05:00
Corey Farrell	e262ea5fcd	Remove inappropriate jsonp_free which caused segmentation fault. pack_string should never free str on error. This wouldn't be a problem except the check for `ours` was inverted. Just remove the check for ours since the true condition is unreachable. json_vpack_ex also had an error check for s.has_error. This can never be true unless value is NULL. Expand pack_unpack testing to cover empty format string, NULL object value with non-null concatenated key, array containing a non-null object after a NULL (error) string. Fixes #444	2018-11-05 16:49:22 -05:00
Corey Farrell	6ac0eefed0	Merge pull request #436 from edgale/warnings removed various warnings	2018-10-17 06:29:47 -04:00
Maximilian Röhrle	226b34d546	fixed extra bracket	2018-10-15 07:05:02 +02:00
Maximilian Röhrle	d115953347	removed explicit casts	2018-10-15 06:58:19 +02:00
Corey Farrell	15f77c8f47	Merge pull request #439 from coreyfarrell/codecoverage Fix code coverage ignored paths.	2018-09-29 15:37:56 -04:00
Corey Farrell	ef080d17b5	Fix code coverage ignored paths. * Replace 'tests/' with '/test/'. Replace '/usr/' with '/usr/include/'. This resolves an issue where it was impossible to test code coverage with the source in /usr/src. * Ignore build/include/jansson.h as we just want src/jansson.h.	2018-09-29 14:36:54 -04:00
Corey Farrell	4f91b1d072	Merge pull request #438 from coreyfarrell/issue-437 json_pack: Improve handling of formats with '?' and '*'.	2018-09-28 14:47:33 -04:00
Corey Farrell	8d659113d5	More work on json_pack error reporting. * Remove errant line-feed from pack_object error message. * Correct error message in pack_object_inter. * Create pack_integer / pack_real to get the correct error messages on failure when packing numeric values. * Add tests for packing NAN and infinity directly, in an array and as an object value.	2018-09-25 18:03:06 -04:00
Corey Farrell	5df5fc5b13	json_pack: Improve handling of formats with '?' and ''. When NULL is received for an optional argument we should not set an error message as this would block later error messages. If NULL is received for a non-optional string we should set has_error. Set has_error for UTF-8 errors to ensure optional strings with UTF-8 errors are not replaced with json_null(). Use 'purpose' argument in NULL error messages of read_string. Add error handling and tests for invalid formats where '+', '#', or '%' is used on an optional string 's?' or 's'. Fix NULL string error messages to use 'purpose'. Refactor skipping of '' token, this is now handled by read_string and pack_object_inter. This allows invalid format strings such as 's#' and 's*+' to produce error messages. Fixes #437	2018-09-25 16:35:19 -04:00
Petri Lehtinen	e65a490c44	Merge pull request #435 from edgale/master unreferenced variable fix	2018-09-04 06:25:45 +03:00
Maximilian Röhrle	fc591913ac	removed various warnings	2018-08-31 09:01:36 +02:00
Maximilian Röhrle	d83d3d9172	This fixes https://github.com/akheron/jansson/issues/434	2018-08-30 14:45:28 +02:00
Petri Lehtinen	020cc26b5c	Rename a varialble that shadows another one Fixes #430	2018-08-12 18:25:51 +03:00
Michal Privoznik	360b1ef5a1	Enable -Bsymbolic-functions linker flag whenever possible It was discovered fairly recently that JSON parsing libraries use common pattern to name their exported symbols (they all use json_ prefix). So eventually it happens that two symbols from two different libraries have the same name. This will lead to cryptic crashes (see [1] and [2]). Linking with -Bsymbolic-functions prevents this. 1: https://gitlab.gnome.org/GNOME/json-glib/issues/33 2: https://groups.google.com/forum/#!topic/jansson-users/7Efx-RI45IU Signed-off-by: Michal Privoznik <mprivozn@redhat.com>	2018-08-09 07:54:26 +03:00
Petri Lehtinen	37147b8a23	Merge pull request #423 from coreyfarrell/gcc-8 Deal with warnings under gcc 8.	2018-08-02 11:26:11 +03:00
Petri Lehtinen	8a00a56ec4	Merge pull request #424 from Crayon2000/patch-1 Update copyright for 2018	2018-07-30 13:42:05 +03:00
Petri Lehtinen	401ece058d	Merge pull request #427 from lxin/va_end Call va_end after va_copy in json_vsprintf	2018-07-30 13:41:39 +03:00
Xin Long	66e4ee795d	Call va_end after va_copy in json_vsprintf As said in man doc: "Each invocation of va_copy() must be matched by a corresponding invocation of va_end() in the same function." va_copy may alloc memory in some system, it's necessay to free it by va_end. Fixes: `efe6c7b3f2` ("Add json_sprintf and json_vsprintf") Signed-off-by: Xin Long <lucien.xin@gmail.com>	2018-07-25 17:44:00 +08:00
Crayon	3e13f514ce	Update copyright for 2018	2018-07-14 16:34:33 -04:00
Corey Farrell	81fe13eeed	Deal with warnings under gcc 8. Recent versions of gcc have introduced compiler warnings for string operations that could be truncated. This caused problems with -Werror. src/error.c used strncpy to write "..." to a string, but skipped writing the NUL terminator. Switch this to use memcpy. src/load.c produced warnings from snprintf writing error strings that could be truncated. Added code to autotools build to detect `-Wno-format-truncation', add it to AM_CFLAGS if supported.	2018-07-14 13:24:55 -04:00
Petri Lehtinen	aed855e692	Avoid invalid memory read in json_pack() Initial patch by @bharjoc-bitdefender Fixes #421	2018-07-09 22:26:35 +03:00
Petri Lehtinen	b59ac57617	Merge pull request #415 from palmerc/master CMake variable to number comparison changed to provide meaningful error	2018-05-22 07:38:17 +03:00
Cameron Lowell Palmer	904f5c28ac	CMake variable to number comparison changed to provide meaningful error message. Explicitly specify STATIC and PIC	2018-05-18 10:35:05 +02:00
Petri Lehtinen	80cea73bf9	Merge pull request #408 from isaachier/cmake CMake improvements, make package relocatable	2018-05-18 08:08:32 +03:00
Petri Lehtinen	e28bcfeac8	Merge pull request #417 from akheron/visual-studio-15 Appveyor & build instructions for Visual Studio 15 2017	2018-05-07 14:22:03 +03:00
Petri Lehtinen	fda9288b5f	Update build instructions for Visual Studio	2018-05-07 11:17:08 +03:00
Petri Lehtinen	9ff08f6312	Also build with VS 2017 in appveyor	2018-05-07 08:39:49 +03:00
Petri Lehtinen	dd4743a51d	Merge pull request #412 from Mephistophiles/fix_defines Fix JSON_HAVE_SYNC_BUILTINS define usage	2018-05-07 08:13:21 +03:00
Maxim Zhukov	50f29f9b1a	Add JSON_HAVE_SYNC_BUILTINS and JSON_HAVE_ATOMIC_BUILTINS for autoheader Added JSON_HAVE_SYNC_BUILTINS and JSON_HAVE_ATOMIC_BUILTINS defines to jansson_config.h.cmake as well as in the autoheader for autoconf.	2018-03-22 17:46:29 +03:00
Petri Lehtinen	e5dbe7bb64	Merge pull request #409 from Mephistophiles/master Fix error handling in json_pack	2018-03-22 10:40:41 +02:00
Maxim Zhukov	15105b66b4	Fix error handling in json_pack Fixed a bug where the error message was not filled if an empty object was passed to the json_pack. Fixes #271	2018-03-22 11:16:40 +03:00
Petri Lehtinen	b23025d72b	Merge pull request #404 from coreyfarrell/func-attrs Build: Add JANSSON_ATTRS macro.	2018-03-20 04:55:48 +02:00
Isaac Hier	2c98c30a02	Stop using absolute paths	2018-03-11 10:54:24 -04:00
Isaac Hier	bb71db204f	Fix output file name for version config	2018-03-11 10:54:14 -04:00
Isaac Hier	92760bb363	Remove warning	2018-03-11 10:54:02 -04:00
Isaac Hier	fe7873e963	Fix package version config generation	2018-03-11 10:37:15 -04:00
Isaac Hier	a586c0654f	Fix CMake include	2018-03-11 10:27:48 -04:00
Isaac Hier	6d7a02beb0	Clean up CMake install	2018-03-11 10:24:27 -04:00
Isaac Hier	b70364b362	Remove absolute path references	2018-03-11 10:11:09 -04:00
Isaac Hier	6d1ae86e1c	Fix config file	2018-03-11 09:59:52 -04:00
Isaac Hier	a324d18940	Rename target file	2018-03-11 09:53:06 -04:00
Isaac Hier	44f6606df8	Rename config files	2018-03-11 09:47:29 -04:00
Isaac Hier	d8798468c6	Upgrade CMake to 3.1 for Hunter	2018-03-11 09:34:45 -04:00
Corey Farrell	749bef0b6a	More test coverage. * Add test_load_callback to CMakeList.txt * Add json_dump, json_load and json_unpack chaos testing.	2018-03-06 23:28:14 -05:00
Corey Farrell	e37e52549f	Add warn_unused_result to strbuffer_init. This adds a compiler warning when strbuffer_init return value is ignored. unpack_object is updated to deal with errors produced while building unrecognized_keys.	2018-03-06 08:27:20 -05:00
Corey Farrell	ea664722d4	Build: Add JANSSON_ATTRS macro. This macro is used to conditionally generate GCC/CLANG __attribute__ declarations if supported. This allows the compiler to produce warnings on certain incorrect usages. json_sprintf and json_vsprintf will produce warnings on invalid format string. Many functions will produce a warning if the result is unused. Specifically functions which allocate new objects will warn if the result is ignored as this always results in a memory leak.	2018-03-06 07:25:16 -05:00
Petri Lehtinen	d098c0ff86	Merge pull request #400 from coreyfarrell/branch-coverage Enable branch coverage reporting.	2018-02-20 15:39:36 +02:00
Petri Lehtinen	2d494c169f	Merge pull request #398 from coreyfarrell/test-coverage Improve test coverage.	2018-02-20 15:39:19 +02:00
Corey Farrell	a5af280bac	Enable branch coverage reporting.	2018-02-20 03:09:03 -05:00
Corey Farrell	73c22de516	Improve test coverage. * Test equality of different length strings. * Add tab to json_pack whitespace test. * Test json_sprintf with empty result and invalid UTF. * Test json_get_alloc_funcs with NULL arguments. * Test invalid arguments. * Add test_chaos to test allocation failure code paths. * Remove redundant json_is_string checks from json_string_equal and json_string_copy. Both functions are static and can only be called with a json string. Fixes to issues found by test_chaos: * Fix crash on OOM in pack_unpack.c:read_string(). * Unconditionally free string in string_create upon allocation failure. Update load.c:parse_value() to reflect this. This resolves a leak on allocation failure for pack_unpack.c:pack_string() and value.c:json_sprintf(). Although not visible from CodeCoverage these changes significantly increase branch coverage. Especially in src/value.c where we previously covered 67.4% of branches and now cover 96.3% of branches.	2018-02-15 10:12:31 -05:00
Petri Lehtinen	6dddf687d8	Merge pull request #396 from coreyfarrell/2.11 jansson 2.11	2018-02-11 20:11:41 +02:00
Corey Farrell	744fe5ed44	jansson 2.11	2018-02-09 12:31:18 -05:00
Petri Lehtinen	03620980cf	Merge pull request #395 from akheron/doc-utf-8 Document encoding requirements for callbacks	2018-02-09 10:10:34 +02:00
Petri Lehtinen	248d62111c	Merge pull request #368 from AmeyaVS/cmake_build_fix Fix generated `pkg-config` file using cmake.	2018-02-09 09:45:36 +02:00
Petri Lehtinen	46dff2737d	Merge pull request #381 from phst/end-of-file-error-code Use a more specific error code for premature end of input	2018-02-09 09:40:42 +02:00
Petri Lehtinen	fa0b5ece9e	Merge pull request #380 from phst/doc-error-code document that json_error_code will be added in version 2.11	2018-02-09 09:39:38 +02:00
Petri Lehtinen	a6138a07b6	Document encoding requirements for callbacks Original patch by @phst. Fixes #369.	2018-02-09 09:35:53 +02:00
Petri Lehtinen	2863dde053	Merge pull request #393 from akheron/json_sprintf Add json_sprintf and json_vsprintf	2018-02-09 08:15:16 +02:00
Petri Lehtinen	efe6c7b3f2	Add json_sprintf and json_vsprintf Fixes #392	2018-02-09 07:37:33 +02:00
Petri Lehtinen	3e81f78366	Merge pull request #389 from coreyfarrell/threadsafety Atomic references and thread safe json_dump	2018-02-08 20:19:07 +02:00
Corey Farrell	8104ce167a	Merge pull request #1 from akheron/threadsafety Clarify thread safety docs, rename JANSSON_THREAD_SAFE	2018-02-08 11:58:30 -05:00
Petri Lehtinen	f44921e176	Clarify thread safety docs, rename JANSSON_THREAD_SAFE	2018-02-08 12:38:14 +02:00
Corey Farrell	3aee856d7b	Docs: Update information on thread safety. Fixes #387	2018-02-01 15:54:35 -05:00
Corey Farrell	37e0ee4d48	json_dump: Fix thread safety issue. Circular reference detection in json_dump was not thread safe. Replace visited flag with a hashtable_t. Issue #387	2018-02-01 15:54:25 -05:00
Corey Farrell	dc3b313e91	Use thread-safe reference counting if supported by the compiler. This makes use of __atomic or __sync builtin compiler functions to make json_decref and json_incref thread-safe. Issue #387	2018-01-29 14:17:58 -05:00
Philipp Stephani	45228cada4	Use a more specific error code for premature end of input	2017-12-20 18:27:04 +01:00
Philipp Stephani	24d45272a7	document that json_error_code will be added in version 2.11	2017-12-18 23:51:32 +01:00
Petri Lehtinen	9e5af7c3b7	Merge pull request #374 from coreyfarrell/always-steal json_pack: Enable more complete stealing of references.	2017-12-16 20:35:14 +02:00
Corey Farrell	6c78910011	apiref: Clarify documentation for unpack `O` format. The `O` format causes reference counts to increase, but in an error they are not released. Callers to unpack functions that use the `O` format should use pointers pre-initialized to NULL so they can safely release the reference on error. Also corrected typo which said this was like `O` (itself). Fixes #135	2017-12-13 14:04:07 -05:00
Corey Farrell	89dad8959b	json_object_iter_set_new: Fix error branch leak. This function needs to release a reference to value if the other arguments are invalid. Issue #135	2017-12-13 14:04:07 -05:00
Corey Farrell	9a1d9c88fc	json_pack: Enable more complete stealing of references. Users of the "o" format have an expectation that the object reference will be stolen. Any error causes the collection process to end early. This patch causes json_pack and related functions to continue scanning the format and parameters so all references can be stolen to prevent leaks. This makes no attempt to continue processing if the format string is broken or missing. 'make check' still passes. Ran test_pack under valgrind and verified that the leaked reference is fixed. Added a test which uses refcounts to verify that the reference was correctly stolen after a NULL value error. Issue #135	2017-12-13 14:03:58 -05:00
Petri Lehtinen	02dade46c0	Merge pull request #375 from phniix/373_upstream_typo_in_cmakelists Fixes akheron/jansson#373	2017-12-13 07:08:25 +02:00
Petri Lehtinen	bc5c6826ef	Merge pull request #377 from coreyfarrell/extra-refs Remove extra reference actions in parsers.	2017-12-13 07:07:33 +02:00
Petri Lehtinen	217859f849	Merge pull request #378 from phst/doc Document that length-aware string functions have been added in 2.7	2017-12-13 07:05:15 +02:00
Philipp Stephani	3951d39b40	Document that length-aware string functions have been added in 2.7	2017-12-10 16:53:01 +01:00
Corey Farrell	bd91753e91	Remove extra reference actions in parsers. Make parse_object use json_object_set_new_nocheck and make parse_array use json_array_append_new, remove json_decref from error and success paths. Fixes #376	2017-11-14 23:52:49 -05:00
Joe Hura	0b04762c94	Fixes akheron/jansson#373 'sys/time.h' is a typo, it should read: 'sys/types.h'	2017-11-07 19:32:14 +11:00
Petri Lehtinen	009ffa3fc8	Fix a compile error on macOS clang Reported by Diederick Huijbers	2017-11-07 10:20:21 +02:00
Ameya Vikram Singh	89f0dde7ff	Fix generated `pkg-config` file using cmake. Fixed the generated `jansson.pc` with cmake to be consistent with the one generated using GNU Autotools.	2017-10-29 23:57:25 +05:30
Petri Lehtinen	9e7847ed26	Merge pull request #365 from phst/bug352 Use last byte of error text as numeric error code	2017-10-09 08:07:42 +03:00
Philipp Stephani	112ccbd820	Use last byte of error text as numeric error code Fixes #352	2017-10-03 11:42:07 +02:00
Petri Lehtinen	271ffda903	Make json_equal() const-correct Fixes #344	2017-08-19 21:10:17 +03:00
Petri Lehtinen	3e5405c39e	Work around gcc's -Wimplicit-fallthrough	2017-08-19 21:09:32 +03:00
Petri Lehtinen	93e8cd7d68	Merge pull request #359 from sanjay24/master json_dump_file API returns success even when fclose fails	2017-08-06 07:14:18 +03:00
Sanjay Kumar	0abcbce3bb	json_dump_file API returns success even when fclose fails (consider disk full case). API should check the return value of fclose before returning success to its caller. fwrite may not write anything into the file, it simply returns the number of bytes written into the buffer. When disk is full and fclose is called, it results in truncation of the file (resulting in zero sized file). Since, API is returning success, its caller can't take any remedial action on its failure.	2017-08-05 23:52:49 +05:30
Petri Lehtinen	4947f9a193	Merge pull request #356 from hellojaewon/master Docs - Fix typo	2017-07-20 22:42:29 +03:00
최재원	ad6c1e37ad	Fix typo	2017-07-16 19:16:34 +09:00
Petri Lehtinen	f52c3da717	Merge pull request #339 from npmccallum/optpack Enable optional object members in json_pack()	2017-04-19 16:17:28 +03:00
Nathaniel McCallum	28666cead0	Enable optional object/array members in json_pack()	2017-04-19 07:19:29 -04:00
Petri Lehtinen	74028ff958	Merge commit '1b8bebf0bf8f1c0c3d92faf67a830bf8448897ed'	2017-04-13 13:46:35 +03:00
Petri Lehtinen	fbf720f2c5	Allow forward declaring json_error_t values	2017-04-13 13:39:43 +03:00
Mathieu Lirzin	1b8bebf0bf	build: Use Autoconf macro @includedir@ for jansson.pc. This is more consistent with what is done for other pkg-config variables.	2017-04-12 22:36:58 +02:00
Petri Lehtinen	f7a70de84a	Merge pull request #336 from akheron/issue-333 CMakeLists.txt: Remove extra parenthesis	2017-03-29 07:31:26 +03:00
Petri Lehtinen	17f77cf2c6	CMakeLists.txt: Remove extra parenthesis Fixes #333	2017-03-29 07:08:19 +03:00