pax_global_header00006660000000000000000000000064144657533000014521gustar00rootroot0000000000000052 comment=b4c371fa0cbc4dcbaccc359ce9e957a22988fb34 json-c-json-c-0.17-20230812/000077500000000000000000000000001446575330000147275ustar00rootroot00000000000000json-c-json-c-0.17-20230812/.clang-format000066400000000000000000000033211446575330000173010ustar00rootroot00000000000000BasedOnStyle: LLVM # If true, clang-format will attempt to re-flow comments ReflowComments: false # The column limit. ColumnLimit: 100 # Indent width for line continuations. ContinuationIndentWidth: 4 # The number of columns to use for indentation. IndentWidth: 8 # The number of columns used for tab stops. TabWidth: 8 UseTab: ForIndentation # Options for aligning backslashes in escaped newlines. AlignEscapedNewlines: Left # Short Block Style AllowShortBlocksOnASingleLine: true # If true, short case labels will be contracted to a single line. AllowShortCaseLabelsOnASingleLine: true # Dependent on the value, int f() { return 0; } can be put on a single line. AllowShortFunctionsOnASingleLine: Empty # The brace breaking style to use. BreakBeforeBraces: Custom # Control of individual brace wrapping cases. BraceWrapping: # Wrap brackets inside of a case AfterCaseLabel: true # Wrap class definition. AfterClass: true # Wrap control statements AfterControlStatement: true # Wrap enum definitions. AfterEnum: true # Wrap function definitions. AfterFunction: true # Wrap namespace definitions. AfterNamespace: true # Wrap struct definitions. AfterStruct: true # Wrap union definitions. AfterUnion: true # Wrap extern blocks. AfterExternBlock: false # Wrap before catch. BeforeCatch: true # Wrap before else. BeforeElse: true # Indent the wrapped braces themselves. IndentBraces: false # If false, empty function body can be put on a single line. SplitEmptyFunction: false # If false, empty record (e.g. class, struct or union) body can be put on a single line. SplitEmptyRecord: false # If false, empty namespace body can be put on a single line. SplitEmptyNamespace: false json-c-json-c-0.17-20230812/.editorconfig000066400000000000000000000004051446575330000174030ustar00rootroot00000000000000# EditorConfig # https://EditorConfig.org # top-most EditorConfig file root = true # LF end-of-line, insert an empty new line and UTF-8 [*] end_of_line = lf insert_final_newline = true charset = utf-8 # Tab indentation [makefile,Makefile] indent_style = tab json-c-json-c-0.17-20230812/.github/000077500000000000000000000000001446575330000162675ustar00rootroot00000000000000json-c-json-c-0.17-20230812/.github/ISSUE_TEMPLATE/000077500000000000000000000000001446575330000204525ustar00rootroot00000000000000json-c-json-c-0.17-20230812/.github/ISSUE_TEMPLATE/bug_report.md000066400000000000000000000012751446575330000231510ustar00rootroot00000000000000--- name: Bug report about: Create a report to help us improve title: '' labels: '' assignees: '' --- Note: for general questions and comments, please use the forums at: https://groups.google.com/g/json-c **Describe the bug** A clear and concise description of what the bug is, and any information about where you're running into the bug that you feel might be relevant. **Steps To Reproduce** List the steps to reproduce the behavior. If possible, please attach a sample json file and/or a minimal code example. **Version and Platform** - json-c version: [e.g. json-c-0.14, or a specific commit hash] - OS: [e.g. Ubuntu 20.04, Debian Buster, NetBSD 9, etc...] - Custom cmake/build flags, if any json-c-json-c-0.17-20230812/.gitignore000066400000000000000000000023551446575330000167240ustar00rootroot00000000000000# Temp files *~ *.swp *.bak *.backup \#* .\#* *\# *.sav *.save *.autosav *.autosave # Tests /tests/Makefile /tests/test1 /tests/test1Formatted /tests/test2 /tests/test2Formatted /tests/test4 /tests/testReplaceExisting /tests/testSubDir /tests/test_cast /tests/test_charcase /tests/test_compare /tests/test_deep_copy /tests/test_double_serializer /tests/test_float /tests/test_int_add /tests/test_int_get /tests/test_json_pointer /tests/test_locale /tests/test_null /tests/test_parse /tests/test_parse_int64 /tests/test_printbuf /tests/test_set_serializer /tests/test_set_value /tests/test_util_file /tests/test_visit /tests/*.vg.out /tests/*.log /tests/*.trs # Generated folders /build /Debug /Release /*/Debug /*/Release # Archives *.zip *.tar.* *.tgz *.gz *.bz2 *.xz *.lz *.lzma *.7z *.dll *.deb *.rpm *.apk *.exe *.msi *.dmg *.ipa # It's not good practice to build directly in the source tree # but ignore cmake auto-generated files anyway: /json_config.h /json.h /config.h /json-c.pc /Makefile /CMakeCache.txt /CMakeFiles /CMakeDoxyfile.in /*.cmake /DartConfiguration.tcl /tests/CMakeFiles/ /tests/*.cmake /Testing/ # ...and build artifacts. /doc/html /libjson-c.a /libjson-c.so /libjson-c.so.* # Benchmarking input and output /bench/data /bench/work json-c-json-c-0.17-20230812/.travis.yml000066400000000000000000000066751446575330000170560ustar00rootroot00000000000000language: cpp matrix: include: # ubuntu xenial 16.04 # gcc 5 is the default on xenial - os: linux dist: xenial compiler: gcc addons: apt: packages: - valgrind - cppcheck - doxygen - cmake env: CHECK="true" # ubuntu bionic 18.04 # gcc 7 is the default on bionic - os: linux dist: bionic compiler: gcc addons: apt: packages: - valgrind - cppcheck - doxygen - cmake env: CHECK="true" # ubuntu focal fossa 20.04 # gcc 9 is the default on bionic - os: linux dist: focal compiler: gcc addons: apt: packages: - valgrind - cppcheck - doxygen - cmake env: CHECK="true" # clang # xenial - os: linux dist: xenial compiler: clang addons: apt: sources: - llvm-toolchain-xenial-6.0 packages: - clang-6.0 - cmake env: MATRIX_EVAL="CC=clang-6.0 && CXX=clang++-6.0" # clang-7 is the default on focal, xenial and bionic - os: linux dist: focal compiler: clang addons: apt: packages: - valgrind - cppcheck - doxygen - cmake env: CHECK="true" # osx - os: osx osx_image: xcode13.4 env: XCODE="true" CHECK="true" # run coveralls - os: linux dist: xenial compiler: gcc addons: apt: packages: - lcov env: CHECK="true" before_install: - sudo gem install coveralls-lcov - echo $CC - echo $LANG - echo $LC_ALL - set -e - if [ "$TRAVIS_OS_NAME" = "linux" ]; then eval "${MATRIX_EVAL}"; if [ -n "$MATRIX_EVAL" ] && [ "$TRAVIS_COMPILER" != "clang" ]; then sudo apt-get install -y $CC; fi; fi before_script: - export CFLAGS="-fprofile-arcs -ftest-coverage" - mkdir build && cd build && cmake .. script: - make - make test after_success: - cd .. - lcov -d build/ -b . -c -o build/all_coverage.info - lcov -r build/all_coverage.info '/usr/*' '*CMakeFiles*' '*fuzz*' '*test*' -o build/coverage.info - coveralls-lcov --verbose build/coverage.info # allow_failures: # - os: osx before_install: - echo $CC - echo $LANG - echo $LC_ALL - set -e - if [ "$TRAVIS_OS_NAME" = "linux" ]; then eval "${MATRIX_EVAL}"; if [ -n "$MATRIX_EVAL" ] && [ "$TRAVIS_COMPILER" != "clang" ]; then sudo apt-get install -y $CC; fi; fi before_script: # XXX osx on travis doesn't work w/ set -e, so turn it off :( - set +e - mkdir -p build || echo "Failed to mkdir build" - cd build || echo "Failed to cd build" - cmake .. || echo "Failed to run cmake" script: - make # when using bionic, Travis seems to ignore the "addons" section, so installing the packages with apt-get... - if [ -n "$CHECK" ]; then if [ "$TRAVIS_OS_NAME" = "osx" ]; then brew install doxygen; else if [ "$TRAVIS_DIST" = "bionic" ]; then sudo apt-get install -y valgrind cppcheck doxygen; fi; fi; make distcheck; if type cppcheck &> /dev/null ; then cppcheck --error-exitcode=1 --quiet *.h *.c tests/ ; fi; fi json-c-json-c-0.17-20230812/AUTHORS000066400000000000000000000052251446575330000160030ustar00rootroot00000000000000Alan Coopersmith Alexander Dahl Alexandru Ardelean An7ar35 andy5995 Aram Poghosyan Björn Esser BonsaY changyong guo chenguoping Chris Lamb Christopher Head Chris Wolfe C. Watford (christopher.watford@gmail.com) Daniel Danzberger Darjan Krijan David McCann DeX77 Dimitri Papadopoulos <3234522+DimitriPapadopoulos@users.noreply.github.com> dota17 Eric Haszlakiewicz Eric Hawicz Even Rouault Federico Francescon Gianluigi Tiesi grdowns Hex052 hofnarr ihsinme <61293369+ihsinme@users.noreply.github.com> Ivan Romanov Jaap Keuter Jakov Smolic janczer JC (Jonathan Chen) Jehan Jehiah Czebotar Jonathan Wiens Jose Bollo José Bollo Juuso Alasuutari Keith Holman Khem Raj Kizuna-Meraki Leon Gross Liang, Gao Luca Mannella Marc <34656315+MarcT512@users.noreply.github.com> Matthias Gatto max Micah Snyder Michael Clark myd7349 Pascal Cuoq Pawday Philosoph228 Pierce Lopez Po-Chuan Hsieh Ramiro Polla Rikard Falkeborn Robert Bielik Robert Rosen Penev Rubasri Kalidas Sergey Sharshunov Simon McVittie ssrlive <30760636+ssrlive@users.noreply.github.com> Tobias Nießen Tobias Stoeckmann Tudor Brindus Unmanned Player <36690541+unmanned-player@users.noreply.github.com> Yurii Rashkovskii json-c-json-c-0.17-20230812/Android.configure.mk000066400000000000000000000027151446575330000206250ustar00rootroot00000000000000# This file is the top android makefile for all sub-modules. # # Suggested settings to build for Android: # # export PATH=$PATH:/opt/android-ndk/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/bin/ # export SYSROOT=/opt/android-ndk/platforms/android-9/arch-arm/usr/ # export LD=arm-linux-androideabi-ld # export CC="arm-linux-androideabi-gcc --sysroot=/opt/android-ndk/platforms/android-9/arch-arm" # # Then run autogen.sh, configure and make. # LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) json_c_TOP := $(LOCAL_PATH) JSON_C_BUILT_SOURCES := Android.mk JSON_C_BUILT_SOURCES := $(patsubst %, $(abspath $(json_c_TOP))/%, $(JSON_C_BUILT_SOURCES)) .PHONY: json-c-configure json-c-configure-real json-c-configure-real: echo $(JSON_C_BUILT_SOURCES) cd $(json_c_TOP) ; \ $(abspath $(json_c_TOP))/autogen.sh && \ CC="$(CONFIGURE_CC)" \ CFLAGS="$(CONFIGURE_CFLAGS)" \ LD=$(TARGET_LD) \ LDFLAGS="$(CONFIGURE_LDFLAGS)" \ CPP=$(CONFIGURE_CPP) \ CPPFLAGS="$(CONFIGURE_CPPFLAGS)" \ PKG_CONFIG_LIBDIR=$(CONFIGURE_PKG_CONFIG_LIBDIR) \ PKG_CONFIG_TOP_BUILD_DIR=/ \ ac_cv_func_malloc_0_nonnull=yes \ ac_cv_func_realloc_0_nonnull=yes \ $(abspath $(json_c_TOP))/$(CONFIGURE) --host=$(CONFIGURE_HOST) \ --prefix=/system \ && \ for file in $(JSON_C_BUILT_SOURCES); do \ rm -f $$file && \ make -C $$(dirname $$file) $$(basename $$file) ; \ done json-c-configure: json-c-configure-real PA_CONFIGURE_TARGETS += json-c-configure -include $(json_c_TOP)/Android.mk json-c-json-c-0.17-20230812/CMakeLists.txt000066400000000000000000000520651446575330000174770ustar00rootroot00000000000000# CMake 3.9 was released in 2017/07 # As of 2023, many versions of Linux, NetBSD and FreeBSD provide, # and many OpenWRT packages require, much newer CMake packages. # We're stopping before 3.10 because that version starts requiring # c++11, which isn't available on e.g HPUX. cmake_minimum_required(VERSION 3.9) # The project() command manages VERSION variables. cmake_policy(SET CMP0048 NEW) # JSON-C library is C only project. # PROJECT_VERSION{,_MAJOR,_MINOR,_PATCH} set by project(): project(json-c LANGUAGES C VERSION 0.17) # Targets may not link directly to themselves. cmake_policy(SET CMP0038 NEW) # MACOSX_RPATH is enabled by default. # We set it explicitly to avoid the warning cmake_policy(SET CMP0042 NEW) # Only interpret if() arguments as variables or keywords when unquoted. cmake_policy(SET CMP0054 NEW) # set default build type if not specified by user if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE debug) endif() set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O2") # Include file check macros honor CMAKE_REQUIRED_LIBRARIES # i.e. the check_include_file() calls will include -lm when checking. # New in version 3.12. if(POLICY CMP0075) cmake_policy(SET CMP0075 NEW) endif() include(CTest) # Set some packaging variables. set(CPACK_PACKAGE_NAME "${PROJECT_NAME}") set(CPACK_PACKAGE_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}") set(CPACK_PACKAGE_VERSION_MINOR "${PROJECT_VERSION_MINOR}") set(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}") set(JSON_C_BUGREPORT "json-c@googlegroups.com") set(CPACK_SOURCE_IGNORE_FILES ${PROJECT_SOURCE_DIR}/build ${PROJECT_SOURCE_DIR}/cmake-build-debug ${PROJECT_SOURCE_DIR}/pack ${PROJECT_SOURCE_DIR}/.idea ${PROJECT_SOURCE_DIR}/.DS_Store ${PROJECT_SOURCE_DIR}/.git ${PROJECT_SOURCE_DIR}/.vscode) include(CheckSymbolExists) include(CheckIncludeFile) include(CheckIncludeFiles) include(CheckCSourceCompiles) include(CheckTypeSize) include(CPack) include(GNUInstallDirs) include(CMakePackageConfigHelpers) option(BUILD_SHARED_LIBS "Default to building shared libraries" ON) option(BUILD_STATIC_LIBS "Default to building static libraries" ON) if (BUILD_SHARED_LIBS) add_definitions(-D JSON_C_DLL) endif() # Generate a release merge and test it to verify the correctness of republishing the package. ADD_CUSTOM_TARGET(distcheck COMMAND make package_source COMMAND tar -xvf "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source.tar.gz" COMMAND mkdir "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/build" COMMAND cmake "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/" -B"./${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/build/" COMMAND make -C "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/build" COMMAND make test -C "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/build" COMMAND rm -rf "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source" ) # Enable or disable features. By default, all features are turned off. option(DISABLE_BSYMBOLIC "Avoid linking with -Bsymbolic-function." OFF) option(DISABLE_THREAD_LOCAL_STORAGE "Disable using Thread-Local Storage (HAVE___THREAD)." OFF) option(DISABLE_WERROR "Avoid treating compiler warnings as fatal errors." OFF) option(ENABLE_RDRAND "Enable RDRAND Hardware RNG Hash Seed." OFF) option(ENABLE_THREADING "Enable partial threading support." OFF) option(OVERRIDE_GET_RANDOM_SEED "Override json_c_get_random_seed() with custom code." OFF) option(DISABLE_EXTRA_LIBS "Avoid linking against extra libraries, such as libbsd." OFF) option(DISABLE_JSON_POINTER "Disable JSON pointer (RFC6901) and JSON patch support." OFF) option(DISABLE_JSON_PATCH "Disable JSON patch (RFC6902) support." OFF) option(NEWLOCALE_NEEDS_FREELOCALE "Work around newlocale bugs in old FreeBSD by calling freelocale" OFF) option(BUILD_APPS "Default to building apps" ON) if (UNIX OR MINGW OR CYGWIN) list(APPEND CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE) endif() if (UNIX) list(APPEND CMAKE_REQUIRED_LIBRARIES m) endif() if (MSVC) list(APPEND CMAKE_REQUIRED_DEFINITIONS /D_CRT_SECURE_NO_DEPRECATE) list(APPEND CMAKE_REQUIRED_FLAGS /wd4996) endif() if (NOT DISABLE_STATIC_FPIC) # Use '-fPIC'/'-fPIE' option. # This will allow other libraries to statically link in libjson-c.a # which in turn prevents crashes in downstream apps that may use # a different JSON library with identical symbol names. set(CMAKE_POSITION_INDEPENDENT_CODE ON) endif() check_include_file("fcntl.h" HAVE_FCNTL_H) check_include_file("inttypes.h" HAVE_INTTYPES_H) check_include_file(stdarg.h HAVE_STDARG_H) check_include_file(strings.h HAVE_STRINGS_H) check_include_file(string.h HAVE_STRING_H) check_include_file(syslog.h HAVE_SYSLOG_H) check_include_files("stdlib.h;stdarg.h;string.h;float.h" STDC_HEADERS) check_include_file(unistd.h HAVE_UNISTD_H) check_include_file(sys/types.h HAVE_SYS_TYPES_H) check_include_file(sys/resource.h HAVE_SYS_RESOURCE_H) # for getrusage check_include_file("dlfcn.h" HAVE_DLFCN_H) check_include_file("endian.h" HAVE_ENDIAN_H) check_include_file("limits.h" HAVE_LIMITS_H) check_include_file("locale.h" HAVE_LOCALE_H) check_include_file("memory.h" HAVE_MEMORY_H) check_include_file(stdint.h HAVE_STDINT_H) check_include_file(stdlib.h HAVE_STDLIB_H) check_include_file(sys/cdefs.h HAVE_SYS_CDEFS_H) check_include_file(sys/param.h HAVE_SYS_PARAM_H) check_include_file(sys/random.h HAVE_SYS_RANDOM_H) check_include_file(sys/stat.h HAVE_SYS_STAT_H) check_include_file(xlocale.h HAVE_XLOCALE_H) # Set json-c specific vars to stamp into json_config.h # in a way that hopefully won't conflict with other # projects that use json-c. if (HAVE_INTTYPES_H) set(JSON_C_HAVE_INTTYPES_H 1) endif() if (HAVE_STDINT_H) set(JSON_C_HAVE_STDINT_H 1) endif() check_symbol_exists(_isnan "float.h" HAVE_DECL__ISNAN) check_symbol_exists(_finite "float.h" HAVE_DECL__FINITE) if ((MSVC AND NOT (MSVC_VERSION LESS 1800)) OR MINGW OR CYGWIN OR UNIX) check_symbol_exists(INFINITY "math.h" HAVE_DECL_INFINITY) check_symbol_exists(isinf "math.h" HAVE_DECL_ISINF) check_symbol_exists(isnan "math.h" HAVE_DECL_ISNAN) check_symbol_exists(nan "math.h" HAVE_DECL_NAN) endif() check_symbol_exists(_doprnt "stdio.h" HAVE_DOPRNT) if (UNIX OR MINGW OR CYGWIN) check_symbol_exists(snprintf "stdio.h" HAVE_SNPRINTF) endif() check_symbol_exists(vasprintf "stdio.h" HAVE_VASPRINTF) check_symbol_exists(vsnprintf "stdio.h" HAVE_VSNPRINTF) check_symbol_exists(vprintf "stdio.h" HAVE_VPRINTF) check_symbol_exists(arc4random "stdlib.h" HAVE_ARC4RANDOM) if (NOT HAVE_ARC4RANDOM AND DISABLE_EXTRA_LIBS STREQUAL "OFF") check_include_file(bsd/stdlib.h HAVE_BSD_STDLIB_H) if (HAVE_BSD_STDLIB_H) list(APPEND CMAKE_REQUIRED_LIBRARIES "bsd") unset(HAVE_ARC4RANDOM CACHE) check_symbol_exists(arc4random "bsd/stdlib.h" HAVE_ARC4RANDOM) if (NOT HAVE_ARC4RANDOM) list(REMOVE_ITEM CMAKE_REQUIRED_LIBRARIES "bsd") endif() endif() endif() if (HAVE_FCNTL_H) check_symbol_exists(open "fcntl.h" HAVE_OPEN) endif() if (HAVE_STDLIB_H) check_symbol_exists(realloc "stdlib.h" HAVE_REALLOC) endif() if (HAVE_LOCALE_H) check_symbol_exists(setlocale "locale.h" HAVE_SETLOCALE) check_symbol_exists(uselocale "locale.h" HAVE_USELOCALE) endif() # uClibc *intentionally* crashes in duplocale(), at least as of: # https://github.com/ffainelli/uClibc/blob/266bdc1/libc/misc/locale/locale.c#L1322 # So, if it looks like we're compiling for a system like that just disable # locale handling entirely. exec_program(${CMAKE_C_COMPILER} ARGS -dumpmachine OUTPUT_VARIABLE CMAKE_GNU_C_MACHINE) if (CMAKE_GNU_C_MACHINE MATCHES "uclibc") message(STATUS "Detected uClibc compiler, disabling locale handling") set(HAVE_SETLOCALE 0) set(HAVE_USELOCALE 0) endif() if (HAVE_STRINGS_H) check_symbol_exists(strcasecmp "strings.h" HAVE_STRCASECMP) check_symbol_exists(strncasecmp "strings.h" HAVE_STRNCASECMP) endif() if (HAVE_STRING_H) check_symbol_exists(strdup "string.h" HAVE_STRDUP) check_symbol_exists(strerror "string.h" HAVE_STRERROR) endif() if (HAVE_SYSLOG_H) check_symbol_exists(vsyslog "syslog.h" HAVE_VSYSLOG) endif() if (HAVE_SYS_RANDOM_H) check_symbol_exists(getrandom "sys/random.h" HAVE_GETRANDOM) endif() if (HAVE_SYS_RESOURCE_H) check_symbol_exists(getrusage "sys/resource.h" HAVE_GETRUSAGE) endif() check_symbol_exists(strtoll "stdlib.h" HAVE_STRTOLL) check_symbol_exists(strtoull "stdlib.h" HAVE_STRTOULL) set(json_c_strtoll "strtoll") if (NOT HAVE_STRTOLL) # Use _strtoi64 if strtoll is not available. check_symbol_exists(_strtoi64 "stdlib.h" __have_strtoi64) if (__have_strtoi64) #set(HAVE_STRTOLL 1) set(json_c_strtoll "_strtoi64") endif() endif() set(json_c_strtoull "strtoull") if (NOT HAVE_STRTOULL) # Use _strtoui64 if strtoull is not available. check_symbol_exists(_strtoui64 "stdlib.h" __have_strtoui64) if (__have_strtoui64) #set(HAVE_STRTOULL 1) set(json_c_strtoull "_strtoui64") endif() endif() check_type_size(int SIZEOF_INT) check_type_size(int64_t SIZEOF_INT64_T) check_type_size(long SIZEOF_LONG) check_type_size("long long" SIZEOF_LONG_LONG) check_type_size("size_t" SIZEOF_SIZE_T) if (MSVC) list(APPEND CMAKE_EXTRA_INCLUDE_FILES BaseTsd.h) check_type_size("SSIZE_T" SIZEOF_SSIZE_T) else() check_type_size("ssize_t" SIZEOF_SSIZE_T) endif() check_c_source_compiles( " extern void json_object_get(); __asm__(\".section .gnu.json_object_get\\n\\t.ascii \\\"Please link against libjson-c instead of libjson\\\"\\n\\t.text\"); int main(int c, char *v) { return 0;} " HAS_GNU_WARNING_LONG) check_c_source_compiles( "int main() { int i, x = 0; i = __sync_add_and_fetch(&x,1); return x; }" HAVE_ATOMIC_BUILTINS) if (NOT DISABLE_THREAD_LOCAL_STORAGE) check_c_source_compiles( "__thread int x = 0; int main() { return 0; }" HAVE___THREAD) if (HAVE___THREAD) set(SPEC___THREAD __thread) elseif (MSVC) set(SPEC___THREAD __declspec(thread)) endif() endif() # Hardware random number is not available on Windows? Says, config.h.win32. Best to preserve compatibility. if (WIN32) set(ENABLE_RDRAND 0) endif() # Once we've done basic symbol/header searches let's add them in. configure_file(${PROJECT_SOURCE_DIR}/cmake/config.h.in ${PROJECT_BINARY_DIR}/config.h) message(STATUS "Wrote ${PROJECT_BINARY_DIR}/config.h") configure_file(${PROJECT_SOURCE_DIR}/cmake/json_config.h.in ${PROJECT_BINARY_DIR}/json_config.h) message(STATUS "Wrote ${PROJECT_BINARY_DIR}/json_config.h") if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ffunction-sections -fdata-sections") if ("${DISABLE_WERROR}" STREQUAL "OFF") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror") endif() set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wcast-qual") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-error=deprecated-declarations") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wextra") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wwrite-strings") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-parameter") if (NOT WIN32) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wstrict-prototypes") endif() add_definitions(-D_GNU_SOURCE) if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang") # Remove this for 1.0 when we can bump the ABI and actually fix these warnings. set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-shorten-64-to-32") endif() elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /DEBUG") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4100") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4996") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4244") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4706") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4702") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4127") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4701") endif() if (NOT ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")) check_c_source_compiles( " /* uClibc toolchains without threading barf when _REENTRANT is defined */ #define _REENTRANT 1 #include int main (void) { return 0; } " REENTRANT_WORKS ) if (REENTRANT_WORKS) add_compile_options("-D_REENTRANT") endif() # OSX Mach-O doesn't support linking with '-Bsymbolic-functions'. # Others may not support it, too. list(APPEND CMAKE_REQUIRED_LIBRARIES "-Wl,-Bsymbolic-functions") check_c_source_compiles( " int main (void) { return 0; } " BSYMBOLIC_WORKS ) list(REMOVE_ITEM CMAKE_REQUIRED_LIBRARIES "-Wl,-Bsymbolic-functions") if (DISABLE_BSYMBOLIC STREQUAL "OFF" AND BSYMBOLIC_WORKS) set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-Bsymbolic-functions") # XXX need cmake>=3.13 for this: #add_link_options("-Wl,-Bsymbolic-functions") endif() file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/check-version-script.sym" "TEST { global: *; };") list(APPEND CMAKE_REQUIRED_LIBRARIES "-Wl,--version-script,${CMAKE_CURRENT_BINARY_DIR}/check-version-script.sym") check_c_source_compiles( " int main (void) { return 0; } " VERSION_SCRIPT_WORKS ) list(REMOVE_ITEM CMAKE_REQUIRED_LIBRARIES "-Wl,--version-script,${CMAKE_CURRENT_BINARY_DIR}/check-version-script.sym") if (VERSION_SCRIPT_WORKS) set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--version-script,${CMAKE_CURRENT_SOURCE_DIR}/json-c.sym") endif() endif() if ($ENV{VALGRIND}) # Build so that valgrind doesn't complain about linkhash.c add_definitions(-DVALGRIND=1) endif() set(JSON_C_PUBLIC_HEADERS # Note: config.h is _not_ included here ${PROJECT_BINARY_DIR}/json_config.h ${PROJECT_BINARY_DIR}/json.h ${PROJECT_SOURCE_DIR}/arraylist.h ${PROJECT_SOURCE_DIR}/debug.h ${PROJECT_SOURCE_DIR}/json_c_version.h ${PROJECT_SOURCE_DIR}/json_inttypes.h ${PROJECT_SOURCE_DIR}/json_object.h ${PROJECT_SOURCE_DIR}/json_object_iterator.h ${PROJECT_SOURCE_DIR}/json_tokener.h ${PROJECT_SOURCE_DIR}/json_types.h ${PROJECT_SOURCE_DIR}/json_util.h ${PROJECT_SOURCE_DIR}/json_visit.h ${PROJECT_SOURCE_DIR}/linkhash.h ${PROJECT_SOURCE_DIR}/printbuf.h ) set(JSON_C_HEADERS ${JSON_C_PUBLIC_HEADERS} ${PROJECT_SOURCE_DIR}/json_object_private.h ${PROJECT_SOURCE_DIR}/json_pointer_private.h ${PROJECT_SOURCE_DIR}/random_seed.h ${PROJECT_SOURCE_DIR}/strerror_override.h ${PROJECT_SOURCE_DIR}/math_compat.h ${PROJECT_SOURCE_DIR}/snprintf_compat.h ${PROJECT_SOURCE_DIR}/strdup_compat.h ${PROJECT_SOURCE_DIR}/vasprintf_compat.h ) set(JSON_C_SOURCES ${PROJECT_SOURCE_DIR}/arraylist.c ${PROJECT_SOURCE_DIR}/debug.c ${PROJECT_SOURCE_DIR}/json_c_version.c ${PROJECT_SOURCE_DIR}/json_object.c ${PROJECT_SOURCE_DIR}/json_object_iterator.c ${PROJECT_SOURCE_DIR}/json_tokener.c ${PROJECT_SOURCE_DIR}/json_util.c ${PROJECT_SOURCE_DIR}/json_visit.c ${PROJECT_SOURCE_DIR}/linkhash.c ${PROJECT_SOURCE_DIR}/printbuf.c ${PROJECT_SOURCE_DIR}/random_seed.c ${PROJECT_SOURCE_DIR}/strerror_override.c ) if (NOT DISABLE_JSON_POINTER) set(JSON_C_PUBLIC_HEADERS ${JSON_C_PUBLIC_HEADERS} ${PROJECT_SOURCE_DIR}/json_pointer.h) set(JSON_C_SOURCES ${JSON_C_SOURCES} ${PROJECT_SOURCE_DIR}/json_pointer.c) set(JSON_H_JSON_POINTER "#include \"json_pointer.h\"") if (NOT DISABLE_JSON_PATCH) set(JSON_C_PUBLIC_HEADERS ${JSON_C_PUBLIC_HEADERS} ${PROJECT_SOURCE_DIR}/json_patch.h) set(JSON_C_SOURCES ${JSON_C_SOURCES} ${PROJECT_SOURCE_DIR}/json_patch.c) set(JSON_H_JSON_PATCH "#include \"json_patch.h\"") endif() else() set(JSON_H_JSON_POINTER "") set(JSON_H_JSON_PATCH "") endif() configure_file(json.h.cmakein ${PROJECT_BINARY_DIR}/json.h @ONLY) include_directories(${PROJECT_SOURCE_DIR}) include_directories(${PROJECT_BINARY_DIR}) add_subdirectory(doc) # "uninstall" custom target for make generators in unix like operating systems # and if that target is not present if (CMAKE_GENERATOR STREQUAL "Unix Makefiles") if(NOT TARGET uninstall) add_custom_target(uninstall COMMAND cat ${PROJECT_BINARY_DIR}/install_manifest.txt | xargs rm WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} ) endif() endif() # XXX for a normal full distribution we'll need to figure out # XXX how to build both shared and static libraries. # Probably leverage that to build a local VALGRIND=1 library for testing too. add_library(${PROJECT_NAME} ${JSON_C_SOURCES} ${JSON_C_HEADERS} ) set_target_properties(${PROJECT_NAME} PROPERTIES VERSION 5.3.0 SOVERSION 5) list(APPEND CMAKE_TARGETS ${PROJECT_NAME}) # If json-c is used as subroject it set to target correct interface -I flags and allow # to build external target without extra include_directories(...) target_include_directories(${PROJECT_NAME} PUBLIC $ $ ) target_link_libraries(${PROJECT_NAME} PUBLIC ${CMAKE_REQUIRED_LIBRARIES}) # Allow to build static and shared libraries at the same time if (BUILD_STATIC_LIBS AND BUILD_SHARED_LIBS) set(STATIC_LIB ${PROJECT_NAME}-static) add_library(${STATIC_LIB} STATIC ${JSON_C_SOURCES} ${JSON_C_HEADERS} ) target_include_directories(${PROJECT_NAME}-static PUBLIC $ $ ) target_link_libraries(${PROJECT_NAME}-static PUBLIC ${CMAKE_REQUIRED_LIBRARIES}) # rename the static library if (NOT MSVC) set_target_properties(${STATIC_LIB} PROPERTIES OUTPUT_NAME ${PROJECT_NAME} ) endif() list(APPEND CMAKE_TARGETS ${STATIC_LIB}) endif () # Always create new install dirs with 0755 permissions, regardless of umask set(CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE ) install(TARGETS ${CMAKE_TARGETS} EXPORT ${PROJECT_NAME}-targets RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ${CMAKE_INSTALL_INCLUDEDIR}/json-c ) install(EXPORT ${PROJECT_NAME}-targets FILE ${PROJECT_NAME}-targets.cmake NAMESPACE ${PROJECT_NAME}:: DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} ) configure_package_config_file( "cmake/Config.cmake.in" ${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config.cmake INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" ) install( FILES ${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} ) if (UNIX OR MINGW OR CYGWIN) SET(prefix ${CMAKE_INSTALL_PREFIX}) # exec_prefix is prefix by default and CMake does not have the # concept. SET(exec_prefix ${CMAKE_INSTALL_PREFIX}) SET(libdir ${CMAKE_INSTALL_FULL_LIBDIR}) SET(includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR}) SET(VERSION ${PROJECT_VERSION}) # Linking against the static json-c requires # dependent packages to include additional libs: SET(LIBS_LIST ${CMAKE_REQUIRED_LIBRARIES}) # Note: We would need cmake >= 3.12 in order to use list(TRANSFORM ...) function(list_transform_prepend var prefix) set(temp "") foreach(f ${${var}}) list(APPEND temp "${prefix}${f}") endforeach() set(${var} "${temp}" PARENT_SCOPE) endfunction() list_transform_prepend(LIBS_LIST "-l") string(REPLACE ";" " " LIBS "${LIBS_LIST}") configure_file(json-c.pc.in json-c.pc @ONLY) set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_LIBDIR}/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files") install(FILES ${PROJECT_BINARY_DIR}/json-c.pc DESTINATION "${INSTALL_PKGCONFIG_DIR}") endif () install(FILES ${JSON_C_PUBLIC_HEADERS} DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR}/json-c) if (CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_TESTING AND (NOT MSVC OR NOT (MSVC_VERSION LESS 1800)) # Tests need at least VS2013 ) add_subdirectory(tests) endif() if (CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_APPS) # skip apps when we're included in someone else's build if (NOT MSVC) # cmd line apps don't built on Windows currently. add_subdirectory(apps) endif() endif() json-c-json-c-0.17-20230812/COPYING000066400000000000000000000042351446575330000157660ustar00rootroot00000000000000 Copyright (c) 2009-2012 Eric Haszlakiewicz Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ---------------------------------------------------------------- Copyright (c) 2004, 2005 Metaparadigm Pte Ltd Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. json-c-json-c-0.17-20230812/ChangeLog000066400000000000000000000706241446575330000165120ustar00rootroot00000000000000 0.17 (up to commit 077661f, 2023-08-08) ======================================== Deprecated and removed features: -------------------------------- * None New features ------------ * json_patch: add first implementation only with patch application * Add --disable-static and --disable-dynamic options to the cmake-configure script. * Add -DBUILD_APPS=NO option to disable app build * Minimum cmake version is now 3.9 Significant changes and bug fixes --------------------------------- * When serializing with JSON_C_TO_STRING_PRETTY set, keep the opening and closing curly or square braces on same line for empty objects or arrays. * Disable locale handling when targeting a uClibc system due to problems with its duplocale() function. * When parsing with JSON_TOKENER_STRICT set, integer overflow/underflow now result in a json_tokener_error_parse_number. Without that flag values are capped at INT64_MIN/UINT64_MAX. * Fix memory leak with emtpy strings in json_object_set_string * json_object_from_fd_ex: fail if file is too large (>=INT_MAX bytes) * Add back json_number_chars, but only because it's part of the public API. * Entirely drop mode bits from open(O_RDONLY) to avoid warnings on certain platforms. * Specify dependent libraries, including -lbsd, in a more consistent way so linking against a static json-c works better * Fix a variety of build problems and add & improve tests * Update RFC reference to https://www.rfc-editor.org/rfc/rfc8259 *** 0.16 (up to commit 66dcdf5, 2022-04-13) ======================================== Deprecated and removed features: -------------------------------- * JSON_C_OBJECT_KEY_IS_CONSTANT is deprecated in favor of JSON_C_OBJECT_ADD_CONSTANT_KEY * Direct access to lh_table and lh_entry structure members is deprecated. Use access functions instead, lh_table_head(), lh_entry_next(), etc... * Drop REFCOUNT_DEBUG code. New features ------------ * The 0.16 release introduces no new features Build changes ------------- * Add a DISABLE_EXTRA_LIBS option to skip using libbsd * Add a DISABLE_JSON_POINTER option to skip compiling in json_pointer support. Significant changes and bug fixes --------------------------------- * Cap string length at INT_MAX to avoid various issues with very long strings. * json_object_deep_copy: fix deep copy of strings containing '\0' * Fix read past end of buffer in the "json_parse" command * Avoid out of memory accesses in the locally provided vasprintf() function (for those platforms that use it) * Handle allocation failure in json_tokener_new_ex * Fix use-after-free in json_tokener_new_ex() in the event of printbuf_new() returning NULL * printbuf_memset(): set gaps to zero - areas within the print buffer which have not been initialized by using printbuf_memset * printbuf: return -1 on invalid arguments (len < 0 or total buffer > INT_MAX) * sprintbuf(): propagate printbuf_memappend errors back to the caller Optimizations -------------- * Speed up parsing by replacing ctype functions with simplified, faster non-locale-sensitive ones in json_tokener and json_object_to_json_string. * Neither vertical tab nor formfeed are considered whitespace per the JSON spec * json_object: speed up creation of objects, calloc() -> malloc() + set fields * Avoid needless extra strlen() call in json_c_shallow_copy_default() and json_object_equal() when the object is known to be a json_type_string. Other changes ------------- * Validate size arguments in arraylist functions. * Use getrandom() if available; with GRND_NONBLOCK to allow use of json-c very early during boot, such as part of cryptsetup. * Use arc4random() if it's available. * random_seed: on error, continue to next method instead of exiting the process * Close file when unable to read from /dev/urandom in get_dev_random_seed() *** 0.15 (up to commit 870965e, 2020/07/26) ======================================== Deprecated and removed features: -------------------------------- * Deprecate `array_list_new()` in favor of `array_list_new2()` * Remove the THIS_FUNCTION_IS_DEPRECATED define. * Remove config.h.win32 New features ------------ * Add a `JSON_TOKENER_ALLOW_TRAILING_CHARS` flag to allow multiple objects to be parsed even when `JSON_TOKENER_STRICT` is set. * Add `json_object_new_array_ext(int)` and `array_list_new_2(int)` to allow arrays to be allocated with the exact size needed, when known. * Add `json_object_array_shrink()` (and `array_list_shrink()`) and use it in json_tokener to minimize the amount of memory used. * Add a json_parse binary, for use in testing changes (not installed, but available in the apps directory). Build changes ------------- * #639/#621 - Add symbol versions to all exported symbols * #508/#634 - Always enable -fPIC to allow use of the json-c static library in other libraries * Build both static and shared libraries at the same time. * #626 - Restore compatibility with cmake 2.8 * #471 - Always create directories with mode 0755, regardless of umask. * #606/#604 - Improve support for OSes like AIX and IBM i, as well as for MINGW32 and old versions of MSVC * #451/#617 - Add a DISABLE_THREAD_LOCAL_STORAGE cmake option to disable the use of thread-local storage. Significant changes and bug fixes --------------------------------- * Split the internal json_object structure into several sub-types, one for each json_type (json_object_object, json_object_string, etc...). This improves memory usage and speed, with the benchmark under bench/ report 5.8% faster test time and 6%(max RSS)-12%(peak heap) less memory usage. Memory used just for json_object structures decreased 27%, so use cases with fewer arrays and/or strings would benefit more. * Minimize memory usage in array handling in json_tokener by shrinking arrays to the exact number of elements parsed. On bench/ benchmark: 9% faster test time, 39%(max RSS)-50%(peak heap) less memory usage. Add json_object_array_shrink() and array_list_shrink() functions. * #616 - Parsing of surrogate pairs in unicode escapes now properly handles incremental parsing. * Fix incremental parsing of numbers, especially those with exponents, e.g. so parsing "[0", "e+", "-]" now properly returns an error. Strict mode now rejects missing exponents ("0e"). * Successfully return number objects at the top level even when they are followed by a "-", "." or "e". This makes parsing things like "123-45" behave consistently with things like "123xyz". Other changes ------------- * #589 - Detect broken RDRAND during initialization; also, fix segfault in the CPUID check. * #592 - Fix integer overflows to prevert out of bounds write on large input. * Protect against division by zero in linkhash, when created with zero size. * #602 - Fix json_parse_uint64() internal error checking, leaving the retval untouched in more failure cases. * #614 - Prevent truncation when custom double formatters insert extra \0's *** 0.14 (up to commit 9ed00a6, 2020/04/14) ========================================= Deprecated and removed features: -------------------------------- * bits.h has been removed * lh_abort() has been removed * lh_table_lookup() has been removed, use lh_table_lookup_ex() instead. * Remove TRUE and FALSE defines, use 1 and 0 instead. Build changes: -------------- ## Deprecated and removed features: * bits.h has been removed * lh_abort() has been removed * lh_table_lookup() has been removed, use lh_table_lookup_ex() instead. * Remove TRUE and FALSE defines, use 1 and 0 instead. * autoconf support, including autogen.sh, has been removed. See details about cmake, below. * With the addition of json_tokener_get_parse_end(), access to internal fields of json_tokener, as well as use of many other symbols and types in json_tokener.h, is deprecated now. * The use of Android.configure.mk to build for Android no longer works, and it is unknown how (or if) the new cmake-based build machinery can be used. * Reports of success, or pull requests to correct issues are welcome. ## Notable improvements and new features ### Builds and documentation * Build machinery has been switched to CMake. See README.md for details about how to build. * TL;DR: `mkdir build ; cd build ; cmake -DCMAKE_INSTALL_PREFIX=/some/path ../json-c ; make all test install` * To ease the transition, there is a `cmake-configure` wrapper that emulates the old autoconf-based configure script. * This has enabled improvements to the build on Windows system; also all public functions have been fixed to be properly exported. For best results, use Visual Studio 2015 or newer. * The json-c style guide has been updated to specify the use of clang-format, and all code has been reformatted. * Since many lines of code have trivial changes now, when using git blame, be sure to specify -w * Numerous improvements have been made to the documentation including function effects on refcounts, when passing a NULL is safe, and so on. ### json_tokener changes * Added a json_tokener_get_parse_end() function to replace direct access of tok->char_offset. * The char_offset field, and the rest of the json_tokener structure remain exposed for now, but expect a future release to hide it like is done with json_object_private.h * json_tokener_parse_ex() now accepts a new JSON_TOKENER_VALIDATE_UTF8 flag to validate that input is UTF8. * If validation fails, json_tokener_get_error(tok) will return json_tokener_error_parse_utf8_string (see enum json_tokener_error). ### Other changes and additions * Add support for unsigned 64-bit integers, uint64_t, to gain one extra bit of magnitude for positive ints. * json_tokener will now parse values up to UINT64_MAX (18446744073709551615) * Existing methods returning int32_t or int64_t will cap out-of-range values at INT32_MAX or INT64_MAX, preserving existing behavior. * The implementation includes the possibility of easily extending this to larger sizes in the future. * A total of 7 new functions were added: * json_object_get_uint64 ( struct json_object const* jso ) * json_object_new_uint64 ( uint64_t i ) * json_object_set_uint64 ( struct json_object* jso, uint64_t new_value ) * json_parse_uint64 ( char const* buf, uint64_t* retval ) * See description of uint64 support, above. * json_tokener_get_parse_end ( struct json_tokener* tok ) * See details under "json_tokener changes", above. * json_object_from_fd_ex ( int fd, int in_depth ) * Allows the max nesting depth to be specified. * json_object_new_null ( ) * Simply returns NULL. Its use is not recommended. * The size of struct json_object has decreased from 96 bytes to 88 bytes. ### Testing * Many updates were made to test cases, increasing code coverage. * There is now a quick way (JSONC_TEST_TRACE=1) to turn on shell tracing in tests. * To run tests, use `make test`; the old "check" target no longer exists. ## Significant bug fixes For the full list of issues and pull requests since the previous release, please see issues_closed_for_0.14.md * [Issue #389](https://github.com/json-c/json-c/issues/389): Add an assert to explicitly crash when _ref_count is corrupted, instead of a later "double free" error. * [Issue #407](https://github.com/json-c/json-c/issues/407): fix incorrect casts in calls to ctype functions (isdigit and isspace) so we don't crash when asserts are enabled on certain platforms and characters > 128 are parsed. * [Issue #418](https://github.com/json-c/json-c/issues/418): Fix docs for json_util_from_fd and json_util_from_file to say that they return NULL on failures. * [Issue #422](https://github.com/json-c/json-c/issues/422): json_object.c:set errno in json_object_get_double() when called on a json_type_string object with bad content. * [Issue #453](https://github.com/json-c/json-c/issues/453): Fixed misalignment in JSON serialization when JSON_C_TO_STRING_SPACED and JSON_C_TO_STRING_PRETTY are used together. * [Issue #463](https://github.com/json-c/json-c/issues/463): fix newlocale() call to use LC_NUMERIC_MASK instead of LC_NUMERIC, and remove incorrect comment. * [Issue #486](https://github.com/json-c/json-c/issues/486): append a missing ".0" to negative double values to ensure they are serialized as floating point numbers. * [Issue #488](https://github.com/json-c/json-c/issues/488): use JSON_EXPORT on functions so they are properly exported on Windows. * [Issue #539](https://github.com/json-c/json-c/issues/539): use an internal-only serializer function in json_object_new_double_s() to avoid potential conflicts with user code that uses the json_object_userdata_to_json_string serializer. *** 0.13.1 (up to commit 0f814e5, 2018/03/04) ========================================= * Bump the major version of the .so library generated up to 4.0 to avoid conflicts because some downstream packagers of json-c had already done their own bump to ".so.3" for a much older 0.12 release. * Add const size_t json_c_object_sizeof() * Avoid invalid free (and thus a segfault) when ref_count gets < 0 * PR#394: fix handling of custom double formats that include a ".0" * Avoid uninitialized variable warnings in json_object_object_foreach * Issue #396: fix build for certain uClibc based systems. * Add a top level fuzz directory for fuzzers run by OSS-Fuzz 0.13 (up to commit 5dae561, 2017/11/29) ================================= This release, being three and a half years after the 0.12 branch (f84d9c), has quite a number of changes included. The following is a sampling of the most significant ones. Since the 0.12 release, 250 issues and pull requests have been closed. See issues_closed_for_0.13.md for a complete list. Deprecated and removed features: -------------------------------- * All internal use of bits.h has been eliminated. The file will be removed. Do not use: hexdigit(), error_ptr(), error_descrition() and it_error() * lh_abort() is deprecated. It will be removed. Behavior changes: ----------------- * Tighten the number parsing algorithm to raise errors instead of truncating the results. For example 12.3.4 or 2015-01-15, which now return null. See commit 99d8fc * Use size_t for array length and size. Platforms where sizeof(size_t) != sizeof(int) may not be backwards compatible See commits 45c56b, 92e9a5 and others. * Check for failure when allocating memory, returning NULL and errno=ENOMEM. See commit 2149a04. * Change json_object_object_add() return type from void to int, and will return -1 on failures, instead of exiting. (Note: this is not an ABI change) New features: ------------- * We're aiming to follow RFC 7159 now. * Add a couple of additional option to json_object_to_json_string_ext: JSON_C_TO_STRING_PRETTY_TAB JSON_C_TO_STRING_NOSLASHESCAPE * Add a json_object_object_add_ex() function to allow for performance improvements when certain constraints are known to be true. * Make serialization format of doubles configurable, in two different ways: Call json_object_set_serializer with json_object_double_to_json_string and a custom format on each double object, or Call json_c_set_serialization_double_format() to set a global or thread-wide format. * Add utility function for comparing json_objects - json_object_equal() * Add a way to copy entire object trees: json_object_deep_copy() * Add json_object_set_ function to modify the value of existing json_object's without the need to recreate them. Also add a json_object_int_inc function to adjust an int's value. * Add support for JSON pointer, RFC 6901. See json_pointer.h * Add a json_util_get_last_err() function to retrieve the string describing the cause of errors, instead of printing to stderr. * Add perllike hash function for strings, and json_global_set_string_hash() 8f8d03d * Add a json_c_visit() function to provide a way to iterate over a tree of json-c objects. Notable bug fixes and other improvements: ----------------------------------------- * Make reference increment and decrement atomic to allow passing json objects between threads. * Fix json_object_object_foreach to avoid uninitialized variable warnings. * Improve performance by removing unneeded data items from hashtable code and reducing duplicate hash computation. * Improve performance by storing small strings inside json_object * Improve performance of json_object_to_json_string by removing variadic printf. commit 9ff0f49 * Issue #371: fix parsing of "-Infinity", and avoid needlessly copying the input when doing so. * Fix stack buffer overflow in json_object_double_to_json_string_format() - commit 2c2deb87 * Fix various potential null ptr deref and int32 overflows * Issue #332: fix a long-standing bug in array_list_put_idx() where it would attempt to free previously free'd entries due to not checking the current array length. * Issue #195: use uselocale() instead of setlocale() in json_tokener to behave better in threaded environments. * Issue #275: fix out of bounds read when handling unicode surrogate pairs. * Ensure doubles that happen to be a whole number are emitted with ".0" - commit ca7a19 * PR#331: for Visual Studio, use a snprintf/vsnprintf wrapper that ensures the string is terminated. * Fix double to int cast overflow in json_object_get_int64. * Clamp double to int32 when narrowing in json_object_get_int. * Use strtoll() to parse ints - instead of sscanf * Miscellaneous smaller changes, including removing unused variables, fixing warning about uninitialized variables adding const qualifiers, reformatting code, etc... Build changes: -------------- * Add Appveyor and Travis build support * Switch to using CMake when building on Windows with Visual Studio. A dynamic .dll is generated instead of a .lib config.h is now generated, config.h.win32 should no longer be manually copied * Add support for MacOS through CMake too. * Enable silent build by default * Link against libm when needed * Add support for building with AddressSanitizer * Add support for building with Clang * Add a --enable-threading configure option, and only use the (slower) __sync_add_and_fetch()/__sync_sub_and_fetch() function when it is specified. List of new functions added: ---------------------------- ### json_object.h * array_list_bsearch() * array_list_del_idx() * json_object_to_json_string_length() * json_object_get_userdata() * json_object_set_userdata() * json_object_object_add_ex() * json_object_array_bsearch() * json_object_array_del_idx() * json_object_set_boolean() * json_object_set_int() * json_object_int_inc() * json_object_set_int64() * json_c_set_serialization_double_format() * json_object_double_to_json_string() * json_object_set_double() * json_object_set_string() * json_object_set_string_len() * json_object_equal() * json_object_deep_copy() ### json_pointer.h * json_pointer_get() * json_pointer_getf() * json_pointer_set() * json_pointer_setf() ### json_util.h * json_object_from_fd() * json_object_to_fd() * json_util_get_last_err() ### json_visit.h * json_c_visit() ### linkhash.h * json_global_set_string_hash() * lh_table_resize() ### printbuf.h * printbuf_strappend() 0.12.1 ====== * Minimal changes to address compile issues. 0.12 ==== * Address security issues: * CVE-2013-6371: hash collision denial of service * CVE-2013-6370: buffer overflow if size_t is larger than int * Avoid potential overflow in json_object_get_double * Eliminate the mc_abort() function and MC_ABORT macro. * Make the json_tokener_errors array local. It has been deprecated for a while, and json_tokener_error_desc() should be used instead. * change the floating point output format to %.17g so values with more than 6 digits show up in the output. * Remove the old libjson.so name compatibility support. The library is only created as libjson-c.so now and headers are only installed into the ${prefix}/json-c directory. * When supported by the linker, add the -Bsymbolic-functions flag. * Various changes to fix the build on MSVC. * Make strict mode more strict: * number must not start with 0 * no single-quote strings * no comments * trailing char not allowed * only allow lowercase literals * Added a json_object_new_double_s() convenience function to allow an exact string representation of a double to be specified when creating the object and use it in json_tokener_parse_ex() so a re-serialized object more exactly matches the input. * Add support NaN and Infinity 0.11 ==== * IMPORTANT: the name of the library has changed to libjson-c.so and the header files are now in include/json-c. The pkgconfig name has also changed from json to json-c. You should change your build to use appropriate -I and -l options. A compatibility shim is in place so builds using the old name will continue to work, but that will be removed in the next release. * Maximum recursion depth is now a runtime option. json_tokener_new() is provided for compatibility. json_tokener_new_ex(depth) * Include json_object_iterator.h in the installed headers. * Add support for building on Android. * Rewrite json_object_object_add to replace just the value if the key already exists so keys remain valid. * Make it safe to delete keys while iterating with the json_object_object_foreach macro. * Add a json_set_serializer() function to allow the string output of a json_object to be customized. * Make float parsing locale independent. * Add a json_tokener_set_flags() function and a JSON_TOKENER_STRICT flag. * Enable -Werror when building. * speed improvements to parsing 64-bit integers on systems with working sscanf * Add a json_object_object_length function. * Fix a bug (buffer overrun) when expanding arrays to more than 64 entries. 0.10 ==== * Add a json_object_to_json_string_ext() function to allow output to be formatted in a more human readable form. * Add json_object_object_get_ex(), a NULL-safe get object method, to be able to distinguish between a key not present and the value being NULL. * Add an alternative iterator implementation, see json_object_iterator.h * Make json_object_iter public to enable external use of the json_object_object_foreachC macro. * Add a printbuf_memset() function to provide an efficient way to set and append things like whitespace indentation. * Adjust json_object_is_type and json_object_get_type so they return json_type_null for NULL objects and handle NULL passed to json_objct_object_get(). * Rename boolean type to json_bool. * Fix various compile issues for Visual Studio and MinGW. * Allow json_tokener_parse_ex() to be re-used to parse multiple object. Also, fix some parsing issues with capitalized hexadecimal numbers and number in E notation. * Add json_tokener_get_error() and json_tokener_error_desc() to better encapsulate the process of retrieving errors while parsing. * Various improvements to the documentation of many functions. * Add new json_object_array_sort() function. * Fix a bug in json_object_get_int(), which would incorrectly return 0 when called on a string type object. Eric Haszlakiewicz * Add a json_type_to_name() function. Eric Haszlakiewicz * Add a json_tokener_parse_verbose() function. Jehiah Czebotar * Improve support for null bytes within JSON strings. Jehiah Czebotar * Fix file descriptor leak if memory allocation fails in json_util Zachary Blair, zack_blair at hotmail dot com * Add int64 support. Two new functions json_object_net_int64 and json_object_get_int64. Binary compatibility preserved. Eric Haszlakiewicz, EHASZLA at transunion com Rui Miguel Silva Seabra, rms at 1407 dot org * Fix subtle bug in linkhash where lookup could hang after all slots were filled then successively freed. Spotted by Jean-Marc Naud, j dash m at newtraxtech dot com * Make json_object_from_file take const char *filename Spotted by Vikram Raj V, vsagar at attinteractive dot com * Add handling of surrogate pairs (json_tokener.c, test4.c, Makefile.am) Brent Miller, bdmiller at yahoo dash inc dot com * Correction to comment describing printbuf_memappend in printbuf.h Brent Miller, bdmiller at yahoo dash inc dot com 0.9 === * Add README.html README-WIN32.html config.h.win32 to Makefile.am Michael Clark, * Add const qualifier to the json_tokener_parse functions Eric Haszlakiewicz, EHASZLA at transunion dot com * Rename min and max so we can never clash with C or C++ std library Ian Atha, thatha at yahoo dash inc dot com * Fix any noticeable spelling or grammar errors. * Make sure every va_start has a va_end. * Check all pointers for validity. Erik Hovland, erik at hovland dot org * Fix json_object_get_boolean to return false for empty string Spotted by Vitaly Kruglikov, Vitaly dot Kruglikov at palm dot com * optimizations to json_tokener_parse_ex(), printbuf_memappend() Brent Miller, bdmiller at yahoo dash inc dot com * Disable REFCOUNT_DEBUG by default in json_object.c * Don't use this as a variable, so we can compile with a C++ compiler * Add casts from void* to type of assignment when using malloc * Add #ifdef __cplusplus guards to all of the headers * Add typedefs for json_object, json_tokener, array_list, printbuf, lh_table Michael Clark, * Null pointer dereference fix. Fix json_object_get_boolean strlen test to not return TRUE for zero length string. Remove redundant includes. Erik Hovland, erik at hovland dot org * Fixed warning reported by adding -Wstrict-prototypes -Wold-style-definition to the compilatin flags. Dotan Barak, dotanba at gmail dot com * Add const correctness to public interfaces Gerard Krol, g dot c dot krol at student dot tudelft dot nl 0.8 === * Add va_end for every va_start Dotan Barak, dotanba at gmail dot com * Add macros to enable compiling out debug code Geoffrey Young, geoff at modperlcookbook dot org * Fix bug with use of capital E in numbers with exponents Mateusz Loskot, mateusz at loskot dot net * Add stddef.h include * Patch allows for json-c compile with -Werror and not fail due to -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations Geoffrey Young, geoff at modperlcookbook dot org 0.7 === * Add escaping of backslash to json output * Add escaping of forward slash on tokenizing and output * Changes to internal tokenizer from using recursion to using a depth state structure to allow incremental parsing 0.6 === * Fix bug in escaping of control characters Johan Björklund, johbjo09 at kth dot se * Remove include "config.h" from headers (should only be included from .c files) Michael Clark 0.5 === * Make headers C++ compatible by change *this to *obj * Add ifdef C++ extern "C" to headers * Use simpler definition of min and max in bits.h Larry Lansing, llansing at fuzzynerd dot com * Remove automake 1.6 requirement * Move autogen commands into autogen.sh. Update README * Remove error pointer special case for Windows * Change license from LGPL to MIT Michael Clark 0.4 === * Fix additional error case in object parsing * Add back sign reversal in nested object parse as error pointer value is negative, while error value is positive. Michael Clark 0.3 === * fix pointer arithmetic bug for error pointer check in is_error() macro * fix type passed to printbuf_memappend in json_tokener * update autotools bootstrap instructions in README Michael Clark 0.2 === * printbuf.c - C. Watford (christopher.watford@gmail.com) Added a Win32/Win64 compliant implementation of vasprintf * debug.c - C. Watford (christopher.watford@gmail.com) Removed usage of vsyslog on Win32/Win64 systems, needs to be handled by a configure script * json_object.c - C. Watford (christopher.watford@gmail.com) Added scope operator to wrap usage of json_object_object_foreach, this needs to be rethought to be more ANSI C friendly * json_object.h - C. Watford (christopher.watford@gmail.com) Added Microsoft C friendly version of json_object_object_foreach * json_tokener.c - C. Watford (christopher.watford@gmail.com) Added a Win32/Win64 compliant implementation of strndup * json_util.c - C. Watford (christopher.watford@gmail.com) Added cast and mask to suffice size_t v. unsigned int conversion correctness * json_tokener.c - sign reversal issue on error info for nested object parse spotted by Johan Björklund (johbjo09 at kth.se) * json_object.c - escape " in json_escape_str * Change to automake and libtool to build shared and static library Michael Clark 0.1 === * initial release json-c-json-c-0.17-20230812/INSTALL000066400000000000000000000000561446575330000157610ustar00rootroot00000000000000 See README.md for installation instructions. json-c-json-c-0.17-20230812/NEWS000066400000000000000000000000221446575330000154200ustar00rootroot00000000000000See the git repo. json-c-json-c-0.17-20230812/README000066400000000000000000000000351446575330000156050ustar00rootroot00000000000000See README.md or README.html json-c-json-c-0.17-20230812/README.html000066400000000000000000000033661446575330000165620ustar00rootroot00000000000000 JSON-C - A JSON implementation in C

JSON-C - A JSON implementation in C

Overview

JSON-C implements a reference counting object model that allows you to easily construct JSON objects in C, output them as JSON formatted strings and parse JSON formatted strings back into the C representation of JSON objects. It aims to conform to RFC 7159.

Building

To setup JSON-C to build on your system please run configure and make.

If you are on Win32 cmake is required, generally:

  • mkdir build
  • cd build
  • cmake ..
  • msbuild "json-c.vcxproj" /m /verbosity:normal /p:OutDir=lib\
  • Or, open the project in Visual Studio

Documentation

Doxygen generated documentation exists here.

GIT Reposository

git clone https://github.com/json-c/json-c.git

Mailing List

Send email to json-c <at> googlegroups <dot> com

License

This program is free software; you can redistribute it and/or modify it under the terms of the MIT License.

json-c-json-c-0.17-20230812/README.md000066400000000000000000000306511446575330000162130ustar00rootroot00000000000000\mainpage `json-c` ======== 1. [Overview and Build Status](#overview) 2. [Getting Help](#gettinghelp) 3. [Building on Unix](#buildunix) * [Prerequisites](#installprereq) * [Build commands](#buildcmds) 4. [CMake options](#CMake) 5. [Testing](#testing) 6. [Building with `vcpkg`](#buildvcpkg) 7. [Building for Android](#android) 7. [Linking to libjson-c](#linking) 8. [Using json-c](#using) JSON-C - A JSON implementation in C ----------------------------------- JSON-C implements a reference counting object model that allows you to easily construct JSON objects in C, output them as JSON formatted strings and parse JSON formatted strings back into the C representation of JSON objects. It aims to conform to [RFC 8259](https://www.rfc-editor.org/rfc/rfc8259). Skip down to [Using json-c](#using) or check out the [API docs](https://json-c.github.io/json-c/), if you already have json-c installed and ready to use. Home page for json-c: https://github.com/json-c/json-c/wiki Getting Help ------------ If you have questions about using json-c, please start a thread on our forums at: https://groups.google.com/forum/#!forum/json-c If you believe you've discovered a bug, report it at (https://github.com/json-c/json-c/issues). Please be sure to include the version of json-c you're using, the OS you're running on, and any other relevant details. Fully reproducible test cases and/or patches to fix problems are greatly appreciated. Fixes for bugs, or small new features can be directly submitted as a [pull request](https://github.com/json-c/json-c/pulls). For major new features or large changes of any kind, please first start a discussion on the [forums](https://groups.google.com/forum/#!forum/json-c). Building on Unix with `git`, `gcc` and `cmake` -------------------------------------------------- If you already have json-c installed, see [Linking to `libjson-c`](#linking) for how to build and link your program against it. Build Status * [AppVeyor Build](https://ci.appveyor.com/project/hawicz/json-c) ![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/github/json-c/json-c?branch=master&svg=true) * [Travis Build](https://app.travis-ci.com/github/json-c/json-c) ![Travis Build Status](https://api.travis-ci.com/json-c/json-c.svg?branch=master) Test Status * [Coveralls](https://coveralls.io/github/json-c/json-c?branch=master) [![Coverage Status](https://coveralls.io/repos/github/json-c/json-c/badge.svg?branch=master)](https://coveralls.io/github/json-c/json-c?branch=master) ### Prerequisites: - `gcc`, `clang`, or another C compiler - `cmake>=2.8`, `>=3.16` recommended, `cmake=>3.1` for tests To generate docs you'll also need: - `doxygen>=1.8.13` If you are on a relatively modern system, you'll likely be able to install the prerequisites using your OS's packaging system. ### Install using apt (e.g. Ubuntu 16.04.2 LTS) ```sh sudo apt install git sudo apt install cmake sudo apt install doxygen # optional sudo apt install valgrind # optional ``` ### Build instructions: `json-c` GitHub repo: https://github.com/json-c/json-c ```sh $ git clone https://github.com/json-c/json-c.git $ mkdir json-c-build $ cd json-c-build $ cmake ../json-c # See CMake section below for custom arguments ``` Note: it's also possible to put your build directory inside the json-c source directory, or even not use a separate build directory at all, but certain things might not work quite right (notably, `make distcheck`) Then: ```sh $ make $ make test $ make USE_VALGRIND=0 test # optionally skip using valgrind $ sudo make install # it could be necessary to execute make install ``` ### Generating documentation with Doxygen: The library documentation can be generated directly from the source code using Doxygen tool: ```sh # in build directory make doc google-chrome doc/html/index.html ``` CMake Options -------------------- The json-c library is built with [CMake](https://cmake.org/cmake-tutorial/), which can take a few options. Variable | Type | Description -----------------------------|--------|-------------- CMAKE_INSTALL_PREFIX | String | The install location. CMAKE_BUILD_TYPE | String | Defaults to "debug". BUILD_SHARED_LIBS | Bool | The default build generates a dynamic (dll/so) library. Set this to OFF to create a static library only. BUILD_STATIC_LIBS | Bool | The default build generates a static (lib/a) library. Set this to OFF to create a shared library only. DISABLE_STATIC_FPIC | Bool | The default builds position independent code. Set this to OFF to create a shared library only. DISABLE_BSYMBOLIC | Bool | Disable use of -Bsymbolic-functions. DISABLE_THREAD_LOCAL_STORAGE | Bool | Disable use of Thread-Local Storage (HAVE___THREAD). DISABLE_WERROR | Bool | Disable use of -Werror. DISABLE_EXTRA_LIBS | Bool | Disable use of extra libraries, libbsd DISABLE_JSON_POINTER | Bool | Omit json_pointer support from the build. ENABLE_RDRAND | Bool | Enable RDRAND Hardware RNG Hash Seed. ENABLE_THREADING | Bool | Enable partial threading support. OVERRIDE_GET_RANDOM_SEED | String | A block of code to use instead of the default implementation of json_c_get_random_seed(), e.g. on embedded platforms where not even the fallback to time() works. Must be a single line. Pass these options as `-D` on CMake's command-line. ```sh # build a static library only cmake -DBUILD_SHARED_LIBS=OFF .. ``` ### Building with partial threading support Although json-c does not support fully multi-threaded access to object trees, it has some code to help make its use in threaded programs a bit safer. Currently, this is limited to using atomic operations for json_object_get() and json_object_put(). Since this may have a performance impact, of at least 3x slower according to https://stackoverflow.com/a/11609063, it is disabled by default. You may turn it on by adjusting your cmake command with: -DENABLE_THREADING=ON Separately, the default hash function used for object field keys, lh_char_hash, uses a compare-and-swap operation to ensure the random seed is only generated once. Because this is a one-time operation, it is always compiled in when the compare-and-swap operation is available. ### cmake-configure wrapper script For those familiar with the old autoconf/autogen.sh/configure method, there is a `cmake-configure` wrapper script to ease the transition to cmake. ```sh mkdir build cd build ../cmake-configure --prefix=/some/install/path make ``` cmake-configure can take a few options. | options | Description| | ---- | ---- | | prefix=PREFIX | install architecture-independent files in PREFIX | | enable-threading | Enable code to support partly multi-threaded use | | enable-rdrand | Enable RDRAND Hardware RNG Hash Seed generation on supported x86/x64 platforms. | | enable-shared | build shared libraries [default=yes] | | enable-static | build static libraries [default=yes] | | disable-Bsymbolic | Avoid linking with -Bsymbolic-function | | disable-werror | Avoid treating compiler warnings as fatal errors | Testing: ---------- By default, if valgrind is available running tests uses it. That can slow the tests down considerably, so to disable it use: ```sh export USE_VALGRIND=0 ``` To run tests a separate build directory is recommended: ```sh mkdir build-test cd build-test # VALGRIND=1 causes -DVALGRIND=1 to be passed when compiling code # which uses slightly slower, but valgrind-safe code. VALGRIND=1 cmake .. make make test # By default, if valgrind is available running tests uses it. make USE_VALGRIND=0 test # optionally skip using valgrind ``` If a test fails, check `Testing/Temporary/LastTest.log`, `tests/testSubDir/${testname}/${testname}.vg.out`, and other similar files. If there is insufficient output try: ```sh VERBOSE=1 CTEST_OUTPUT_ON_FAILURE=1 make test ``` or ```sh JSONC_TEST_TRACE=1 make test ``` and check the log files again. Building on Unix and Windows with `vcpkg` -------------------------------------------------- You can download and install JSON-C using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager: git clone https://github.com/Microsoft/vcpkg.git cd vcpkg ./bootstrap-vcpkg.sh ./vcpkg integrate install vcpkg install json-c The JSON-C port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository. Building for Android ---------------------- Building on Android is now particularly well supported, but there have been some reports of success using https://developer.android.com/ndk/guides/cmake ``` mkdir json-c-build cd json-c-build/ export NDK_HOME=~/Library/Android/sdk/ndk/22.1.7171670/ cmake \ --toolchain=$NDK_HOME/build/cmake/android.toolchain.cmake \ -DANDROID_STL=none \ -DANDROID_ABI=arm64-v8a \ -DANDROID_PLATFORM=android-29 \ -DANDROID_LD=lld \ -DCMAKE_BUILD_TYPE=MinSizeRel \ -DCMAKE_INSTALL_PREFIX= \ -DENABLE_THREADING=true \ .. make install ``` Linking to `libjson-c` ---------------------- If your system has `pkgconfig`, then you can just add this to your `makefile`: ```make CFLAGS += $(shell pkg-config --cflags json-c) LDFLAGS += $(shell pkg-config --libs json-c) ``` Without `pkgconfig`, you might do something like this: ```make JSON_C_DIR=/path/to/json_c/install CFLAGS += -I$(JSON_C_DIR)/include/json-c # Or to use lines like: #include #CFLAGS += -I$(JSON_C_DIR)/include LDFLAGS+= -L$(JSON_C_DIR)/lib -ljson-c ``` If your project uses cmake: * Add to your CMakeLists.txt file: ```cmake find_package(json-c CONFIG) target_link_libraries(${PROJECT_NAME} PRIVATE json-c::json-c) ``` * Then you might run in your project: ```sh cd build cmake -DCMAKE_PREFIX_PATH=/path/to/json_c/install/lib64/cmake .. ``` Using json-c ------------ To use json-c you can either include json.h, or preferably, one of the following more specific header files: * json_object.h - Core types and methods. * json_tokener.h - Methods for parsing and serializing json-c object trees. * json_pointer.h - JSON Pointer (RFC 6901) implementation for retrieving objects from a json-c object tree. * json_object_iterator.h - Methods for iterating over single json_object instances. (See also `json_object_object_foreach()` in json_object.h) * json_visit.h - Methods for walking a tree of json-c objects. * json_util.h - Miscellaneous utility functions. For a full list of headers see [files.html](https://json-c.github.io/json-c/json-c-current-release/doc/html/files.html) The primary type in json-c is json_object. It describes a reference counted tree of json objects which are created by either parsing text with a json_tokener (i.e. `json_tokener_parse_ex()`), or by creating (with `json_object_new_object()`, `json_object_new_int()`, etc...) and adding (with `json_object_object_add()`, `json_object_array_add()`, etc...) them individually. Typically, every object in the tree will have one reference, from its parent. When you are done with the tree of objects, you call json_object_put() on just the root object to free it, which recurses down through any child objects calling json_object_put() on each one of those in turn. You can get a reference to a single child (`json_object_object_get()` or `json_object_array_get_idx()`) and use that object as long as its parent is valid. If you need a child object to live longer than its parent, you can increment the child's refcount (`json_object_get()`) to allow it to survive the parent being freed or it being removed from its parent (`json_object_object_del()` or `json_object_array_del_idx()`) When parsing text, the json_tokener object is independent from the json_object that it returns. It can be allocated (`json_tokener_new()`) used one or multiple times (`json_tokener_parse_ex()`, and freed (`json_tokener_free()`) while the json_object objects live on. A json_object tree can be serialized back into a string with `json_object_to_json_string_ext()`. The string that is returned is only valid until the next "to_json_string" call on that same object. Also, it is freed when the json_object is freed. json-c-json-c-0.17-20230812/RELEASE_CHECKLIST.txt000066400000000000000000000131061446575330000201420ustar00rootroot00000000000000 # Release checklist: ## Pre-release tasks * Figure out whether a release is worthwhile to do. * Analyze the previous release branch to see if anything should have been applied to master. * Collect changes and assemble tentative release notes. * Identify previous release branch point * Check commit logs between previous branch point and now for notable changes worth mentioning * Create a new issues_closed_for_X.Y.md file * Include notable entries from here in the release notes. * Analyze APIs between previous release branch and master to produce list of changes (added/removed/updated funcs, etc...), and detect backwards compat issues. * https://github.com/lvc/abi-compliance-checker * See also `abi-check.sh` * If the new release is not backwards compatible, then this is a MAJOR release. * Mention removed features in ChangeLog * Consider re-adding backwards compatible support, through symbol aliases and appropriate entries in json-c.sym * Be sure any new symbols are listed in json-c.sym as part of the _new_ release version. * Update the AUTHORS file PREV=$(git tag | tail -1) ( git log -r ${PREV}..HEAD | grep Author: | sed -e's/Author: //' ; cat AUTHORS ) | sort -u > A1 mv A1 AUTHORS * Exclude mentioning changes that have already been included in a point release of the previous release branch. * Update ChangeLog with relevant notes before branching. * Check that the compile works on Linux - automatic through Travis * Check that the compile works on NetBSD * Check that the compile works on Windows - automatic through AppVeyor ## Release creation Start creating the new release: PREV=$(git tag | tail -1) PREV=${PREV#json-c-} PREV=${PREV%-*} release=0.$((${PREV#*.} + 1)) cd ~ git clone https://github.com/json-c/json-c json-c-${release} rm -rf distcheck mkdir distcheck cd distcheck # Note, the build directory *must* be entirely separate from # the source tree for distcheck to work properly. cmake -DCMAKE_BUILD_TYPE=Release ../json-c-${release} make distcheck cd .. Make any fixes/changes *before* branching. cd json-c-${release} git checkout -b json-c-${release} ------------ Using ${release}: Update the version in json_c_version.h Update the version in CMakeLists.txt (VERSION in the project(...) line) Update the set_target_properties() line in CmakeLists.txt to set the shared library version. Generally, unless we're doing a major release, change: VERSION x.y.z to VERSION x.y+1.z git commit -a -m "Bump version to ${release}" If we're doing a major release (SONAME bump), also bump the version of ALL symbols in json-c.sym. See explanation at https://github.com/json-c/json-c/issues/621 More info at: https://software.intel.com/sites/default/files/m/a/1/e/dsohowto.pdf ------------ Generate the doxygen documentation: (cd ../distcheck && make doc) cp -r -p ../distcheck/doc/{html,Doxyfile} doc/. rm doc/Doxyfile # Remove generated file w/ hardcoded paths git add -f doc git commit doc -m "Generate docs for the ${release} release" ------------ Create the release tarballs: cd .. echo .git > excludes tar -czf json-c-${release}.tar.gz -X excludes json-c-${release} echo 'doc/*.cmake' >> excludes echo 'doc/CMakeFiles' >> excludes echo 'doc/Makefile' >> excludes echo 'doc/Doxyfile' >> excludes echo 'doc/html' >> excludes tar -czf json-c-${release}-nodoc.tar.gz -X excludes json-c-${release} ------------ Tag the branch: cd json-c-${release} git tag -a json-c-${release}-$(date +%Y%m%d) -m "Release json-c-${release}" git push origin json-c-${release} git push --tags ------------ Go to Amazon S3 service at: https://console.aws.amazon.com/s3/ Upload the two tarballs in the json-c_releases/releases folder. * Expand "Permissions", pick "Grant public-read access" * Expand "Properties", ensure "Standard" storage class is picked. Logout of Amazon S3, and verify that the files are visible. https://s3.amazonaws.com/json-c_releases/releases/index.html =================================== Post-release checklist: git checkout master Add new section to ChangeLog for ${release}+1 Use ${release}.99 to indicate a version "newer" than anything on the branch: Update the version in json_c_version.h Update the version in CMakeLists.txt Update RELEASE_CHECKLIST.txt, set release=${release}+1 Add a new empty section to the json-c.sym file, for ${release}+1 Update the set_target_properties() line in CmakeLists.txt to match the release branch. git commit -a -m "Update the master branch to version ${release}.99" git push ------------ Update the gh-pages branch with new docs: cd json-c-${release} git checkout json-c-${release} cd .. git clone -b gh-pages https://github.com/json-c/json-c json-c-pages cd json-c-pages mkdir json-c-${release} cp -R ../json-c-${release}/doc json-c-${release}/. git add json-c-${release} rm json-c-current-release ln -s json-c-${release} json-c-current-release git commit -a -m "Add the ${release} docs." vi index.html # Add/change links to current release. git commit -a -m "Update the doc links to point at ${release}" git push ------------ Update checksums on wiki page. cd .. openssl sha -sha256 json-c*gz openssl md5 json-c*gz Copy and paste this output into the wiki page at: * https://github.com/json-c/json-c/wiki * https://github.com/json-c/json-c/wiki/Old-Releases ------------ Send an email to the mailing list. json-c-json-c-0.17-20230812/STYLE.txt000066400000000000000000000022251446575330000163710ustar00rootroot00000000000000In general: For minor changes to a function, copy the existing formatting. When changing the style, commit that separately from other changes. For new code and major changes to a function, switch to the official json-c style. Official json-c style: Aim for readability, not strict conformance to fixed style rules. Formatting is tab based; previous attempts at proper alignment with spaces for continuation lines have been abandoned in favor of the convenience of using clang-format. Refer to the .clang-format file for details, and run the tool before commit: clang-format -i somefile.c foo.h For sections of code that would be significantly negatively impacted, surround them with magic comments to disable formatting: /* clang-format off */ ...code... /* clang-format on */ Naming: Words within function and variable names are separated with underscores. Avoid camel case. Prefer longer, more descriptive names, but not excessively so. No single letter variable names. Other: Variables should be defined for the smallest scope needed. Functions should be defined static when possible. When possible, avoid exposing internals in the public API. json-c-json-c-0.17-20230812/abi-check.sh000066400000000000000000000016111446575330000170700ustar00rootroot00000000000000#!/bin/sh prev=0.16 release=0.17 # ... clone json-c, abi-compliance-checker, abi-dumper mkdir build cd build CFLAGS=-Og cmake -DCMAKE_INSTALL_PREFIX=~/json-c-installs/json-c-${release} .. make && make test && make install # Assume the old version has already been built cd ~/abi-compliance-checker mkxml() { ver="$1" cat < json-c-${ver}.xml ${ver} ../json-c-installs/json-c-${ver}/include/json-c ../json-c-installs/json-c-${ver}/lib64/libjson-c.so EOF } mkxml ${release} mkxml ${prev} perl abi-compliance-checker.pl -lib json-c -dump json-c-${prev}.xml -dump-path ./ABI-${prev}.dump perl abi-compliance-checker.pl -lib json-c -dump json-c-${release}.xml -dump-path ./ABI-${release}.dump perl abi-compliance-checker.pl -l json-c -old ABI-${prev}.dump -new ABI-${release}.dump echo "look in compat_reports/json-c/..." json-c-json-c-0.17-20230812/apps/000077500000000000000000000000001446575330000156725ustar00rootroot00000000000000json-c-json-c-0.17-20230812/apps/CMakeLists.txt000066400000000000000000000104651446575330000204400ustar00rootroot00000000000000 cmake_minimum_required(VERSION 2.8) # see ../CMakeLists.txt for why 2.8 if(POLICY CMP0075) cmake_policy(SET CMP0075 NEW) endif() include(CheckSymbolExists) include(CheckIncludeFile) include(CMakePackageConfigHelpers) # First, sort out whether we're running inside a json-c build, # or standalone, such as part of a benchmark build. if ("${PROJECT_NAME}" STREQUAL "json-c") # Part of an overall json-c build set(APPS_LINK_LIBS "${PROJECT_NAME}") # We know we have this in our current sources: set(HAVE_JSON_TOKENER_GET_PARSE_END) else() # Standalone mode, using an already installed json-c library, somewhere. # The path to the json-c install must be specified with -DCMAKE_PREFIX_PATH=... project(apps) find_package(PkgConfig) # PkgConfig is supposed to include CMAKE_PREFIX_PATH in the PKG_CONFIG_PATH # that's used when running pkg-config, but it just doesn't work :( # https://gitlab.kitware.com/cmake/cmake/issues/18150 #set(PKG_CONFIG_USE_CMAKE_PREFIX_PATH True) # Instead, we handle it explicitly here and update PKG_CONFIG_PATH ourselves. if (NOT CMAKE_PREFIX_PATH) message(FATAL_ERROR "Please specify -DCMAKE_PREFIX_PATH=... when running cmake.") endif() # Note: find_file isn't recursive :( find_file(PC_FILE_PATH "json-c.pc" PATHS "${CMAKE_PREFIX_PATH}/lib64" "${CMAKE_PREFIX_PATH}/lib" PATH_SUFFIXES "pkgconfig" NO_DEFAULT_PATH) get_filename_component(PC_DIR_PATH "${PC_FILE_PATH}" DIRECTORY) set(ENV{PKG_CONFIG_PATH} "$ENV{PKG_CONFIG_PATH}:${PC_DIR_PATH}") message(STATUS "PC_FILE_PATH=${PC_FILE_PATH}") message(STATUS "PC_DIR_PATH=${PC_DIR_PATH}") pkg_check_modules(PC_JSONC json-c) if (PC_JSONC_FOUND) message(STATUS "Found json-c using pkg-config: ${PC_JSONC_PREFIX}") message(STATUS " PC_JSONC_INCLUDE_DIRS=${PC_JSONC_INCLUDE_DIRS}") message(STATUS " PC_JSONC_LIBRARIES=${PC_JSONC_LIBRARIES}") message(STATUS " PC_JSONC_LIBRARY_DIRS=${PC_JSONC_LIBRARY_DIRS}") link_directories(${PC_JSONC_LIBRARY_DIRS}) include_directories(${PC_JSONC_INCLUDE_DIRS}) # for target_link_libraries(...) set(APPS_INCLUDE_DIRS ${PC_JSONC_INCLUDE_DIRS}) set(APPS_LINK_DIRS ${PC_JSONC_LIBRARY_DIRS}) set(APPS_LINK_LIBS ${PC_JSONC_LIBRARIES}) else() message(STATUS "Using find_package to locate json-c") # Note: find_package needs CMAKE_PREFIX_PATH set appropriately. # XXX json-c's installed cmake files don't actually set up what's # needed to use find_package() by itself, so we're just using it # to confirm the top of the install location. find_package(json-c CONFIG) # sets json-c_DIR # Assume json-c-config.cmake is in lib64/cmake/json-c/ get_filename_component(json-c_TOP "${json-c_DIR}/../../.." ABSOLUTE) get_filename_component(json-c_LIBDIR "${json-c_DIR}/../.." ABSOLUTE) message(STATUS " json-c_TOP=${json-c_TOP}") message(STATUS " json-c_DIR=${json-c_DIR}") message(STATUS " json-c_LIBDIR=${json-c_LIBDIR}") link_directories(${json-c_LIBDIR}) include_directories(${json-c_TOP}/include) include_directories(${json-c_TOP}/include/json-c) set(APPS_LINK_DIRS "${json-c_LIBDIR}") set(APPS_INCLUDE_DIRS "${json-c_TOP}/include;${json-c_TOP}/include/json-c") set(APPS_LINK_LIBS json-c) endif() set(CMAKE_REQUIRED_LINK_OPTIONS "-L${APPS_LINK_DIRS}") set(CMAKE_REQUIRED_LIBRARIES ${APPS_LINK_LIBS}) set(CMAKE_REQUIRED_INCLUDES ${APPS_INCLUDE_DIRS}) check_symbol_exists(json_tokener_get_parse_end "json_tokener.h" HAVE_JSON_TOKENER_GET_PARSE_END) endif() # end "standalone mode" block # --------------------------------- check_include_file(sys/resource.h HAVE_SYS_RESOURCE_H) # for getrusage if (HAVE_SYS_RESOURCE_H) check_symbol_exists(getrusage "sys/resource.h" HAVE_GETRUSAGE) endif() configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/apps_config.h.in ${PROJECT_BINARY_DIR}/apps_config.h) message(STATUS "Wrote ${PROJECT_BINARY_DIR}/apps_config.h") # --------------------------------- include_directories(PUBLIC ${CMAKE_SOURCE_DIR}) include_directories(${PROJECT_SOURCE_DIR}) include_directories(${PROJECT_BINARY_DIR}) # --------------------------------- # Now, finally, the actual executables we're building: add_executable(json_parse json_parse.c) target_link_libraries(json_parse PRIVATE ${APPS_LINK_LIBS}) # Note: it is intentional that there are no install instructions here yet. # When/if the interface of the app(s) listed here settles down enough to # publish as part of a regular build that will be added. json-c-json-c-0.17-20230812/apps/cmake/000077500000000000000000000000001446575330000167525ustar00rootroot00000000000000json-c-json-c-0.17-20230812/apps/cmake/apps_config.h.in000066400000000000000000000003401446575330000220150ustar00rootroot00000000000000 /* Define to 1 if you have the header file. */ #cmakedefine HAVE_SYS_RESOURCE_H /* Define if you have the `getrusage' function. */ #cmakedefine HAVE_GETRUSAGE #cmakedefine HAVE_JSON_TOKENER_GET_PARSE_END json-c-json-c-0.17-20230812/apps/json_parse.c000066400000000000000000000124651446575330000202110ustar00rootroot00000000000000#include #include #include #include #include #include #include #include #include #include "apps_config.h" /* XXX for a regular program, these should be * but that's inconvenient when building in the json-c source tree. */ #include "json_object.h" #include "json_tokener.h" #include "json_util.h" #ifdef HAVE_SYS_RESOURCE_H #include #include #endif #ifndef JSON_NORETURN #if defined(_MSC_VER) #define JSON_NORETURN __declspec(noreturn) #elif defined(__OS400__) #define JSON_NORETURN #else /* 'cold' attribute is for optimization, telling the computer this code * path is unlikely. */ #define JSON_NORETURN __attribute__((noreturn, cold)) #endif #endif static int formatted_output = JSON_C_TO_STRING_SPACED; static int show_output = 1; static int strict_mode = 0; static int color = 0; static const char *fname = NULL; #ifndef HAVE_JSON_TOKENER_GET_PARSE_END #define json_tokener_get_parse_end(tok) ((tok)->char_offset) #endif JSON_NORETURN static void usage(const char *argv0, int exitval, const char *errmsg); static void showmem(void); static int parseit(int fd, int (*callback)(struct json_object *)); static int showobj(struct json_object *new_obj); static void showmem(void) { #ifdef HAVE_GETRUSAGE struct rusage rusage; memset(&rusage, 0, sizeof(rusage)); getrusage(RUSAGE_SELF, &rusage); fprintf(stderr, "maxrss: %ld KB\n", rusage.ru_maxrss); #endif } static int parseit(int fd, int (*callback)(struct json_object *)) { struct json_object *obj; char buf[32768]; ssize_t ret; int depth = JSON_TOKENER_DEFAULT_DEPTH; json_tokener *tok; tok = json_tokener_new_ex(depth); if (!tok) { fprintf(stderr, "unable to allocate json_tokener: %s\n", strerror(errno)); return 1; } json_tokener_set_flags(tok, JSON_TOKENER_STRICT #ifdef JSON_TOKENER_ALLOW_TRAILING_CHARS | JSON_TOKENER_ALLOW_TRAILING_CHARS #endif ); // XXX push this into some kind of json_tokener_parse_fd API? // json_object_from_fd isn't flexible enough, and mirroring // everything you can do with a tokener into json_util.c seems // like the wrong approach. size_t total_read = 0; while ((ret = read(fd, buf, sizeof(buf))) > 0) { size_t retu = (size_t)ret; // We know it's positive total_read += retu; size_t start_pos = 0; while (start_pos != retu) { obj = json_tokener_parse_ex(tok, &buf[start_pos], retu - start_pos); enum json_tokener_error jerr = json_tokener_get_error(tok); size_t parse_end = json_tokener_get_parse_end(tok); if (obj == NULL && jerr != json_tokener_continue) { const char *aterr = (start_pos + parse_end < (int)sizeof(buf)) ? &buf[start_pos + parse_end] : ""; fflush(stdout); size_t fail_offset = total_read - retu + start_pos + parse_end; fprintf(stderr, "Failed at offset %lu: %s %c\n", (unsigned long)fail_offset, json_tokener_error_desc(jerr), aterr[0]); json_tokener_free(tok); return 1; } if (obj != NULL) { int cb_ret = callback(obj); json_object_put(obj); if (cb_ret != 0) { json_tokener_free(tok); return 1; } } start_pos += json_tokener_get_parse_end(tok); assert(start_pos <= retu); } } if (ret < 0) { fprintf(stderr, "error reading fd %d: %s\n", fd, strerror(errno)); } json_tokener_free(tok); return 0; } static int showobj(struct json_object *new_obj) { if (new_obj == NULL) { fprintf(stderr, "%s: Failed to parse\n", fname); return 1; } fprintf(stderr, "Successfully parsed object from %s\n", fname); if (show_output) { const char *output; output = json_object_to_json_string_ext(new_obj, formatted_output | color); printf("%s\n", output); } showmem(); return 0; } static void usage(const char *argv0, int exitval, const char *errmsg) { FILE *fp = stdout; if (exitval != 0) fp = stderr; if (errmsg != NULL) fprintf(fp, "ERROR: %s\n\n", errmsg); fprintf(fp, "Usage: %s [-f|-F ] [-n] [-s]\n", argv0); fprintf(fp, " -f - Format the output to stdout with JSON_C_TO_STRING_PRETTY (default is JSON_C_TO_STRING_SPACED)\n"); fprintf(fp, " -F - Format the output to stdout with , e.g. 0 for JSON_C_TO_STRING_PLAIN\n"); fprintf(fp, " -n - No output\n"); fprintf(fp, " -c - color\n"); fprintf(fp, " -s - Parse in strict mode, flags:\n"); fprintf(fp, " JSON_TOKENER_STRICT|JSON_TOKENER_ALLOW_TRAILING_CHARS\n"); fprintf(fp, " Diagnostic information will be emitted to stderr\n"); fprintf(fp, "\nWARNING WARNING WARNING\n"); fprintf(fp, "This is a prototype, it may change or be removed at any time!\n"); exit(exitval); } int main(int argc, char **argv) { int opt; while ((opt = getopt(argc, argv, "fF:hnsc")) != -1) { switch (opt) { case 'f': formatted_output = JSON_C_TO_STRING_PRETTY; break; case 'F': formatted_output = atoi(optarg); break; case 'n': show_output = 0; break; case 's': strict_mode = 1; break; case 'c': color = JSON_C_TO_STRING_COLOR; break; case 'h': usage(argv[0], 0, NULL); default: /* '?' */ usage(argv[0], EXIT_FAILURE, "Unknown arguments"); } } if (optind >= argc) { usage(argv[0], EXIT_FAILURE, "Expected argument after options"); } fname = argv[optind]; int fd = open(argv[optind], O_RDONLY, 0); showmem(); if (parseit(fd, showobj) != 0) exit(EXIT_FAILURE); showmem(); exit(EXIT_SUCCESS); } json-c-json-c-0.17-20230812/appveyor.yml000066400000000000000000000044771446575330000173330ustar00rootroot00000000000000version: '{branch}.{build}' image: # b_toolset: v143 - Visual Studio 2022 # VS2015 also used for earlier VS builds # aka os: Windows Server 2012 R2 - Visual Studio 2015 # aka os: Windows Server 2016 # b_toolset: v141 - Visual Studio 2017 # aka os: Windows Server 2019 # b_toolset: v142 - Visual Studio 2019 platform: x64 environment: matrix: - b_toolset: Windows7.1SDK - b_toolset: v120 - b_toolset: v140 - b_toolset: v141 - b_toolset: v142 - b_toolset: v143 configuration: - Debug - Release build_script: - cmake -T %b_toolset% -DCMAKE_BUILD_TYPE=%CONFIGURATION% -DCMAKE_INSTALL_PREFIX=t_install . - cmake --build . --target install matrix: exclude: # Skip release builds for all except the newest image - image: Visual Studio 2015 configuration: Release # In the "old" image, new toolsets aren't available: - image: Visual Studio 2015 b_toolset: v141 - image: Visual Studio 2015 b_toolset: v142 - image: Visual Studio 2015 b_toolset: v143 # ---- - image: Visual Studio 2017 configuration: Release # In the "new" images, exclude all toolsets except the relevant # one for that image: - image: Visual Studio 2017 b_toolset: Windows7.1SDK - image: Visual Studio 2017 b_toolset: v120 - image: Visual Studio 2017 b_toolset: v140 - image: Visual Studio 2017 b_toolset: v142 - image: Visual Studio 2017 b_toolset: v143 # ---- - image: Visual Studio 2019 configuration: Release - image: Visual Studio 2019 b_toolset: Windows7.1SDK - image: Visual Studio 2019 b_toolset: v120 - image: Visual Studio 2019 b_toolset: v140 - image: Visual Studio 2019 b_toolset: v141 - image: Visual Studio 2019 b_toolset: v143 # ---- - image: Visual Studio 2022 b_toolset: Windows7.1SDK - image: Visual Studio 2022 b_toolset: v120 - image: Visual Studio 2022 b_toolset: v140 - image: Visual Studio 2022 b_toolset: v141 - image: Visual Studio 2022 b_toolset: v142 after_build: - cd t_install - 7z a ../json-c.win32.%b_toolset%.%CONFIGURATION%.zip * artifacts: - path: json-c.win32.%b_toolset%.%CONFIGURATION%.zip name: json-c.win32.%b_toolset%.%CONFIGURATION%.zip json-c-json-c-0.17-20230812/arraylist.c000066400000000000000000000126541446575330000171150ustar00rootroot00000000000000/* * $Id: arraylist.c,v 1.4 2006/01/26 02:16:28 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ #include "config.h" #include #ifdef STDC_HEADERS #include #include #endif /* STDC_HEADERS */ #if defined(HAVE_STRINGS_H) && !defined(_STRING_H) && !defined(__USE_BSD) #include #endif /* HAVE_STRINGS_H */ #ifndef SIZE_T_MAX #if SIZEOF_SIZE_T == SIZEOF_INT #define SIZE_T_MAX UINT_MAX #elif SIZEOF_SIZE_T == SIZEOF_LONG #define SIZE_T_MAX ULONG_MAX #elif SIZEOF_SIZE_T == SIZEOF_LONG_LONG #define SIZE_T_MAX ULLONG_MAX #else #error Unable to determine size of size_t #endif #endif #include "arraylist.h" struct array_list *array_list_new(array_list_free_fn *free_fn) { return array_list_new2(free_fn, ARRAY_LIST_DEFAULT_SIZE); } struct array_list *array_list_new2(array_list_free_fn *free_fn, int initial_size) { struct array_list *arr; if (initial_size < 0 || (size_t)initial_size >= SIZE_T_MAX / sizeof(void *)) return NULL; arr = (struct array_list *)malloc(sizeof(struct array_list)); if (!arr) return NULL; arr->size = initial_size; arr->length = 0; arr->free_fn = free_fn; if (!(arr->array = (void **)malloc(arr->size * sizeof(void *)))) { free(arr); return NULL; } return arr; } extern void array_list_free(struct array_list *arr) { size_t i; for (i = 0; i < arr->length; i++) if (arr->array[i]) arr->free_fn(arr->array[i]); free(arr->array); free(arr); } void *array_list_get_idx(struct array_list *arr, size_t i) { if (i >= arr->length) return NULL; return arr->array[i]; } static int array_list_expand_internal(struct array_list *arr, size_t max) { void *t; size_t new_size; if (max < arr->size) return 0; /* Avoid undefined behaviour on size_t overflow */ if (arr->size >= SIZE_T_MAX / 2) new_size = max; else { new_size = arr->size << 1; if (new_size < max) new_size = max; } if (new_size > (~((size_t)0)) / sizeof(void *)) return -1; if (!(t = realloc(arr->array, new_size * sizeof(void *)))) return -1; arr->array = (void **)t; arr->size = new_size; return 0; } int array_list_shrink(struct array_list *arr, size_t empty_slots) { void *t; size_t new_size; if (empty_slots >= SIZE_T_MAX / sizeof(void *) - arr->length) return -1; new_size = arr->length + empty_slots; if (new_size == arr->size) return 0; if (new_size > arr->size) return array_list_expand_internal(arr, new_size); if (new_size == 0) new_size = 1; if (!(t = realloc(arr->array, new_size * sizeof(void *)))) return -1; arr->array = (void **)t; arr->size = new_size; return 0; } int array_list_insert_idx(struct array_list *arr, size_t idx, void *data) { size_t move_amount; if (idx >= arr->length) return array_list_put_idx(arr, idx, data); /* we're at full size, what size_t can support */ if (arr->length == SIZE_T_MAX) return -1; if (array_list_expand_internal(arr, arr->length + 1)) return -1; move_amount = (arr->length - idx) * sizeof(void *); memmove(arr->array + idx + 1, arr->array + idx, move_amount); arr->array[idx] = data; arr->length++; return 0; } //static inline int _array_list_put_idx(struct array_list *arr, size_t idx, void *data) int array_list_put_idx(struct array_list *arr, size_t idx, void *data) { if (idx > SIZE_T_MAX - 1) return -1; if (array_list_expand_internal(arr, idx + 1)) return -1; if (idx < arr->length && arr->array[idx]) arr->free_fn(arr->array[idx]); arr->array[idx] = data; if (idx > arr->length) { /* Zero out the arraylist slots in between the old length and the newly added entry so we know those entries are empty. e.g. when setting array[7] in an array that used to be only 5 elements longs, array[5] and array[6] need to be set to 0. */ memset(arr->array + arr->length, 0, (idx - arr->length) * sizeof(void *)); } if (arr->length <= idx) arr->length = idx + 1; return 0; } int array_list_add(struct array_list *arr, void *data) { /* Repeat some of array_list_put_idx() so we can skip several checks that we know are unnecessary when appending at the end */ size_t idx = arr->length; if (idx > SIZE_T_MAX - 1) return -1; if (array_list_expand_internal(arr, idx + 1)) return -1; arr->array[idx] = data; arr->length++; return 0; } void array_list_sort(struct array_list *arr, int (*compar)(const void *, const void *)) { qsort(arr->array, arr->length, sizeof(arr->array[0]), compar); } void *array_list_bsearch(const void **key, struct array_list *arr, int (*compar)(const void *, const void *)) { return bsearch(key, arr->array, arr->length, sizeof(arr->array[0]), compar); } size_t array_list_length(struct array_list *arr) { return arr->length; } int array_list_del_idx(struct array_list *arr, size_t idx, size_t count) { size_t i, stop; /* Avoid overflow in calculation with large indices. */ if (idx > SIZE_T_MAX - count) return -1; stop = idx + count; if (idx >= arr->length || stop > arr->length) return -1; for (i = idx; i < stop; ++i) { // Because put_idx can skip entries, we need to check if // there's actually anything in each slot we're erasing. if (arr->array[i]) arr->free_fn(arr->array[i]); } memmove(arr->array + idx, arr->array + stop, (arr->length - stop) * sizeof(void *)); arr->length -= count; return 0; } json-c-json-c-0.17-20230812/arraylist.h000066400000000000000000000050401446575330000171110ustar00rootroot00000000000000/* * $Id: arraylist.h,v 1.4 2006/01/26 02:16:28 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Internal methods for working with json_type_array objects. * Although this is exposed by the json_object_get_array() method, * it is not recommended for direct use. */ #ifndef _json_c_arraylist_h_ #define _json_c_arraylist_h_ #ifdef __cplusplus extern "C" { #endif #include #define ARRAY_LIST_DEFAULT_SIZE 32 typedef void(array_list_free_fn)(void *data); struct array_list { void **array; size_t length; size_t size; array_list_free_fn *free_fn; }; typedef struct array_list array_list; /** * Allocate an array_list of the default size (32). * @deprecated Use array_list_new2() instead. */ extern struct array_list *array_list_new(array_list_free_fn *free_fn); /** * Allocate an array_list of the desired size. * * If possible, the size should be chosen to closely match * the actual number of elements expected to be used. * If the exact size is unknown, there are tradeoffs to be made: * - too small - the array_list code will need to call realloc() more * often (which might incur an additional memory copy). * - too large - will waste memory, but that can be mitigated * by calling array_list_shrink() once the final size is known. * * @see array_list_shrink */ extern struct array_list *array_list_new2(array_list_free_fn *free_fn, int initial_size); extern void array_list_free(struct array_list *al); extern void *array_list_get_idx(struct array_list *al, size_t i); extern int array_list_insert_idx(struct array_list *al, size_t i, void *data); extern int array_list_put_idx(struct array_list *al, size_t i, void *data); extern int array_list_add(struct array_list *al, void *data); extern size_t array_list_length(struct array_list *al); extern void array_list_sort(struct array_list *arr, int (*compar)(const void *, const void *)); extern void *array_list_bsearch(const void **key, struct array_list *arr, int (*compar)(const void *, const void *)); extern int array_list_del_idx(struct array_list *arr, size_t idx, size_t count); /** * Shrink the array list to just enough to fit the number of elements in it, * plus empty_slots. */ extern int array_list_shrink(struct array_list *arr, size_t empty_slots); #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/bench/000077500000000000000000000000001446575330000160065ustar00rootroot00000000000000json-c-json-c-0.17-20230812/bench/README.bench.md000066400000000000000000000044761446575330000203560ustar00rootroot00000000000000 Benchmark tests for json-c General strategy: ------------------- * Identify "after" commit hash * Use provided directory * Use provided commit hash * Local changes in current working directory * ${cur_branch} * Identify "before" commit hash, in order of preference * Use provided directory * Use provided commit hash * Use origin/${cur_branch}, if different from ${after_commit} * Use previous release * If not using existing dir, clone to src-${after_commit} * or, checkout appropriate commit in existing src-${after_commit} * Create build & install dirs for ${after_commit} * Build & install ${after_commit} * Compile benchmark programs against install-${after_commit} * If not using existing dir, clone to src-${before_commit} * or, checkout appropriate commit in existing src-${before_commit} * Create build & install dirs for ${before_commit} * Build & install ${before_commit} * Compile benchmark programs against install-${before_commit} * Run benchmark in each location * Compare results heaptrack memory profiler --------------------------- https://milianw.de/blog/heaptrack-a-heap-memory-profiler-for-linux.html ``` yum install libdwarf-devel elfutils boost-devel libunwind-devel git clone git://anongit.kde.org/heaptrack cd heaptrack mkdir build cd build cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo \ -DCMAKE_INSTALL_PREFIX=$HOME/heaptrack-install .. make install ``` Issues -------- * jc-bench.sh is incomplete. * valgrind massif misreports "extra-heap" bytes? "json_parse -n canada.json" shows 38640 KB maxrss. Using valgrind --tool=massif, a large amount of memory is listed as wasted "extra-heap" bytes. (~5.6MB) ``` valgrind --tool=massif --massif-out-file=massif.out ./json_parse -n ~/canada.json ms_print massif.out ``` Using heaptrack, and analyzing the histogram, only shows ~2.6MB ``` heaptrack ./json_parse -n canada.json heaptrack --analyze heaptrack*gz -H histogram.out awk ' { s=$1; count=$2; ru=(int((s+ 15) / 16)) * 16; wasted = ((ru-s)*count); print s, count, ru-s, wasted; total=total+wasted} END { print "Total: ", total }' histogram.out ``` With the (unreleased) arraylist trimming changes, maxrss reported by getrusage() goes down, but massif claims *more* total usage, and a HUGE extra-heap amount (50% of total). json-c-json-c-0.17-20230812/bench/jc-bench.sh000077500000000000000000000146471446575330000200320ustar00rootroot00000000000000#!/bin/sh # # Benchmarking harness for json-c # # Use this to compare the behavior of two different versions of the library, # such as json-c-0.14 release vs master, master vs local changes, etc... # set -e trap 'echo "FAILED!"' EXIT RUNDIR=$(dirname "$0") RUNDIR=$(cd "$RUNDIR" && pwd) TOP=$(cd "$RUNDIR/.." && pwd) usage() { exitval=$1 errmsg=$2 if [ $exitval -ne 0 ] ; then exec 1>&2 fi if [ ! -z "$errmsg" ] ; then echo "ERROR: $errmsg" 1>&2 fi cat < $_commit] as 'after'" else # Local changes in current working directory # ${cur_branch} after_src_dir=$TOP after_commit= echo "Using local changes in $TOP as 'after'" fi fi # Identify "before" commit hash, in order of preference if [ ! -z "$before_arg" -a -d "$before_arg" ] ; then # Use provided directory before_src_dir="$before_arg" before_commit= echo "Using provided directory [$before_arg] as 'before'" else _commit= if [ ! -z "$before_arg" ] ; then # Use provided commit hash _commit=$(git rev-parse --verify "$before_arg") fi if [ ! -z "$_commit" ] ;then before_src_dir= # i.e. current tree before_commit="$_commit" echo "Using provided commit [$before_arg => $_commit] as 'before'" else # Use origin/${cur_branch}, if different from ${after_commit} _cur_branch=$(git rev-parse --abbrev-ref HEAD) _commit= if [ ! -z "${_cur_branch}" ] ; then _commit=$(git rev-parse --verify "origin/${_cur_branch}") echo "Using origin/${_cur_branch} [$_commit] as 'before'" fi if [ "$_commit" = "${after_commit}" ] ; then _commit= fi fi if [ ! -z "$_commit" ] ; then before_src_dir= # i.e. current tree before_commit="$_commit" else # Use previous release before_src_dir= # i.e. current tree before_commit="$(git tag | sort | tail -1)" echo "Using previous release [$before_commit] as 'before'" fi fi echo compile_benchmark() { local bname=$1 local src_dir="$2" local src_commit="$3" local build_dir="${WORK}/$bname/build" local inst_dir="${WORK}/$bname/install" local bench_dir="${WORK}/$bname/bench" echo echo "=========== $bname ===========" echo mkdir -p "${build_dir}" mkdir -p "${inst_dir}" mkdir -p "${bench_dir}" if [ ! -z "$src_commit" ] ; then # Resolve the short hash, tag or branch name to full hash src_commit=$(git rev-parse $src_commit) fi # No src dir specified, clone and checkout $src_commit if [ -z "$src_dir" ] ; then src_dir="${WORK}/$bname/src" echo "=== Using sources in $src_dir" mkdir -p "$src_dir" at_commit=$(git --git-dir="$src_dir/.git" rev-parse HEAD 2> /dev/null || true) echo "at_commit: $at_commit" if [ -z "$at_commit" ] ; then # Assume it's an empty dir git clone -n "$TOP" "$src_dir" fi git -C "$src_dir" --git-dir="$src_dir/.git" checkout "$src_commit" fi # else, use the provided $src_dir if [ -e "${src_dir}/CMakeLists.txt" ] ; then cd "${build_dir}" cmake -DCMAKE_INSTALL_PREFIX="${inst_dir}" "${src_dir}" else # Old versions of json-c used automake/autoconf cd "${src_dir}" sh autogen.sh # always run it, configure doesn't always work cd "${build_dir}" "${src_dir}/configure" --prefix="${inst_dir}" fi make all install cd "${bench_dir}" cmake -DCMAKE_PREFIX_PATH="${inst_dir}" "${TOP}/apps" make all } # XXX TODO: name "after" and "before" uniquely using the dir & commit if [ $do_all -ne 0 -o $do_build -ne 0 ] ; then sleep 5 # Wait slightly, to allow the human to read the message # about what exactly we're doing to benchmark. compile_benchmark "after" "${after_src_dir}" "${after_commit}" compile_benchmark "before" "${before_src_dir}" "${before_commit}" fi run_benchmark() { local bname=$1 local inst_dir="${WORK}/$bname/install" local bench_dir="${WORK}/$bname/bench" local INPUT=${DATA}/canada.json cd "${bench_dir}" mkdir -p results (time ./json_parse -n "${INPUT}") > results/basic_timing.out 2>&1 valgrind --tool=massif --massif-out-file=massif.out ./json_parse -n "${INPUT}" ms_print massif.out > results/ms_print.out heaptrack -o heaptrack_out ./json_parse -n "${INPUT}" heaptrack --analyze heaptrack_out.gz -H histogram.out > results/heaptrack.out awk ' { s=$1; count=$2; ru=(int((s+ 15) / 16)) * 16; wasted = ((ru-s)*count); print s, count, ru-s, wasted; total=total+wasted} END { print "Total: ", total }' histogram.out > results/histogram2.out # XXX stamp some info about what was built & run into ./results/. echo "DONE with $bname" } if [ $do_all -ne 0 -o $do_run -ne 0 ] ; then run_benchmark "after" run_benchmark "before" fi if [ $do_compare -ne 0 ] ; then # XXX this needs better analysis cd "${WORK}" diff -udr before/bench/results after/bench/results || true else echo "To compare results, run:" echo "$0 --compare" fi trap '' EXIT :<<=cut Benchmarks to run: * Parse JSON strings, of various sizes and characteristics * Flags: STRICT vs. non-STRICT, validate UTF8 * Serialization time * plain, spaces, pretty * json_c_visit tests * JSON pointer tests Things to record and compare: * Running time * Peak memory usage * Useful bytes vs. overhead for memory allocations * Total number of allocations * Average allocation size * Log of all allocation sizes =cut json-c-json-c-0.17-20230812/cmake-configure000077500000000000000000000041641446575330000177210ustar00rootroot00000000000000#!/bin/bash # Wrapper around cmake to emulate useful options # from the previous autoconf-based configure script. RUNDIR=$(dirname "$0") RUNDIR=$(cd "$RUNDIR" && pwd) CURDIR=$(pwd) FLAGS=() usage() { exitval="$1" errmsg="$2" if [ $exitval -ne 0 ] ; then exec 1>&2 fi if [ ! -z "$errmsg" ] ; then echo "ERROR: $errmsg" 1>&2 fi cat <] [-- []] --prefix=PREFIX install architecture-independent files in PREFIX --enable-threading Enable code to support partly multi-threaded use --enable-rdrand Enable RDRAND Hardware RNG Hash Seed generation on supported x86/x64 platforms. --enable-shared build shared libraries [default=yes] --enable-static build static libraries [default=yes] --disable-Bsymbolic Avoid linking with -Bsymbolic-function --disable-werror Avoid treating compiler warnings as fatal errors --disable-extra-libs Avoid linking against extra libraries, such as libbsd EOF exit } if [ "$CURDIR" = "$RUNDIR" ] ; then usage 1 "Please mkdir some other build directory, and run this script from there." fi if ! cmake --version ; then usage 1 "Unable to find a working cmake, please be sure you have it installed and on your PATH" fi while [ $# -gt 0 ] ; do case "$1" in -h|--help) usage 0 ;; --prefix) FLAGS+=(-DCMAKE_INSTALL_PREFIX="$2") shift ;; --prefix=*) FLAGS+=(-DCMAKE_INSTALL_PREFIX="${1##--prefix=}") ;; --enable-threading) FLAGS+=(-DENABLE_THREADING=ON) ;; --enable-rdrand) FLAGS+=(-DENABLE_RDRAND=ON) ;; --enable-shared) FLAGS+=(-DBUILD_SHARED_LIBS=ON) ;; --disable-shared) FLAGS+=(-DBUILD_SHARED_LIBS=OFF) ;; --enable-static) FLAGS+=(-DBUILD_STATIC_LIBS=ON) ;; --disable-static) FLAGS+=(-DBUILD_STATIC_LIBS=OFF) ;; --disable-Bsymbolic) FLAGS+=(-DDISABLE_BSYMBOLIC=ON) ;; --disable-werror) FLAGS+=(-DDISABLE_WERROR=ON) ;; --disable-extra-libs) FLAGS+=(-DDISABLE_EXTRA_LIBS=ON) ;; --) shift break ;; -*) usage 1 "Unknown arguments: $*" ;; *) break ;; esac shift done exec cmake "${FLAGS[@]}" "$@" "${RUNDIR}" json-c-json-c-0.17-20230812/cmake/000077500000000000000000000000001446575330000160075ustar00rootroot00000000000000json-c-json-c-0.17-20230812/cmake/Config.cmake.in000066400000000000000000000001761446575330000206270ustar00rootroot00000000000000@PACKAGE_INIT@ include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@-targets.cmake") check_required_components("@PROJECT_NAME@") json-c-json-c-0.17-20230812/cmake/config.h.in000066400000000000000000000154741446575330000200450ustar00rootroot00000000000000 /* Enable RDRAND Hardware RNG Hash Seed */ #cmakedefine ENABLE_RDRAND "@ENABLE_RDRAND@" /* Override json_c_get_random_seed() with custom code */ #cmakedefine OVERRIDE_GET_RANDOM_SEED @OVERRIDE_GET_RANDOM_SEED@ /* Enable partial threading support */ #cmakedefine ENABLE_THREADING "@@" /* Define if .gnu.warning accepts long strings. */ #cmakedefine HAS_GNU_WARNING_LONG "@@" /* Define to 1 if you have the header file. */ #cmakedefine HAVE_DLFCN_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_ENDIAN_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_FCNTL_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_INTTYPES_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_LIMITS_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_LOCALE_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_MEMORY_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_STDARG_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_STDINT_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_STDLIB_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_STRINGS_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_STRING_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_SYSLOG_H @HAVE_SYSLOG_H@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_SYS_CDEFS_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_SYS_PARAM_H @HAVE_SYS_PARAM_H@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_SYS_RANDOM_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_SYS_RESOURCE_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_SYS_STAT_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_SYS_TYPES_H @HAVE_SYS_TYPES_H@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_UNISTD_H @HAVE_UNISTD_H@ /* Define to 1 if you have the header file. */ #cmakedefine HAVE_XLOCALE_H /* Define to 1 if you have the header file. */ #cmakedefine HAVE_BSD_STDLIB_H /* Define to 1 if you have `arc4random' */ #cmakedefine HAVE_ARC4RANDOM /* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */ #cmakedefine HAVE_DOPRNT /* Has atomic builtins */ #cmakedefine HAVE_ATOMIC_BUILTINS /* Define to 1 if you have the declaration of `INFINITY', and to 0 if you don't. */ #cmakedefine HAVE_DECL_INFINITY /* Define to 1 if you have the declaration of `isinf', and to 0 if you don't. */ #cmakedefine HAVE_DECL_ISINF /* Define to 1 if you have the declaration of `isnan', and to 0 if you don't. */ #cmakedefine HAVE_DECL_ISNAN /* Define to 1 if you have the declaration of `nan', and to 0 if you don't. */ #cmakedefine HAVE_DECL_NAN /* Define to 1 if you have the declaration of `_finite', and to 0 if you don't. */ #cmakedefine HAVE_DECL__FINITE /* Define to 1 if you have the declaration of `_isnan', and to 0 if you don't. */ #cmakedefine HAVE_DECL__ISNAN /* Define to 1 if you have the `open' function. */ #cmakedefine HAVE_OPEN /* Define to 1 if you have the `realloc' function. */ #cmakedefine HAVE_REALLOC /* Define to 1 if you have the `setlocale' function. */ #cmakedefine HAVE_SETLOCALE /* Define to 1 if you have the `snprintf' function. */ #cmakedefine HAVE_SNPRINTF /* Define to 1 if you have the `strcasecmp' function. */ #cmakedefine HAVE_STRCASECMP @HAVE_STRCASECMP@ /* Define to 1 if you have the `strdup' function. */ #cmakedefine HAVE_STRDUP /* Define to 1 if you have the `strerror' function. */ #cmakedefine HAVE_STRERROR /* Define to 1 if you have the `strncasecmp' function. */ #cmakedefine HAVE_STRNCASECMP @HAVE_STRNCASECMP@ /* Define to 1 if you have the `uselocale' function. */ #cmakedefine HAVE_USELOCALE /* Define to 1 if newlocale() needs freelocale() called on it's `base` argument */ #cmakedefine NEWLOCALE_NEEDS_FREELOCALE /* Define to 1 if you have the `vasprintf' function. */ #cmakedefine HAVE_VASPRINTF /* Define to 1 if you have the `vprintf' function. */ #cmakedefine HAVE_VPRINTF /* Define to 1 if you have the `vsnprintf' function. */ #cmakedefine HAVE_VSNPRINTF /* Define to 1 if you have the `vsyslog' function. */ #cmakedefine HAVE_VSYSLOG @HAVE_VSYSLOG@ /* Define if you have the `getrandom' function. */ #cmakedefine HAVE_GETRANDOM /* Define if you have the `getrusage' function. */ #cmakedefine HAVE_GETRUSAGE #cmakedefine HAVE_STRTOLL #if !defined(HAVE_STRTOLL) #define strtoll @json_c_strtoll@ /* #cmakedefine json_c_strtoll @json_c_strtoll@*/ #endif #cmakedefine HAVE_STRTOULL #if !defined(HAVE_STRTOULL) #define strtoull @json_c_strtoull@ /* #cmakedefine json_c_strtoull @json_c_strtoull@ */ #endif /* Have __thread */ #cmakedefine HAVE___THREAD /* Public define for json_inttypes.h */ #cmakedefine JSON_C_HAVE_INTTYPES_H @JSON_C_HAVE_INTTYPES_H@ /* Name of package */ #define PACKAGE "@PROJECT_NAME@" /* Define to the address where bug reports for this package should be sent. */ #define PACKAGE_BUGREPORT "@JSON_C_BUGREPORT@" /* Define to the full name of this package. */ #define PACKAGE_NAME "@PROJECT_NAME@" /* Define to the full name and version of this package. */ #define PACKAGE_STRING "@PROJECT_NAME@ @CPACK_PACKAGE_VERSION_MAJOR@.@CPACK_PACKAGE_VERSION_MINOR@.@CPACK_PACKAGE_VERSION_PATCH@" /* Define to the one symbol short name of this package. */ #define PACKAGE_TARNAME "@PROJECT_NAME@" /* Define to the home page for this package. */ #define PACKAGE_URL "https://github.com/json-c/json-c" /* Define to the version of this package. */ #define PACKAGE_VERSION "@CPACK_PACKAGE_VERSION_MAJOR@.@CPACK_PACKAGE_VERSION_MINOR@.@CPACK_PACKAGE_VERSION_PATCH@" /* The number of bytes in type int */ #cmakedefine SIZEOF_INT @SIZEOF_INT@ /* The number of bytes in type int64_t */ #cmakedefine SIZEOF_INT64_T @SIZEOF_INT64_T@ /* The number of bytes in type long */ #cmakedefine SIZEOF_LONG @SIZEOF_LONG@ /* The number of bytes in type long long */ #cmakedefine SIZEOF_LONG_LONG @SIZEOF_LONG_LONG@ /* The number of bytes in type size_t */ #cmakedefine SIZEOF_SIZE_T @SIZEOF_SIZE_T@ /* The number of bytes in type ssize_t */ #cmakedefine SIZEOF_SSIZE_T @SIZEOF_SSIZE_T@ /* Specifier for __thread */ #cmakedefine SPEC___THREAD @SPEC___THREAD@ /* Define to 1 if you have the ANSI C header files. */ #cmakedefine STDC_HEADERS /* Version number of package */ #define VERSION "@CPACK_PACKAGE_VERSION_MAJOR@.@CPACK_PACKAGE_VERSION_MINOR@.@CPACK_PACKAGE_VERSION_PATCH@" /* Define to empty if `const' does not conform to ANSI C. */ #cmakedefine const /* Define to `unsigned int' if does not define. */ #cmakedefine size_t json-c-json-c-0.17-20230812/cmake/json_config.h.in000066400000000000000000000003551446575330000210660ustar00rootroot00000000000000/* Define to 1 if you have the header file. */ #cmakedefine JSON_C_HAVE_INTTYPES_H @JSON_C_HAVE_INTTYPES_H@ /* Define to 1 if you have the header file. */ #cmakedefine JSON_C_HAVE_STDINT_H @JSON_C_HAVE_STDINT_H@ json-c-json-c-0.17-20230812/debug.c000066400000000000000000000026421446575330000161650ustar00rootroot00000000000000/* * $Id: debug.c,v 1.5 2006/01/26 02:16:28 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ #include "config.h" #include #include #include #include #if HAVE_SYSLOG_H #include #endif /* HAVE_SYSLOG_H */ #if HAVE_UNISTD_H #include #endif /* HAVE_UNISTD_H */ #if HAVE_SYS_PARAM_H #include #endif /* HAVE_SYS_PARAM_H */ #include "debug.h" static int _syslog = 0; static int _debug = 0; void mc_set_debug(int debug) { _debug = debug; } int mc_get_debug(void) { return _debug; } extern void mc_set_syslog(int syslog) { _syslog = syslog; } void mc_debug(const char *msg, ...) { va_list ap; if (_debug) { va_start(ap, msg); #if HAVE_VSYSLOG if (_syslog) { vsyslog(LOG_DEBUG, msg, ap); } else #endif vprintf(msg, ap); va_end(ap); } } void mc_error(const char *msg, ...) { va_list ap; va_start(ap, msg); #if HAVE_VSYSLOG if (_syslog) { vsyslog(LOG_ERR, msg, ap); } else #endif vfprintf(stderr, msg, ap); va_end(ap); } void mc_info(const char *msg, ...) { va_list ap; va_start(ap, msg); #if HAVE_VSYSLOG if (_syslog) { vsyslog(LOG_INFO, msg, ap); } else #endif vfprintf(stderr, msg, ap); va_end(ap); } json-c-json-c-0.17-20230812/debug.h000066400000000000000000000052171446575330000161730ustar00rootroot00000000000000/* * $Id: debug.h,v 1.5 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * Copyright (c) 2009 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Do not use, json-c internal, may be changed or removed at any time. */ #ifndef _JSON_C_DEBUG_H_ #define _JSON_C_DEBUG_H_ #include #ifdef __cplusplus extern "C" { #endif #ifndef JSON_EXPORT #if defined(_MSC_VER) && defined(JSON_C_DLL) #define JSON_EXPORT __declspec(dllexport) #else #define JSON_EXPORT extern #endif #endif JSON_EXPORT void mc_set_debug(int debug); JSON_EXPORT int mc_get_debug(void); JSON_EXPORT void mc_set_syslog(int syslog); JSON_EXPORT void mc_debug(const char *msg, ...); JSON_EXPORT void mc_error(const char *msg, ...); JSON_EXPORT void mc_info(const char *msg, ...); #ifndef __STRING #define __STRING(x) #x #endif #ifndef PARSER_BROKEN_FIXED #define JASSERT(cond) \ do \ { \ } while (0) #else #define JASSERT(cond) \ do \ { \ if (!(cond)) \ { \ mc_error("cjson assert failure %s:%d : cond \"" __STRING(cond) "failed\n", \ __FILE__, __LINE__); \ *(int *)0 = 1; \ abort(); \ } \ } while (0) #endif #define MC_ERROR(x, ...) mc_error(x, ##__VA_ARGS__) #ifdef MC_MAINTAINER_MODE #define MC_SET_DEBUG(x) mc_set_debug(x) #define MC_GET_DEBUG() mc_get_debug() #define MC_SET_SYSLOG(x) mc_set_syslog(x) #define MC_DEBUG(x, ...) mc_debug(x, ##__VA_ARGS__) #define MC_INFO(x, ...) mc_info(x, ##__VA_ARGS__) #else #define MC_SET_DEBUG(x) \ if (0) \ mc_set_debug(x) #define MC_GET_DEBUG() (0) #define MC_SET_SYSLOG(x) \ if (0) \ mc_set_syslog(x) #define MC_DEBUG(x, ...) \ if (0) \ mc_debug(x, ##__VA_ARGS__) #define MC_INFO(x, ...) \ if (0) \ mc_info(x, ##__VA_ARGS__) #endif #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/doc/000077500000000000000000000000001446575330000154745ustar00rootroot00000000000000json-c-json-c-0.17-20230812/doc/CMakeLists.txt000066400000000000000000000007211446575330000202340ustar00rootroot00000000000000# generate doxygen documentation for json-c API find_package(Doxygen) if (DOXYGEN_FOUND) configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile) message(STATUS "Wrote ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile") add_custom_target(doc COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile) else (DOXYGEN_FOUND) message("Warning: doxygen not found, the 'doc' target will not be included") endif(DOXYGEN_FOUND) json-c-json-c-0.17-20230812/doc/Doxyfile.in000066400000000000000000003113431446575330000176140ustar00rootroot00000000000000# Doxyfile 1.8.8 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project. # # All text after a double hash (##) is considered a comment and is placed in # front of the TAG it is preceding. # # All text after a single hash (#) is considered a comment and will be ignored. # The format is: # TAG = value [value, ...] # For lists, items can also be appended using: # TAG += value [value, ...] # Values that contain spaces should be placed between quotes (\" \"). #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- # This tag specifies the encoding used for all characters in the config file # that follow. The default is UTF-8 which is also the encoding used for all text # before the first occurrence of this tag. Doxygen uses libiconv (or the iconv # built into libc) for the transcoding. See https://www.gnu.org/software/libiconv # for the list of possible encodings. # The default value is: UTF-8. DOXYFILE_ENCODING = UTF-8 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded by # double-quotes, unless you are using Doxywizard) that should identify the # project for which the documentation is generated. This name is used in the # title of most generated pages and in a few other places. # The default value is: My Project. PROJECT_NAME = json-c # The PROJECT_NUMBER tag can be used to enter a project or revision number. This # could be handy for archiving the generated documentation or if some version # control system is used. PROJECT_NUMBER = @PROJECT_VERSION@ # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a # quick idea about the purpose of the project. Keep the description short. PROJECT_BRIEF = # With the PROJECT_LOGO tag one can specify an logo or icon that is included in # the documentation. The maximum height of the logo should not exceed 55 pixels # and the maximum width should not exceed 200 pixels. Doxygen will copy the logo # to the output directory. PROJECT_LOGO = # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path # into which the generated documentation will be written. If a relative path is # entered, it will be relative to the location where doxygen was started. If # left blank the current directory will be used. OUTPUT_DIRECTORY = @CMAKE_CURRENT_BINARY_DIR@ # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub- # directories (in 2 levels) under the output directory of each output format and # will distribute the generated files over these directories. Enabling this # option can be useful when feeding doxygen a huge amount of source files, where # putting all generated files in the same directory would otherwise causes # performance problems for the file system. # The default value is: NO. CREATE_SUBDIRS = NO # If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII # characters to appear in the names of generated files. If set to NO, non-ASCII # characters will be escaped, for example _xE3_x81_x84 will be used for Unicode # U+3044. # The default value is: NO. ALLOW_UNICODE_NAMES = NO # The OUTPUT_LANGUAGE tag is used to specify the language in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all constant output in the proper language. # Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, # Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), # Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, # Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), # Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, # Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, # Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, # Ukrainian and Vietnamese. # The default value is: English. OUTPUT_LANGUAGE = English # If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member # descriptions after the members that are listed in the file and class # documentation (similar to Javadoc). Set to NO to disable this. # The default value is: YES. BRIEF_MEMBER_DESC = YES # If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief # description of a member or function before the detailed description # # Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the # brief descriptions will be completely suppressed. # The default value is: YES. REPEAT_BRIEF = YES # This tag implements a quasi-intelligent brief description abbreviator that is # used to form the text in various listings. Each string in this list, if found # as the leading text of the brief description, will be stripped from the text # and the result, after processing the whole list, is used as the annotated # text. Otherwise, the brief description is used as-is. If left blank, the # following values are used ($name is automatically replaced with the name of # the entity):The $name class, The $name widget, The $name file, is, provides, # specifies, contains, represents, a, an and the. ABBREVIATE_BRIEF = # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then # doxygen will generate a detailed section even if there is only a brief # description. # The default value is: NO. ALWAYS_DETAILED_SEC = NO # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all # inherited members of a class in the documentation of that class as if those # members were ordinary class members. Constructors, destructors and assignment # operators of the base classes will not be shown. # The default value is: NO. INLINE_INHERITED_MEMB = NO # If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path # before files name in the file list and in the header files. If set to NO the # shortest path that makes the file name unique will be used # The default value is: YES. FULL_PATH_NAMES = YES # The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. # Stripping is only done if one of the specified strings matches the left-hand # part of the path. The tag can be used to show relative paths in the file list. # If left blank the directory from which doxygen is run is used as the path to # strip. # # Note that you can specify absolute paths here, but also relative paths, which # will be relative from the directory where doxygen is started. # This tag requires that the tag FULL_PATH_NAMES is set to YES. STRIP_FROM_PATH = @CMAKE_SOURCE_DIR@ # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the # path mentioned in the documentation of a class, which tells the reader which # header file to include in order to use a class. If left blank only the name of # the header file containing the class definition is used. Otherwise one should # specify the list of include paths that are normally passed to the compiler # using the -I flag. STRIP_FROM_INC_PATH = # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but # less readable) file names. This can be useful is your file systems doesn't # support long names like on DOS, Mac, or CD-ROM. # The default value is: NO. SHORT_NAMES = NO # If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the # first line (until the first dot) of a Javadoc-style comment as the brief # description. If set to NO, the Javadoc-style will behave just like regular Qt- # style comments (thus requiring an explicit @brief command for a brief # description.) # The default value is: NO. JAVADOC_AUTOBRIEF = NO # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first # line (until the first dot) of a Qt-style comment as the brief description. If # set to NO, the Qt-style will behave just like regular Qt-style comments (thus # requiring an explicit \brief command for a brief description.) # The default value is: NO. QT_AUTOBRIEF = NO # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a # multi-line C++ special comment block (i.e. a block of //! or /// comments) as # a brief description. This used to be the default behavior. The new default is # to treat a multi-line C++ comment block as a detailed description. Set this # tag to YES if you prefer the old behavior instead. # # Note that setting this tag to YES also means that rational rose comments are # not recognized any more. # The default value is: NO. MULTILINE_CPP_IS_BRIEF = NO # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the # documentation from any documented member that it re-implements. # The default value is: YES. INHERIT_DOCS = YES # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a # new page for each member. If set to NO, the documentation of a member will be # part of the file/class/namespace that contains it. # The default value is: NO. SEPARATE_MEMBER_PAGES = NO # The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen # uses this value to replace tabs by spaces in code fragments. # Minimum value: 1, maximum value: 16, default value: 4. TAB_SIZE = 8 # This tag can be used to specify a number of aliases that act as commands in # the documentation. An alias has the form: # name=value # For example adding # "sideeffect=@par Side Effects:\n" # will allow you to put the command \sideeffect (or @sideeffect) in the # documentation, which will result in a user-defined paragraph with heading # "Side Effects:". You can put \n's in the value part of an alias to insert # newlines. ALIASES = # This tag can be used to specify a number of word-keyword mappings (TCL only). # A mapping has the form "name=value". For example adding "class=itcl::class" # will allow you to use the command class in the itcl::class meaning. TCL_SUBST = # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources # only. Doxygen will then generate output that is more tailored for C. For # instance, some of the names that are used will be different. The list of all # members will be omitted, etc. # The default value is: NO. OPTIMIZE_OUTPUT_FOR_C = YES # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or # Python sources only. Doxygen will then generate output that is more tailored # for that language. For instance, namespaces will be presented as packages, # qualified scopes will look different, etc. # The default value is: NO. OPTIMIZE_OUTPUT_JAVA = NO # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran # sources. Doxygen will then generate output that is tailored for Fortran. # The default value is: NO. OPTIMIZE_FOR_FORTRAN = NO # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL # sources. Doxygen will then generate output that is tailored for VHDL. # The default value is: NO. OPTIMIZE_OUTPUT_VHDL = NO # Doxygen selects the parser to use depending on the extension of the files it # parses. With this tag you can assign which parser to use for a given # extension. Doxygen has a built-in mapping, but you can override or extend it # using this tag. The format is ext=language, where ext is a file extension, and # language is one of the parsers supported by doxygen: IDL, Java, Javascript, # C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran: # FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran: # Fortran. In the later case the parser tries to guess whether the code is fixed # or free formatted code, this is the default for Fortran type files), VHDL. For # instance to make doxygen treat .inc files as Fortran files (default is PHP), # and .f files as C (default is Fortran), use: inc=Fortran f=C. # # Note For files without extension you can use no_extension as a placeholder. # # Note that for custom extensions you also need to set FILE_PATTERNS otherwise # the files are not read by doxygen. EXTENSION_MAPPING = # If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments # according to the Markdown format, which allows for more readable # documentation. See https://daringfireball.net/projects/markdown/ for details. # The output of markdown processing is further processed by doxygen, so you can # mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in # case of backward compatibilities issues. # The default value is: YES. MARKDOWN_SUPPORT = YES # When enabled doxygen tries to link words that correspond to documented # classes, or namespaces to their corresponding documentation. Such a link can # be prevented in individual cases by by putting a % sign in front of the word # or globally by setting AUTOLINK_SUPPORT to NO. # The default value is: YES. AUTOLINK_SUPPORT = YES # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want # to include (a tag file for) the STL sources as input, then you should set this # tag to YES in order to let doxygen match functions declarations and # definitions whose arguments contain STL classes (e.g. func(std::string); # versus func(std::string) {}). This also make the inheritance and collaboration # diagrams that involve STL classes more complete and accurate. # The default value is: NO. BUILTIN_STL_SUPPORT = NO # If you use Microsoft's C++/CLI language, you should set this option to YES to # enable parsing support. # The default value is: NO. CPP_CLI_SUPPORT = NO # Set the SIP_SUPPORT tag to YES if your project consists of sip (see: # https://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen # will parse them like normal C++ but will assume all classes use public instead # of private inheritance when no explicit protection keyword is present. # The default value is: NO. SIP_SUPPORT = NO # For Microsoft's IDL there are propget and propput attributes to indicate # getter and setter methods for a property. Setting this option to YES will make # doxygen to replace the get and set methods by a property in the documentation. # This will only work if the methods are indeed getting or setting a simple # type. If this is not the case, or you want to show the methods anyway, you # should set this option to NO. # The default value is: YES. IDL_PROPERTY_SUPPORT = YES # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC # tag is set to YES, then doxygen will reuse the documentation of the first # member in the group (if any) for the other members of the group. By default # all members of a group must be documented explicitly. # The default value is: NO. DISTRIBUTE_GROUP_DOC = NO # Set the SUBGROUPING tag to YES to allow class member groups of the same type # (for instance a group of public functions) to be put as a subgroup of that # type (e.g. under the Public Functions section). Set it to NO to prevent # subgrouping. Alternatively, this can be done per class using the # \nosubgrouping command. # The default value is: YES. SUBGROUPING = YES # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions # are shown inside the group in which they are included (e.g. using \ingroup) # instead of on a separate page (for HTML and Man pages) or section (for LaTeX # and RTF). # # Note that this feature does not work in combination with # SEPARATE_MEMBER_PAGES. # The default value is: NO. INLINE_GROUPED_CLASSES = NO # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions # with only public data fields or simple typedef fields will be shown inline in # the documentation of the scope in which they are defined (i.e. file, # namespace, or group documentation), provided this scope is documented. If set # to NO, structs, classes, and unions are shown on a separate page (for HTML and # Man pages) or section (for LaTeX and RTF). # The default value is: NO. INLINE_SIMPLE_STRUCTS = NO # When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or # enum is documented as struct, union, or enum with the name of the typedef. So # typedef struct TypeS {} TypeT, will appear in the documentation as a struct # with name TypeT. When disabled the typedef will appear as a member of a file, # namespace, or class. And the struct will be named TypeS. This can typically be # useful for C code in case the coding convention dictates that all compound # types are typedef'ed and only the typedef is referenced, never the tag name. # The default value is: NO. TYPEDEF_HIDES_STRUCT = NO # The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This # cache is used to resolve symbols given their name and scope. Since this can be # an expensive process and often the same symbol appears multiple times in the # code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small # doxygen will become slower. If the cache is too large, memory is wasted. The # cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range # is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 # symbols. At the end of a run doxygen will report the cache usage and suggest # the optimal cache size from a speed point of view. # Minimum value: 0, maximum value: 9, default value: 0. LOOKUP_CACHE_SIZE = 0 #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in # documentation are documented, even if no documentation was available. Private # class members and static file members will be hidden unless the # EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. # Note: This will also disable the warnings about undocumented members that are # normally produced when WARNINGS is set to YES. # The default value is: NO. EXTRACT_ALL = YES # If the EXTRACT_PRIVATE tag is set to YES all private members of a class will # be included in the documentation. # The default value is: NO. EXTRACT_PRIVATE = NO # If the EXTRACT_PACKAGE tag is set to YES all members with package or internal # scope will be included in the documentation. # The default value is: NO. EXTRACT_PACKAGE = NO # If the EXTRACT_STATIC tag is set to YES all static members of a file will be # included in the documentation. # The default value is: NO. EXTRACT_STATIC = YES # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined # locally in source files will be included in the documentation. If set to NO # only classes defined in header files are included. Does not have any effect # for Java sources. # The default value is: YES. EXTRACT_LOCAL_CLASSES = NO # This flag is only useful for Objective-C code. When set to YES local methods, # which are defined in the implementation section but not in the interface are # included in the documentation. If set to NO only methods in the interface are # included. # The default value is: NO. EXTRACT_LOCAL_METHODS = NO # If this flag is set to YES, the members of anonymous namespaces will be # extracted and appear in the documentation as a namespace called # 'anonymous_namespace{file}', where file will be replaced with the base name of # the file that contains the anonymous namespace. By default anonymous namespace # are hidden. # The default value is: NO. EXTRACT_ANON_NSPACES = NO # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all # undocumented members inside documented classes or files. If set to NO these # members will be included in the various overviews, but no documentation # section is generated. This option has no effect if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_MEMBERS = NO # If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all # undocumented classes that are normally visible in the class hierarchy. If set # to NO these classes will be included in the various overviews. This option has # no effect if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_CLASSES = NO # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend # (class|struct|union) declarations. If set to NO these declarations will be # included in the documentation. # The default value is: NO. HIDE_FRIEND_COMPOUNDS = NO # If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any # documentation blocks found inside the body of a function. If set to NO these # blocks will be appended to the function's detailed documentation block. # The default value is: NO. HIDE_IN_BODY_DOCS = NO # The INTERNAL_DOCS tag determines if documentation that is typed after a # \internal command is included. If the tag is set to NO then the documentation # will be excluded. Set it to YES to include the internal documentation. # The default value is: NO. INTERNAL_DOCS = NO # If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file # names in lower-case letters. If set to YES upper-case letters are also # allowed. This is useful if you have classes or files whose names only differ # in case and if your file system supports case sensitive file names. Windows # and Mac users are advised to set this option to NO. # The default value is: system dependent. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with # their full class and namespace scopes in the documentation. If set to YES the # scope will be hidden. # The default value is: NO. HIDE_SCOPE_NAMES = NO # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of # the files that are included by a file in the documentation of that file. # The default value is: YES. SHOW_INCLUDE_FILES = NO # If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each # grouped member an include statement to the documentation, telling the reader # which file to include in order to use the member. # The default value is: NO. SHOW_GROUPED_MEMB_INC = NO # If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include # files with double quotes in the documentation rather than with sharp brackets. # The default value is: NO. FORCE_LOCAL_INCLUDES = NO # If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the # documentation for inline members. # The default value is: YES. INLINE_INFO = YES # If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the # (detailed) documentation of file and class members alphabetically by member # name. If set to NO the members will appear in declaration order. # The default value is: YES. SORT_MEMBER_DOCS = YES # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief # descriptions of file, namespace and class members alphabetically by member # name. If set to NO the members will appear in declaration order. Note that # this will also influence the order of the classes in the class list. # The default value is: NO. SORT_BRIEF_DOCS = NO # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the # (brief and detailed) documentation of class members so that constructors and # destructors are listed first. If set to NO the constructors will appear in the # respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. # Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief # member documentation. # Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting # detailed member documentation. # The default value is: NO. SORT_MEMBERS_CTORS_1ST = NO # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy # of group names into alphabetical order. If set to NO the group names will # appear in their defined order. # The default value is: NO. SORT_GROUP_NAMES = NO # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by # fully-qualified names, including namespaces. If set to NO, the class list will # be sorted only by class name, not including the namespace part. # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. # Note: This option applies only to the class list, not to the alphabetical # list. # The default value is: NO. SORT_BY_SCOPE_NAME = NO # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper # type resolution of all parameters of a function it will reject a match between # the prototype and the implementation of a member function even if there is # only one candidate or it is obvious which candidate to choose by doing a # simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still # accept a match between prototype and implementation in such cases. # The default value is: NO. STRICT_PROTO_MATCHING = NO # The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the # todo list. This list is created by putting \todo commands in the # documentation. # The default value is: YES. GENERATE_TODOLIST = YES # The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the # test list. This list is created by putting \test commands in the # documentation. # The default value is: YES. GENERATE_TESTLIST = YES # The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug # list. This list is created by putting \bug commands in the documentation. # The default value is: YES. GENERATE_BUGLIST = YES # The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO) # the deprecated list. This list is created by putting \deprecated commands in # the documentation. # The default value is: YES. GENERATE_DEPRECATEDLIST= YES # The ENABLED_SECTIONS tag can be used to enable conditional documentation # sections, marked by \if ... \endif and \cond # ... \endcond blocks. ENABLED_SECTIONS = # The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the # initial value of a variable or macro / define can have for it to appear in the # documentation. If the initializer consists of more lines than specified here # it will be hidden. Use a value of 0 to hide initializers completely. The # appearance of the value of individual variables and macros / defines can be # controlled using \showinitializer or \hideinitializer command in the # documentation regardless of this setting. # Minimum value: 0, maximum value: 10000, default value: 30. MAX_INITIALIZER_LINES = 30 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated at # the bottom of the documentation of classes and structs. If set to YES the list # will mention the files that were used to generate the documentation. # The default value is: YES. SHOW_USED_FILES = YES # Set the SHOW_FILES tag to NO to disable the generation of the Files page. This # will remove the Files entry from the Quick Index and from the Folder Tree View # (if specified). # The default value is: YES. SHOW_FILES = YES # Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces # page. This will remove the Namespaces entry from the Quick Index and from the # Folder Tree View (if specified). # The default value is: YES. SHOW_NAMESPACES = YES # The FILE_VERSION_FILTER tag can be used to specify a program or script that # doxygen should invoke to get the current version for each file (typically from # the version control system). Doxygen will invoke the program by executing (via # popen()) the command command input-file, where command is the value of the # FILE_VERSION_FILTER tag, and input-file is the name of an input file provided # by doxygen. Whatever the program writes to standard output is used as the file # version. For an example see the documentation. FILE_VERSION_FILTER = # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed # by doxygen. The layout file controls the global structure of the generated # output files in an output format independent way. To create the layout file # that represents doxygen's defaults, run doxygen with the -l option. You can # optionally specify a file name after the option, if omitted DoxygenLayout.xml # will be used as the name of the layout file. # # Note that if you run doxygen from a directory containing a file called # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE # tag is left empty. LAYOUT_FILE = # The CITE_BIB_FILES tag can be used to specify one or more bib files containing # the reference definitions. This must be a list of .bib files. The .bib # extension is automatically appended if omitted. This requires the bibtex tool # to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info. # For LaTeX the style of the bibliography can be controlled using # LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the # search path. See also \cite for info how to create references. CITE_BIB_FILES = #--------------------------------------------------------------------------- # Configuration options related to warning and progress messages #--------------------------------------------------------------------------- # The QUIET tag can be used to turn on/off the messages that are generated to # standard output by doxygen. If QUIET is set to YES this implies that the # messages are off. # The default value is: NO. QUIET = NO # The WARNINGS tag can be used to turn on/off the warning messages that are # generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES # this implies that the warnings are on. # # Tip: Turn warnings on while writing the documentation. # The default value is: YES. WARNINGS = YES # If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate # warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag # will automatically be disabled. # The default value is: YES. WARN_IF_UNDOCUMENTED = YES # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for # potential errors in the documentation, such as not documenting some parameters # in a documented function, or documenting parameters that don't exist or using # markup commands wrongly. # The default value is: YES. WARN_IF_DOC_ERROR = YES # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that # are documented, but have no documentation for their parameters or return # value. If set to NO doxygen will only warn about wrong or incomplete parameter # documentation, but not about the absence of documentation. # The default value is: NO. WARN_NO_PARAMDOC = NO # The WARN_FORMAT tag determines the format of the warning messages that doxygen # can produce. The string should contain the $file, $line, and $text tags, which # will be replaced by the file and line number from which the warning originated # and the warning text. Optionally the format may contain $version, which will # be replaced by the version of the file (if it could be obtained via # FILE_VERSION_FILTER) # The default value is: $file:$line: $text. WARN_FORMAT = "$file:$line: $text" # The WARN_LOGFILE tag can be used to specify a file to which warning and error # messages should be written. If left blank the output is written to standard # error (stderr). WARN_LOGFILE = #--------------------------------------------------------------------------- # Configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag is used to specify the files and/or directories that contain # documented source files. You may enter file names like myfile.cpp or # directories like /usr/src/myproject. Separate the files or directories with # spaces. # Note: If this tag is empty the current directory is searched. INPUT = @CMAKE_SOURCE_DIR@ @CMAKE_BINARY_DIR@ # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses # libiconv (or the iconv built into libc) for the transcoding. See the libiconv # documentation (see: https://www.gnu.org/software/libiconv) for the list of # possible encodings. # The default value is: UTF-8. INPUT_ENCODING = UTF-8 # If the value of the INPUT tag contains directories, you can use the # FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and # *.h) to filter out the source-files in the directories. If left blank the # following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii, # *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, # *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, # *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, # *.qsf, *.as and *.js. FILE_PATTERNS = *.h \ *.md # The RECURSIVE tag can be used to specify whether or not subdirectories should # be searched for input files as well. # The default value is: NO. RECURSIVE = NO # The EXCLUDE tag can be used to specify files and/or directories that should be # excluded from the INPUT source files. This way you can easily exclude a # subdirectory from a directory tree whose root is specified with the INPUT tag. # # Note that relative paths are relative to the directory from which doxygen is # run. EXCLUDE = # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or # directories that are symbolic links (a Unix file system feature) are excluded # from the input. # The default value is: NO. EXCLUDE_SYMLINKS = NO # If the value of the INPUT tag contains directories, you can use the # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude # certain files from those directories. # # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories for example use the pattern */test/* EXCLUDE_PATTERNS = \ */json_object_private.h \ */debug.h \ */*config.h \ */random_seed.h \ */strerror_*h \ */*compat.h # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the # output. The symbol name can be a fully qualified name, a word, or if the # wildcard * is used, a substring. Examples: ANamespace, AClass, # AClass::ANamespace, ANamespace::*Test # # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories use the pattern */test/* EXCLUDE_SYMBOLS = \ _json_c_* \ _LH_* \ _printbuf_* \ __STRING # The EXAMPLE_PATH tag can be used to specify one or more files or directories # that contain example code fragments that are included (see the \include # command). EXAMPLE_PATH = # If the value of the EXAMPLE_PATH tag contains directories, you can use the # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and # *.h) to filter out the source-files in the directories. If left blank all # files are included. EXAMPLE_PATTERNS = # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be # searched for input files to be used with the \include or \dontinclude commands # irrespective of the value of the RECURSIVE tag. # The default value is: NO. EXAMPLE_RECURSIVE = NO # The IMAGE_PATH tag can be used to specify one or more files or directories # that contain images that are to be included in the documentation (see the # \image command). IMAGE_PATH = # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program # by executing (via popen()) the command: # # # # where is the value of the INPUT_FILTER tag, and is the # name of an input file. Doxygen will then use the output that the filter # program writes to standard output. If FILTER_PATTERNS is specified, this tag # will be ignored. # # Note that the filter must not add or remove lines; it is applied before the # code is scanned, but not when the output code is generated. If lines are added # or removed, the anchors will not be placed correctly. INPUT_FILTER = @CMAKE_CURRENT_SOURCE_DIR@/fixup_markdown.sh # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern # basis. Doxygen will compare the file name with each pattern and apply the # filter if there is a match. The filters are a list of the form: pattern=filter # (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how # filters are used. If the FILTER_PATTERNS tag is empty or if none of the # patterns match the file name, INPUT_FILTER is applied. FILTER_PATTERNS = # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using # INPUT_FILTER ) will also be used to filter the input files that are used for # producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). # The default value is: NO. FILTER_SOURCE_FILES = NO # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file # pattern. A pattern will override the setting for FILTER_PATTERN (if any) and # it is also possible to disable source filtering for a specific pattern using # *.ext= (so without naming a filter). # This tag requires that the tag FILTER_SOURCE_FILES is set to YES. FILTER_SOURCE_PATTERNS = # If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that # is part of the input, its contents will be placed on the main page # (index.html). This can be useful if you have a project on for instance GitHub # and want to reuse the introduction page also for the doxygen output. USE_MDFILE_AS_MAINPAGE = README.md #--------------------------------------------------------------------------- # Configuration options related to source browsing #--------------------------------------------------------------------------- # If the SOURCE_BROWSER tag is set to YES then a list of source files will be # generated. Documented entities will be cross-referenced with these sources. # # Note: To get rid of all source code in the generated output, make sure that # also VERBATIM_HEADERS is set to NO. # The default value is: NO. SOURCE_BROWSER = NO # Setting the INLINE_SOURCES tag to YES will include the body of functions, # classes and enums directly into the documentation. # The default value is: NO. INLINE_SOURCES = NO # Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any # special comment blocks from generated source code fragments. Normal C, C++ and # Fortran comments will always remain visible. # The default value is: YES. STRIP_CODE_COMMENTS = YES # If the REFERENCED_BY_RELATION tag is set to YES then for each documented # function all documented functions referencing it will be listed. # The default value is: NO. REFERENCED_BY_RELATION = YES # If the REFERENCES_RELATION tag is set to YES then for each documented function # all documented entities called/used by that function will be listed. # The default value is: NO. REFERENCES_RELATION = YES # If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set # to YES, then the hyperlinks from functions in REFERENCES_RELATION and # REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will # link to the documentation. # The default value is: YES. REFERENCES_LINK_SOURCE = YES # If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the # source code will show a tooltip with additional information such as prototype, # brief description and links to the definition and documentation. Since this # will make the HTML file larger and loading of large files a bit slower, you # can opt to disable this feature. # The default value is: YES. # This tag requires that the tag SOURCE_BROWSER is set to YES. SOURCE_TOOLTIPS = YES # If the USE_HTAGS tag is set to YES then the references to source code will # point to the HTML generated by the htags(1) tool instead of doxygen built-in # source browser. The htags tool is part of GNU's global source tagging system # (see https://www.gnu.org/software/global/global.html). You will need version # 4.8.6 or higher. # # To use it do the following: # - Install the latest version of global # - Enable SOURCE_BROWSER and USE_HTAGS in the config file # - Make sure the INPUT points to the root of the source tree # - Run doxygen as normal # # Doxygen will invoke htags (and that will in turn invoke gtags), so these # tools must be available from the command line (i.e. in the search path). # # The result: instead of the source browser generated by doxygen, the links to # source code will now point to the output of htags. # The default value is: NO. # This tag requires that the tag SOURCE_BROWSER is set to YES. USE_HTAGS = NO # If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a # verbatim copy of the header file for each class for which an include is # specified. Set to NO to disable this. # See also: Section \class. # The default value is: YES. VERBATIM_HEADERS = NO # If the CLANG_ASSISTED_PARSING tag is set to YES, then doxygen will use the # clang parser (see: https://clang.llvm.org/) for more accurate parsing at the # cost of reduced performance. This can be particularly helpful with template # rich C++ code for which doxygen's built-in parser lacks the necessary type # information. # Note: The availability of this option depends on whether or not doxygen was # compiled with the --with-libclang option. # The default value is: NO. #CLANG_ASSISTED_PARSING = NO # If clang assisted parsing is enabled you can provide the compiler with command # line options that you would normally use when invoking the compiler. Note that # the include paths will already be set by doxygen for the files and directories # specified with INPUT and INCLUDE_PATH. # This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES. #CLANG_OPTIONS = #--------------------------------------------------------------------------- # Configuration options related to the alphabetical class index #--------------------------------------------------------------------------- # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all # compounds will be generated. Enable this if the project contains a lot of # classes, structs, unions or interfaces. # The default value is: YES. ALPHABETICAL_INDEX = NO # The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in # which the alphabetical index list will be split. # Minimum value: 1, maximum value: 20, default value: 5. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. COLS_IN_ALPHA_INDEX = 5 # In case all classes in a project start with a common prefix, all classes will # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag # can be used to specify a prefix (or a list of prefixes) that should be ignored # while generating the index headers. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. IGNORE_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the HTML output #--------------------------------------------------------------------------- # If the GENERATE_HTML tag is set to YES doxygen will generate HTML output # The default value is: YES. GENERATE_HTML = YES # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of # it. # The default directory is: html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_OUTPUT = html # The HTML_FILE_EXTENSION tag can be used to specify the file extension for each # generated HTML page (for example: .htm, .php, .asp). # The default value is: .html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FILE_EXTENSION = .html # The HTML_HEADER tag can be used to specify a user-defined HTML header file for # each generated HTML page. If the tag is left blank doxygen will generate a # standard header. # # To get valid HTML the header file that includes any scripts and style sheets # that doxygen needs, which is dependent on the configuration options used (e.g. # the setting GENERATE_TREEVIEW). It is highly recommended to start with a # default header using # doxygen -w html new_header.html new_footer.html new_stylesheet.css # YourConfigFile # and then modify the file new_header.html. See also section "Doxygen usage" # for information on how to generate the default header that doxygen normally # uses. # Note: The header is subject to change so you typically have to regenerate the # default header when upgrading to a newer version of doxygen. For a description # of the possible markers and block names see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_HEADER = # The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each # generated HTML page. If the tag is left blank doxygen will generate a standard # footer. See HTML_HEADER for more information on how to generate a default # footer and what special commands can be used inside the footer. See also # section "Doxygen usage" for information on how to generate the default footer # that doxygen normally uses. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FOOTER = # The HTML_STYLESHEET tag can be used to specify a user-defined cascading style # sheet that is used by each HTML page. It can be used to fine-tune the look of # the HTML output. If left blank doxygen will generate a default style sheet. # See also section "Doxygen usage" for information on how to generate the style # sheet that doxygen normally uses. # Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as # it is more robust and this tag (HTML_STYLESHEET) will in the future become # obsolete. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_STYLESHEET = # The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined # cascading style sheets that are included after the standard style sheets # created by doxygen. Using this option one can overrule certain style aspects. # This is preferred over using HTML_STYLESHEET since it does not replace the # standard style sheet and is therefore more robust against future updates. # Doxygen will copy the style sheet files to the output directory. # Note: The order of the extra stylesheet files is of importance (e.g. the last # stylesheet in the list overrules the setting of the previous ones in the # list). For an example see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_STYLESHEET = # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or # other source files which should be copied to the HTML output directory. Note # that these files will be copied to the base HTML output directory. Use the # $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these # files. In the HTML_STYLESHEET file, use the file name only. Also note that the # files will be copied as-is; there are no commands or markers available. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_FILES = # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen # will adjust the colors in the stylesheet and background images according to # this color. Hue is specified as an angle on a colorwheel, see # https://en.wikipedia.org/wiki/Hue for more information. For instance the value # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 # purple, and 360 is red again. # Minimum value: 0, maximum value: 359, default value: 220. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_HUE = 220 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors # in the HTML output. For a value of 0 the output will use grayscales only. A # value of 255 will produce the most vivid colors. # Minimum value: 0, maximum value: 255, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_SAT = 100 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the # luminance component of the colors in the HTML output. Values below 100 # gradually make the output lighter, whereas values above 100 make the output # darker. The value divided by 100 is the actual gamma applied, so 80 represents # a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not # change the gamma. # Minimum value: 40, maximum value: 240, default value: 80. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_GAMMA = 80 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML # page will contain the date and time when the page was generated. Setting this # to NO can help when comparing the output of multiple runs. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_TIMESTAMP = YES # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML # documentation will contain sections that can be hidden and shown after the # page has loaded. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_DYNAMIC_SECTIONS = NO # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries # shown in the various tree structured indices initially; the user can expand # and collapse entries dynamically later on. Doxygen will expand the tree to # such a level that at most the specified number of entries are visible (unless # a fully collapsed tree already exceeds this amount). So setting the number of # entries 1 will produce a full collapsed tree by default. 0 is a special value # representing an infinite number of entries and will result in a full expanded # tree by default. # Minimum value: 0, maximum value: 9999, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_INDEX_NUM_ENTRIES = 100 # If the GENERATE_DOCSET tag is set to YES, additional index files will be # generated that can be used as input for Apple's Xcode 3 integrated development # environment (see: https://developer.apple.com/tools/xcode/), introduced with # OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a # Makefile in the HTML output directory. Running make will produce the docset in # that directory and running make install will install the docset in # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at # startup. See # https://developer.apple.com/library/archive/featuredarticles/DoxygenXcode/ # for more information. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_DOCSET = NO # This tag determines the name of the docset feed. A documentation feed provides # an umbrella under which multiple documentation sets from a single provider # (such as a company or product suite) can be grouped. # The default value is: Doxygen generated docs. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_FEEDNAME = "Doxygen generated docs" # This tag specifies a string that should uniquely identify the documentation # set bundle. This should be a reverse domain-name style string, e.g. # com.mycompany.MyDocSet. Doxygen will append .docset to the name. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_BUNDLE_ID = org.doxygen.Project # The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify # the documentation publisher. This should be a reverse domain-name style # string, e.g. com.mycompany.MyDocSet.documentation. # The default value is: org.doxygen.Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_ID = org.doxygen.Publisher # The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. # The default value is: Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_NAME = Publisher # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three # additional HTML index files: index.hhp, index.hhc, and index.hhk. The # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop # (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on # Windows. # # The HTML Help Workshop contains a compiler that can convert all HTML output # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML # files are now used as the Windows 98 help format, and will replace the old # Windows help format (.hlp) on all Windows platforms in the future. Compressed # HTML files also contain an index, a table of contents, and you can search for # words in the documentation. The HTML workshop also contains a viewer for # compressed HTML files. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_HTMLHELP = NO # The CHM_FILE tag can be used to specify the file name of the resulting .chm # file. You can add a path in front of the file if the result should not be # written to the html output directory. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_FILE = # The HHC_LOCATION tag can be used to specify the location (absolute path # including file name) of the HTML help compiler ( hhc.exe). If non-empty # doxygen will try to run the HTML help compiler on the generated index.hhp. # The file has to be specified with full path. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. HHC_LOCATION = # The GENERATE_CHI flag controls if a separate .chi index file is generated ( # YES) or that it should be included in the master .chm file ( NO). # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. GENERATE_CHI = NO # The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc) # and project file content. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_INDEX_ENCODING = # The BINARY_TOC flag controls whether a binary table of contents is generated ( # YES) or a normal table of contents ( NO) in the .chm file. Furthermore it # enables the Previous and Next buttons. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members to # the table of contents of the HTML help documentation and to the tree view. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. TOC_EXPAND = NO # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that # can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help # (.qch) of the generated HTML documentation. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_QHP = NO # If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify # the file name of the resulting .qch file. The path specified is relative to # the HTML output folder. # This tag requires that the tag GENERATE_QHP is set to YES. QCH_FILE = # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help # Project output. For more information please see Qt Help Project / Namespace # (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace). # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_NAMESPACE = org.doxygen.Project # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt # Help Project output. For more information please see Qt Help Project / Virtual # Folders (see: # https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-folders). # The default value is: doc. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_VIRTUAL_FOLDER = doc # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom # filter to add. For more information please see Qt Help Project / Custom # Filters (see: # https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_NAME = # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the # custom filter to add. For more information please see Qt Help Project / Custom # Filters (see: # https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_ATTRS = # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this # project's filter section matches. Qt Help Project / Filter Attributes (see: # https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_SECT_FILTER_ATTRS = # The QHG_LOCATION tag can be used to specify the location of Qt's # qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the # generated .qhp file. # This tag requires that the tag GENERATE_QHP is set to YES. QHG_LOCATION = # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be # generated, together with the HTML files, they form an Eclipse help plugin. To # install this plugin and make it available under the help contents menu in # Eclipse, the contents of the directory containing the HTML and XML files needs # to be copied into the plugins directory of eclipse. The name of the directory # within the plugins directory should be the same as the ECLIPSE_DOC_ID value. # After copying Eclipse needs to be restarted before the help appears. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_ECLIPSEHELP = NO # A unique identifier for the Eclipse help plugin. When installing the plugin # the directory name containing the HTML and XML files should also have this # name. Each documentation set should have its own identifier. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. ECLIPSE_DOC_ID = org.doxygen.Project # If you want full control over the layout of the generated HTML pages it might # be necessary to disable the index and replace it with your own. The # DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top # of each HTML page. A value of NO enables the index and the value YES disables # it. Since the tabs in the index contain the same information as the navigation # tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. DISABLE_INDEX = NO # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index # structure should be generated to display hierarchical information. If the tag # value is set to YES, a side panel will be generated containing a tree-like # index structure (just like the one that is generated for HTML Help). For this # to work a browser that supports JavaScript, DHTML, CSS and frames is required # (i.e. any modern browser). Windows users are probably better off using the # HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can # further fine-tune the look of the index. As an example, the default style # sheet generated by doxygen has an example that shows how to put an image at # the root of the tree instead of the PROJECT_NAME. Since the tree basically has # the same information as the tab index, you could consider setting # DISABLE_INDEX to YES when enabling this option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_TREEVIEW = NO # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that # doxygen will group on one line in the generated HTML documentation. # # Note that a value of 0 will completely suppress the enum values from appearing # in the overview section. # Minimum value: 0, maximum value: 20, default value: 4. # This tag requires that the tag GENERATE_HTML is set to YES. ENUM_VALUES_PER_LINE = 4 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used # to set the initial width (in pixels) of the frame in which the tree is shown. # Minimum value: 0, maximum value: 1500, default value: 250. # This tag requires that the tag GENERATE_HTML is set to YES. TREEVIEW_WIDTH = 250 # When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to # external symbols imported via tag files in a separate window. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. EXT_LINKS_IN_WINDOW = NO # Use this tag to change the font size of LaTeX formulas included as images in # the HTML documentation. When you change the font size after a successful # doxygen run you need to manually remove any form_*.png images from the HTML # output directory to force them to be regenerated. # Minimum value: 8, maximum value: 50, default value: 10. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_FONTSIZE = 10 # Use the FORMULA_TRANPARENT tag to determine whether or not the images # generated for formulas are transparent PNGs. Transparent PNGs are not # supported properly for IE 6.0, but are supported on all modern browsers. # # Note that when changing this option you need to delete any form_*.png files in # the HTML output directory before the changes have effect. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_TRANSPARENT = YES # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see # https://www.mathjax.org) which uses client side Javascript for the rendering # instead of using prerendered bitmaps. Use this if you do not have LaTeX # installed or if you want to formulas look prettier in the HTML output. When # enabled you may also need to install MathJax separately and configure the path # to it using the MATHJAX_RELPATH option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. USE_MATHJAX = NO # When MathJax is enabled you can set the default output format to be used for # the MathJax output. See the MathJax site (see: # https://docs.mathjax.org/en/latest/output/) for more details. # Possible values are: HTML-CSS (which is slower, but has the best # compatibility), NativeMML (i.e. MathML) and SVG. # The default value is: HTML-CSS. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_FORMAT = HTML-CSS # When MathJax is enabled you need to specify the location relative to the HTML # output directory using the MATHJAX_RELPATH option. The destination directory # should contain the MathJax.js script. For instance, if the mathjax directory # is located at the same level as the HTML output directory, then # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax # Content Delivery Network so you can quickly see the result without installing # MathJax. However, it is strongly recommended to install a local copy of # MathJax from https://www.mathjax.org before deployment. # The default value is: https://cdn.mathjax.org/mathjax/latest. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_RELPATH = https://cdn.mathjax.org/mathjax/latest # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax # extension names that should be enabled during MathJax rendering. For example # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_EXTENSIONS = # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces # of code that will be used on startup of the MathJax code. See the MathJax site # (see: https://docs.mathjax.org/en/latest/output/) for more details. For an # example see the documentation. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_CODEFILE = # When the SEARCHENGINE tag is enabled doxygen will generate a search box for # the HTML output. The underlying search engine uses javascript and DHTML and # should work on any modern browser. Note that when using HTML help # (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) # there is already a search function so this one should typically be disabled. # For large projects the javascript based search engine can be slow, then # enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to # search using the keyboard; to jump to the search box use + S # (what the is depends on the OS and browser, but it is typically # , /
README.md File Reference
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/annotated.html000066400000000000000000000114451446575330000213100ustar00rootroot00000000000000 json-c: Data Structures
Data Structures
Here are the data structures with brief descriptions:
oCarray_list
oCjson_object_iter
oCjson_object_iterator
oCjson_patch_error
oCjson_pointer_get_result
oCjson_tokener
oCjson_tokener_srec
oClh_entry
oClh_table
\Cprintbuf
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/arraylist_8h.html000066400000000000000000000545151446575330000217510ustar00rootroot00000000000000 json-c: arraylist.h File Reference
Data Structures | Macros | Typedefs | Functions
arraylist.h File Reference

Internal methods for working with json_type_array objects. Although this is exposed by the json_object_get_array() method, it is not recommended for direct use. More...

Data Structures

struct  array_list
 

Macros

#define ARRAY_LIST_DEFAULT_SIZE   32
 

Typedefs

typedef void( array_list_free_fn )(void *data)
 
typedef struct array_list array_list
 

Functions

struct array_list * array_list_new (array_list_free_fn *free_fn)
 
struct array_list * array_list_new2 (array_list_free_fn *free_fn, int initial_size)
 
void array_list_free (struct array_list *al)
 
void * array_list_get_idx (struct array_list *al, size_t i)
 
int array_list_insert_idx (struct array_list *al, size_t i, void *data)
 
int array_list_put_idx (struct array_list *al, size_t i, void *data)
 
int array_list_add (struct array_list *al, void *data)
 
size_t array_list_length (struct array_list *al)
 
void array_list_sort (struct array_list *arr, int(*compar)(const void *, const void *))
 
void * array_list_bsearch (const void **key, struct array_list *arr, int(*compar)(const void *, const void *))
 
int array_list_del_idx (struct array_list *arr, size_t idx, size_t count)
 
int array_list_shrink (struct array_list *arr, size_t empty_slots)
 

Detailed Description

Internal methods for working with json_type_array objects. Although this is exposed by the json_object_get_array() method, it is not recommended for direct use.

Macro Definition Documentation

#define ARRAY_LIST_DEFAULT_SIZE   32

Typedef Documentation

typedef struct array_list array_list
typedef void( array_list_free_fn)(void *data)

Function Documentation

int array_list_add ( struct array_list *  al,
void *  data 
)
void* array_list_bsearch ( const void **  key,
struct array_list *  arr,
int(*)(const void *, const void *)  compar 
)
int array_list_del_idx ( struct array_list *  arr,
size_t  idx,
size_t  count 
)
void array_list_free ( struct array_list *  al)
void* array_list_get_idx ( struct array_list *  al,
size_t  i 
)
int array_list_insert_idx ( struct array_list *  al,
size_t  i,
void *  data 
)
size_t array_list_length ( struct array_list *  al)
struct array_list* array_list_new ( array_list_free_fn *  free_fn)
read

Allocate an array_list of the default size (32).

Deprecated:
Use array_list_new2() instead.
struct array_list* array_list_new2 ( array_list_free_fn *  free_fn,
int  initial_size 
)
read

Allocate an array_list of the desired size.

If possible, the size should be chosen to closely match the actual number of elements expected to be used. If the exact size is unknown, there are tradeoffs to be made:

  • too small - the array_list code will need to call realloc() more often (which might incur an additional memory copy).
  • too large - will waste memory, but that can be mitigated by calling array_list_shrink() once the final size is known.
See Also
array_list_shrink
int array_list_put_idx ( struct array_list *  al,
size_t  i,
void *  data 
)
int array_list_shrink ( struct array_list *  arr,
size_t  empty_slots 
)

Shrink the array list to just enough to fit the number of elements in it, plus empty_slots.

void array_list_sort ( struct array_list *  arr,
int(*)(const void *, const void *)  compar 
)
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/bc_s.png000066400000000000000000000012441446575330000200550ustar00rootroot00000000000000PNG  IHDR_ kIDATxkQϝ̤I&m&156*nąܸR,4 +H(Ub1J.(EmߏhJmKS'C(х & r3g(z&_9}՟@mu ` h`ԯ &~M4%3?h)\Yi>Jb @giވkg\轭EUv+?E"pB\Y&$vM+Dn)}:Xo 3گ'.f0u9Ljf6%3Gf#sm(,k*ʒJJˢou_~ r]%%mnu]zr5[ưXeI+ Kch` ^ލnIENDB`json-c-json-c-0.17-20230812/doc/html/classes.html000066400000000000000000000110651446575330000207660ustar00rootroot00000000000000 json-c: Data Structure Index
Data Structure Index
A | J | L | P
  A  
json_object_iterator   json_tokener_srec   lh_table   
json_patch_error   
  L  
  P  
array_list   json_pointer_get_result   
  J  
json_tokener   lh_entry   printbuf   
json_object_iter   
A | J | L | P
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/closed.png000066400000000000000000000002041446575330000204130ustar00rootroot00000000000000PNG  IHDR KIDATxm @!Gk7-`&sts@k}2 P%_N .:0Dk›x" ֛)x5IENDB`json-c-json-c-0.17-20230812/doc/html/deprecated.html000066400000000000000000000160071446575330000214320ustar00rootroot00000000000000 json-c: Deprecated List
Deprecated List
Global array_list_new (array_list_free_fn *free_fn)
Use array_list_new2() instead.
Global json_parse_double (const char *buf, double *retval)
Global json_tokener
Unused in json-c code
Global json_tokener::char_offset
See json_tokener_get_parse_end() instead.
Global json_tokener::err
See json_tokener_get_error() instead.
Global json_tokener::str
Do not access any of these fields outside of json_tokener.c
Class json_tokener_srec
Don't use this outside of json_tokener.c, it will be made private in a future release.
Global json_tokener_state
Don't use this outside of json_tokener.c, it will be made private in a future release.
Global lh_entry::k
Use lh_entry_k() instead of accessing this directly.
Global lh_entry::k_is_constant
use lh_entry_k_is_constant() instead.
Global lh_entry::next
Use lh_entry_next() instead of accessing this directly.
Global lh_entry::prev
Use lh_entry_prev() instead of accessing this directly.
Global lh_entry::v
Use lh_entry_v() instead of accessing this directly.
Global lh_table::count
Use lh_table_length() instead.
Global lh_table::equal_fn
do not use outside of linkhash.c
Global lh_table::free_fn
do not use outside of linkhash.c
Global lh_table::hash_fn
do not use outside of linkhash.c
Global lh_table::head
Use lh_table_head() instead.
Global lh_table::size
do not use outside of linkhash.c
Global lh_table::table
do not use outside of linkhash.c
Global lh_table::tail
Do not use, may be removed in a future release.
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/dir_b62156a74b5a818be0c2ef9f85294b95.html000066400000000000000000000050261446575330000245030ustar00rootroot00000000000000 json-c: /home/erh/distcheck Directory Reference
distcheck Directory Reference

Files

file  json.h
 A convenience header that may be included instead of other individual ones.
 
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/doxygen.css000066400000000000000000000474031446575330000206370ustar00rootroot00000000000000/* The standard CSS for doxygen */ body, table, div, p, dl { font: 400 14px/19px Roboto,sans-serif; } /* @group Heading Levels */ h1.groupheader { font-size: 150%; } .title { font-size: 150%; font-weight: bold; margin: 10px 2px; } h2.groupheader { border-bottom: 1px solid #879ECB; color: #354C7B; font-size: 150%; font-weight: normal; margin-top: 1.75em; padding-top: 8px; padding-bottom: 4px; width: 100%; } h3.groupheader { font-size: 100%; } h1, h2, h3, h4, h5, h6 { -webkit-transition: text-shadow 0.5s linear; -moz-transition: text-shadow 0.5s linear; -ms-transition: text-shadow 0.5s linear; -o-transition: text-shadow 0.5s linear; transition: text-shadow 0.5s linear; margin-right: 15px; } h1.glow, h2.glow, h3.glow, h4.glow, h5.glow, h6.glow { text-shadow: 0 0 15px cyan; } dt { font-weight: bold; } div.multicol { -moz-column-gap: 1em; -webkit-column-gap: 1em; -moz-column-count: 3; -webkit-column-count: 3; } p.startli, p.startdd, p.starttd { margin-top: 2px; } p.endli { margin-bottom: 0px; } p.enddd { margin-bottom: 4px; } p.endtd { margin-bottom: 2px; } /* @end */ caption { font-weight: bold; } span.legend { font-size: 70%; text-align: center; } h3.version { font-size: 90%; text-align: center; } div.qindex, div.navtab{ background-color: #EBEFF6; border: 1px solid #A3B4D7; text-align: center; } div.qindex, div.navpath { width: 100%; line-height: 140%; } div.navtab { margin-right: 15px; } /* @group Link Styling */ a { color: #3D578C; font-weight: normal; text-decoration: none; } .contents a:visited { color: #4665A2; } a:hover { text-decoration: underline; } a.qindex { font-weight: bold; } a.qindexHL { font-weight: bold; background-color: #9CAFD4; color: #ffffff; border: 1px double #869DCA; } .contents a.qindexHL:visited { color: #ffffff; } a.el { font-weight: bold; } a.elRef { } a.code, a.code:visited { color: #4665A2; } a.codeRef, a.codeRef:visited { color: #4665A2; } /* @end */ dl.el { margin-left: -1cm; } pre.fragment { border: 1px solid #C4CFE5; background-color: #FBFCFD; padding: 4px 6px; margin: 4px 8px 4px 2px; overflow: auto; word-wrap: break-word; font-size: 9pt; line-height: 125%; font-family: monospace, fixed; font-size: 105%; } div.fragment { padding: 4px; margin: 4px; background-color: #FBFCFD; border: 1px solid #C4CFE5; } div.line { font-family: monospace, fixed; font-size: 13px; min-height: 13px; line-height: 1.0; text-wrap: unrestricted; white-space: -moz-pre-wrap; /* Moz */ white-space: -pre-wrap; /* Opera 4-6 */ white-space: -o-pre-wrap; /* Opera 7 */ white-space: pre-wrap; /* CSS3 */ word-wrap: break-word; /* IE 5.5+ */ text-indent: -53px; padding-left: 53px; padding-bottom: 0px; margin: 0px; -webkit-transition-property: background-color, box-shadow; -webkit-transition-duration: 0.5s; -moz-transition-property: background-color, box-shadow; -moz-transition-duration: 0.5s; -ms-transition-property: background-color, box-shadow; -ms-transition-duration: 0.5s; -o-transition-property: background-color, box-shadow; -o-transition-duration: 0.5s; transition-property: background-color, box-shadow; transition-duration: 0.5s; } div.line.glow { background-color: cyan; box-shadow: 0 0 10px cyan; } span.lineno { padding-right: 4px; text-align: right; border-right: 2px solid #0F0; background-color: #E8E8E8; white-space: pre; } span.lineno a { background-color: #D8D8D8; } span.lineno a:hover { background-color: #C8C8C8; } div.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px; padding: 0.2em; border: solid thin #333; border-radius: 0.5em; -webkit-border-radius: .5em; -moz-border-radius: .5em; box-shadow: 2px 2px 3px #999; -webkit-box-shadow: 2px 2px 3px #999; -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px; background-image: -webkit-gradient(linear, left top, left bottom, from(#eee), to(#000),color-stop(0.3, #444)); background-image: -moz-linear-gradient(center top, #eee 0%, #444 40%, #000); } div.groupHeader { margin-left: 16px; margin-top: 12px; font-weight: bold; } div.groupText { margin-left: 16px; font-style: italic; } body { background-color: white; color: black; margin: 0; } div.contents { margin-top: 10px; margin-left: 12px; margin-right: 8px; } td.indexkey { background-color: #EBEFF6; font-weight: bold; border: 1px solid #C4CFE5; margin: 2px 0px 2px 0; padding: 2px 10px; white-space: nowrap; vertical-align: top; } td.indexvalue { background-color: #EBEFF6; border: 1px solid #C4CFE5; padding: 2px 10px; margin: 2px 0px; } tr.memlist { background-color: #EEF1F7; } p.formulaDsp { text-align: center; } img.formulaDsp { } img.formulaInl { vertical-align: middle; } div.center { text-align: center; margin-top: 0px; margin-bottom: 0px; padding: 0px; } div.center img { border: 0px; } address.footer { text-align: right; padding-right: 12px; } img.footer { border: 0px; vertical-align: middle; } /* @group Code Colorization */ span.keyword { color: #008000 } span.keywordtype { color: #604020 } span.keywordflow { color: #e08000 } span.comment { color: #800000 } span.preprocessor { color: #806020 } span.stringliteral { color: #002080 } span.charliteral { color: #008080 } span.vhdldigit { color: #ff00ff } span.vhdlchar { color: #000000 } span.vhdlkeyword { color: #700070 } span.vhdllogic { color: #ff0000 } blockquote { background-color: #F7F8FB; border-left: 2px solid #9CAFD4; margin: 0 24px 0 4px; padding: 0 12px 0 16px; } /* @end */ /* .search { color: #003399; font-weight: bold; } form.search { margin-bottom: 0px; margin-top: 0px; } input.search { font-size: 75%; color: #000080; font-weight: normal; background-color: #e8eef2; } */ td.tiny { font-size: 75%; } .dirtab { padding: 4px; border-collapse: collapse; border: 1px solid #A3B4D7; } th.dirtab { background: #EBEFF6; font-weight: bold; } hr { height: 0px; border: none; border-top: 1px solid #4A6AAA; } hr.footer { height: 1px; } /* @group Member Descriptions */ table.memberdecls { border-spacing: 0px; padding: 0px; } .memberdecls td, .fieldtable tr { -webkit-transition-property: background-color, box-shadow; -webkit-transition-duration: 0.5s; -moz-transition-property: background-color, box-shadow; -moz-transition-duration: 0.5s; -ms-transition-property: background-color, box-shadow; -ms-transition-duration: 0.5s; -o-transition-property: background-color, box-shadow; -o-transition-duration: 0.5s; transition-property: background-color, box-shadow; transition-duration: 0.5s; } .memberdecls td.glow, .fieldtable tr.glow { background-color: cyan; box-shadow: 0 0 15px cyan; } .mdescLeft, .mdescRight, .memItemLeft, .memItemRight, .memTemplItemLeft, .memTemplItemRight, .memTemplParams { background-color: #F9FAFC; border: none; margin: 4px; padding: 1px 0 0 8px; } .mdescLeft, .mdescRight { padding: 0px 8px 4px 8px; color: #555; } .memSeparator { border-bottom: 1px solid #DEE4F0; line-height: 1px; margin: 0px; padding: 0px; } .memItemLeft, .memTemplItemLeft { white-space: nowrap; } .memItemRight { width: 100%; } .memTemplParams { color: #4665A2; white-space: nowrap; font-size: 80%; } /* @end */ /* @group Member Details */ /* Styles for detailed member documentation */ .memtemplate { font-size: 80%; color: #4665A2; font-weight: normal; margin-left: 9px; } .memnav { background-color: #EBEFF6; border: 1px solid #A3B4D7; text-align: center; margin: 2px; margin-right: 15px; padding: 2px; } .mempage { width: 100%; } .memitem { padding: 0; margin-bottom: 10px; margin-right: 5px; -webkit-transition: box-shadow 0.5s linear; -moz-transition: box-shadow 0.5s linear; -ms-transition: box-shadow 0.5s linear; -o-transition: box-shadow 0.5s linear; transition: box-shadow 0.5s linear; display: table !important; width: 100%; } .memitem.glow { box-shadow: 0 0 15px cyan; } .memname { font-weight: bold; margin-left: 6px; } .memname td { vertical-align: bottom; } .memproto, dl.reflist dt { border-top: 1px solid #A8B8D9; border-left: 1px solid #A8B8D9; border-right: 1px solid #A8B8D9; padding: 6px 0px 6px 0px; color: #253555; font-weight: bold; text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); background-image:url('nav_f.png'); background-repeat:repeat-x; background-color: #E2E8F2; /* opera specific markup */ box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); border-top-right-radius: 4px; border-top-left-radius: 4px; /* firefox specific markup */ -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px; -moz-border-radius-topright: 4px; -moz-border-radius-topleft: 4px; /* webkit specific markup */ -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); -webkit-border-top-right-radius: 4px; -webkit-border-top-left-radius: 4px; } .memdoc, dl.reflist dd { border-bottom: 1px solid #A8B8D9; border-left: 1px solid #A8B8D9; border-right: 1px solid #A8B8D9; padding: 6px 10px 2px 10px; background-color: #FBFCFD; border-top-width: 0; background-image:url('nav_g.png'); background-repeat:repeat-x; background-color: #FFFFFF; /* opera specific markup */ border-bottom-left-radius: 4px; border-bottom-right-radius: 4px; box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); /* firefox specific markup */ -moz-border-radius-bottomleft: 4px; -moz-border-radius-bottomright: 4px; -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px; /* webkit specific markup */ -webkit-border-bottom-left-radius: 4px; -webkit-border-bottom-right-radius: 4px; -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15); } dl.reflist dt { padding: 5px; } dl.reflist dd { margin: 0px 0px 10px 0px; padding: 5px; } .paramkey { text-align: right; } .paramtype { white-space: nowrap; } .paramname { color: #602020; white-space: nowrap; } .paramname em { font-style: normal; } .paramname code { line-height: 14px; } .params, .retval, .exception, .tparams { margin-left: 0px; padding-left: 0px; } .params .paramname, .retval .paramname { font-weight: bold; vertical-align: top; } .params .paramtype { font-style: italic; vertical-align: top; } .params .paramdir { font-family: "courier new",courier,monospace; vertical-align: top; } table.mlabels { border-spacing: 0px; } td.mlabels-left { width: 100%; padding: 0px; } td.mlabels-right { vertical-align: bottom; padding: 0px; white-space: nowrap; } span.mlabels { margin-left: 8px; } span.mlabel { background-color: #728DC1; border-top:1px solid #5373B4; border-left:1px solid #5373B4; border-right:1px solid #C4CFE5; border-bottom:1px solid #C4CFE5; text-shadow: none; color: white; margin-right: 4px; padding: 2px 3px; border-radius: 3px; font-size: 7pt; white-space: nowrap; vertical-align: middle; } /* @end */ /* these are for tree view when not used as main index */ div.directory { margin: 10px 0px; border-top: 1px solid #A8B8D9; border-bottom: 1px solid #A8B8D9; width: 100%; } .directory table { border-collapse:collapse; } .directory td { margin: 0px; padding: 0px; vertical-align: top; } .directory td.entry { white-space: nowrap; padding-right: 6px; } .directory td.entry a { outline:none; } .directory td.entry a img { border: none; } .directory td.desc { width: 100%; padding-left: 6px; padding-right: 6px; padding-top: 3px; border-left: 1px solid rgba(0,0,0,0.05); } .directory tr.even { padding-left: 6px; background-color: #F7F8FB; } .directory img { vertical-align: -30%; } .directory .levels { white-space: nowrap; width: 100%; text-align: right; font-size: 9pt; } .directory .levels span { cursor: pointer; padding-left: 2px; padding-right: 2px; color: #3D578C; } div.dynheader { margin-top: 8px; -webkit-touch-callout: none; -webkit-user-select: none; -khtml-user-select: none; -moz-user-select: none; -ms-user-select: none; user-select: none; } address { font-style: normal; color: #2A3D61; } table.doxtable { border-collapse:collapse; margin-top: 4px; margin-bottom: 4px; } table.doxtable td, table.doxtable th { border: 1px solid #2D4068; padding: 3px 7px 2px; } table.doxtable th { background-color: #374F7F; color: #FFFFFF; font-size: 110%; padding-bottom: 4px; padding-top: 5px; } table.fieldtable { width: 100%; margin-bottom: 10px; border: 1px solid #A8B8D9; border-spacing: 0px; -moz-border-radius: 4px; -webkit-border-radius: 4px; border-radius: 4px; -moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px; -webkit-box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15); box-shadow: 2px 2px 2px rgba(0, 0, 0, 0.15); } .fieldtable td, .fieldtable th { padding: 3px 7px 2px; } .fieldtable td.fieldtype, .fieldtable td.fieldname { white-space: nowrap; border-right: 1px solid #A8B8D9; border-bottom: 1px solid #A8B8D9; vertical-align: top; } .fieldtable td.fielddoc { border-bottom: 1px solid #A8B8D9; width: 100%; } .fieldtable tr:last-child td { border-bottom: none; } .fieldtable th { background-image:url('nav_f.png'); background-repeat:repeat-x; background-color: #E2E8F2; font-size: 90%; color: #253555; padding-bottom: 4px; padding-top: 5px; text-align:left; -moz-border-radius-topleft: 4px; -moz-border-radius-topright: 4px; -webkit-border-top-left-radius: 4px; -webkit-border-top-right-radius: 4px; border-top-left-radius: 4px; border-top-right-radius: 4px; border-bottom: 1px solid #A8B8D9; } .tabsearch { top: 0px; left: 10px; height: 36px; background-image: url('tab_b.png'); z-index: 101; overflow: hidden; font-size: 13px; } .navpath ul { font-size: 11px; background-image:url('tab_b.png'); background-repeat:repeat-x; background-position: 0 -5px; height:30px; line-height:30px; color:#8AA0CC; border:solid 1px #C2CDE4; overflow:hidden; margin:0px; padding:0px; } .navpath li { list-style-type:none; float:left; padding-left:10px; padding-right:15px; background-image:url('bc_s.png'); background-repeat:no-repeat; background-position:right; color:#364D7C; } .navpath li.navelem a { height:32px; display:block; text-decoration: none; outline: none; color: #283A5D; font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif; text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); text-decoration: none; } .navpath li.navelem a:hover { color:#6884BD; } .navpath li.footer { list-style-type:none; float:right; padding-left:10px; padding-right:15px; background-image:none; background-repeat:no-repeat; background-position:right; color:#364D7C; font-size: 8pt; } div.summary { float: right; font-size: 8pt; padding-right: 5px; width: 50%; text-align: right; } div.summary a { white-space: nowrap; } div.ingroups { font-size: 8pt; width: 50%; text-align: left; } div.ingroups a { white-space: nowrap; } div.header { background-image:url('nav_h.png'); background-repeat:repeat-x; background-color: #F9FAFC; margin: 0px; border-bottom: 1px solid #C4CFE5; } div.headertitle { padding: 5px 5px 5px 10px; } dl { padding: 0 0 0 10px; } /* dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug */ dl.section { margin-left: 0px; padding-left: 0px; } dl.note { margin-left:-7px; padding-left: 3px; border-left:4px solid; border-color: #D0C000; } dl.warning, dl.attention { margin-left:-7px; padding-left: 3px; border-left:4px solid; border-color: #FF0000; } dl.pre, dl.post, dl.invariant { margin-left:-7px; padding-left: 3px; border-left:4px solid; border-color: #00D000; } dl.deprecated { margin-left:-7px; padding-left: 3px; border-left:4px solid; border-color: #505050; } dl.todo { margin-left:-7px; padding-left: 3px; border-left:4px solid; border-color: #00C0E0; } dl.test { margin-left:-7px; padding-left: 3px; border-left:4px solid; border-color: #3030E0; } dl.bug { margin-left:-7px; padding-left: 3px; border-left:4px solid; border-color: #C08050; } dl.section dd { margin-bottom: 6px; } #projectlogo { text-align: center; vertical-align: bottom; border-collapse: separate; } #projectlogo img { border: 0px none; } #projectname { font: 300% Tahoma, Arial,sans-serif; margin: 0px; padding: 2px 0px; } #projectbrief { font: 120% Tahoma, Arial,sans-serif; margin: 0px; padding: 0px; } #projectnumber { font: 50% Tahoma, Arial,sans-serif; margin: 0px; padding: 0px; } #titlearea { padding: 0px; margin: 0px; width: 100%; border-bottom: 1px solid #5373B4; } .image { text-align: center; } .dotgraph { text-align: center; } .mscgraph { text-align: center; } .caption { font-weight: bold; } div.zoom { border: 1px solid #90A5CE; } dl.citelist { margin-bottom:50px; } dl.citelist dt { color:#334975; float:left; font-weight:bold; margin-right:10px; padding:5px; } dl.citelist dd { margin:2px 0; padding:5px 0; } div.toc { padding: 14px 25px; background-color: #F4F6FA; border: 1px solid #D8DFEE; border-radius: 7px 7px 7px 7px; float: right; height: auto; margin: 0 20px 10px 10px; width: 200px; } div.toc li { background: url("bdwn.png") no-repeat scroll 0 5px transparent; font: 10px/1.2 Verdana,DejaVu Sans,Geneva,sans-serif; margin-top: 5px; padding-left: 10px; padding-top: 2px; } div.toc h3 { font: bold 12px/1.2 Arial,FreeSans,sans-serif; color: #4665A2; border-bottom: 0 none; margin: 0; } div.toc ul { list-style: none outside none; border: medium none; padding: 0px; } div.toc li.level1 { margin-left: 0px; } div.toc li.level2 { margin-left: 15px; } div.toc li.level3 { margin-left: 30px; } div.toc li.level4 { margin-left: 45px; } .inherit_header { font-weight: bold; color: gray; cursor: pointer; -webkit-touch-callout: none; -webkit-user-select: none; -khtml-user-select: none; -moz-user-select: none; -ms-user-select: none; user-select: none; } .inherit_header td { padding: 6px 0px 2px 5px; } .inherit { display: none; } tr.heading h2 { margin-top: 12px; margin-bottom: 4px; } @media print { #top { display: none; } #side-nav { display: none; } #nav-path { display: none; } body { overflow:visible; } h1, h2, h3, h4, h5, h6 { page-break-after: avoid; } .summary { display: none; } .memitem { page-break-inside: avoid; } #doc-content { margin-left:0 !important; height:auto !important; width:auto !important; overflow:inherit; display:inline; } } json-c-json-c-0.17-20230812/doc/html/doxygen.png000066400000000000000000000073031446575330000206260ustar00rootroot00000000000000PNG  IHDRh ;IDATx]y\պ~45%TL QPE"q11]8aw*(*" z`8 m,p$%B(8k6lk[߷;?kPx'tz3_Q4g@m ci{~4:Hc'PP7^h zbcP 3}OqNkT(?d ~z<4ǡ؞vz٦Zd,6k]Fz< Zs?sU2Sw1c`[}%ѽ.Լ6BLZ!F8[ T #g]:vu?vbR?wgb$kF~;عƕX?lNʪ,HCgAzlӺg ]jM3oҳ'=$f}GS_co.ȹ:ds:1={9?zqviDp moaEqҵw}~{j{ºFNë[OqOSXO]>muľe5{Jկ(bl}`UyacCAklysA7oJ .Be. Z'-PyF.lp&.j7rez19HG%qz׈c_k_")HJn~֘5 q5#+9T Rܸrzϴ̝ =υ{áOfwg|/$;֙ƭ]W"/< DఽB}yIEc^=[VhM$l];Kr¦* t$]M;I1!M (f<5~z mՠ>کIz;u[ie^ӳNF6B\}7+,'a -yHY,^f~?Hc{Z+4\sٷnߣFơsغD?<vkx0MlذIxdEEAMg*YE7ۙ^[uv[wG=Edn׶l'pGk+C82 dz3H BS[wŘ ~xptmţiQ歉AB1fى4uI]6% 1t.NJphz̠R1"3-"&1[:N mW0_œ 6&)ꦬ}~{m]zMP~^:eQT_*798ˍ 347E¿uSɻU_ NWeNӏ|;;d"ȉ޵ﾮ"ĴMM+bY_E]PXKНIޥoE<_(EP|m,өZߺk,kM`jzeU t36˷r}w:Χ |TܵQK_pໃYd0!a –W$$/\$ 2mLH dHV,:RZJaz*>_NT(‚^SVFU8E܈nd;8\C]=m:bDd=ߞUU5O|]Pv\]2"y[yzg{Y{Ù5;w{N3nĨwKݭ29Id y)P8ũ@mPwjl,6 hWd ump.DžtwR xBδYcxg*vo y򑕓[?V0NO난~󒯷h#Hk8kӍ^q@]ӓ,56-κUn[>]@nϜp[6# 4tn:}8T9_Y$/GK(ђM`dѺ;OB &P{qhJ+閧l2M_1ӫtlya L^y.۽[ u/]iS}N>e1qjf&iT\=kϛX-.84V5u!TE .OH4zwTr. xքHHg hT$yqzp< qrwI]I鲘s":ՖbզL69VW<;3?M3AV#ޯKUr9!qtH+6V/TS^pqgLP'5E ޺ n"2|;W"֬TwtO' +W+Z̖<&nO,I06.Z.h*INڒOegBXZ9hDSʍ A/c`A"z|ş;H#|%OOD mcƤqmu&~n πZj =_n[nN$_bE)8?6l}#bW( d-p&a"9ņ$ڛA!;{~8ޣ10`#kuN Qbh 8Mawhq(bK Z%m֍(J)@> 7% {y ohf>{p.­_%glZ\B2B #Һphݚ[<#SpA7Ht4:|gtL*($Ʃ$;b`=MM5ǾHH.HeA5}rd)T};Q5i2O00;,냔}g]79_{C>h{.II?[Kswz6u;OJa˶zvd l舊yc'rTWӰL |ʽhB T'ò]K(=Kx  L,Pʵu׈ž1ݫ;pGDxZY kf676oھH~޸ 8Up6(? K+?%ݷ/19U?B)l @=ޞkIENDB`json-c-json-c-0.17-20230812/doc/html/dynsections.js000066400000000000000000000041341446575330000213420ustar00rootroot00000000000000function toggleVisibility(linkObj) { var base = $(linkObj).attr('id'); var summary = $('#'+base+'-summary'); var content = $('#'+base+'-content'); var trigger = $('#'+base+'-trigger'); var src=$(trigger).attr('src'); if (content.is(':visible')===true) { content.hide(); summary.show(); $(linkObj).addClass('closed').removeClass('opened'); $(trigger).attr('src',src.substring(0,src.length-8)+'closed.png'); } else { content.show(); summary.hide(); $(linkObj).removeClass('closed').addClass('opened'); $(trigger).attr('src',src.substring(0,src.length-10)+'open.png'); } return false; } function updateStripes() { $('table.directory tr'). removeClass('even').filter(':visible:even').addClass('even'); } function toggleLevel(level) { $('table.directory tr').each(function(){ var l = this.id.split('_').length-1; var i = $('#img'+this.id.substring(3)); var a = $('#arr'+this.id.substring(3)); if (l json-c: File List
File List
Here is a list of all files with brief descriptions:
[detail level 12]
o-distcheck
|\*json.hA convenience header that may be included instead of other individual ones
o*arraylist.hInternal methods for working with json_type_array objects. Although this is exposed by the json_object_get_array() method, it is not recommended for direct use
o*json_c_version.hMethods for retrieving the json-c version
o*json_inttypes.hDo not use, json-c internal, may be changed or removed at any time
o*json_object.hCore json-c API. Start here, or with json_tokener.h
o*json_object_iterator.hAn API for iterating over json_type_object objects, styled to be familiar to C++ programmers. Unlike json_object_object_foreach() and json_object_object_foreachC(), this avoids the need to expose json-c internals like lh_entry
o*json_patch.hJSON Patch (RFC 6902) implementation for manipulating JSON objects
o*json_pointer.hJSON Pointer (RFC 6901) implementation for retrieving objects from a json-c object tree
o*json_pointer_private.hDo not use, json-c internal, may be changed or removed at any time
o*json_tokener.hMethods to parse an input string into a tree of json_object objects
o*json_types.hBasic types used in a few places in json-c, but you should include "json_object.h" instead
o*json_util.hMiscllaneous utility functions and macros
o*json_visit.hMethods for walking a tree of objects
o*linkhash.hInternal methods for working with json_type_object objects. Although this is exposed by the json_object_get_object() function and within the json_object_iter type, it is not recommended for direct use
\*printbuf.hInternal string buffer handling. Unless you're writing a json_object_to_json_string_fn implementation for use with json_object_set_serializer() direct use of this is not recommended
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/ftv2blank.png000066400000000000000000000001261446575330000210360ustar00rootroot00000000000000PNG  IHDRɪ|IDATxݱðScOx@ y}IENDB`json-c-json-c-0.17-20230812/doc/html/ftv2cl.png000066400000000000000000000007051446575330000203500ustar00rootroot00000000000000PNG  IHDR}\IDATx;H#Ao4ႇK ,m vڞJ XY B|drcvoİ 0Ò3ͤe״1X8nQ88֧3*rb-$P1@Z-#011HkK wO@!fuc;sB[EA\>]Pzf| +g5b i5mM_q,cod!,{Y,zT8H]𤕘7/8Q!F~6?Y A@Ũ.@TYr8*>?e[6xIENDB`json-c-json-c-0.17-20230812/doc/html/ftv2doc.png000066400000000000000000000013521446575330000205160ustar00rootroot00000000000000PNG  IHDR}\IDATxMOS[sa?-XZ(PD4 AWbu`b 77wHFCԁ/`voAPqP@ 980 +y^Z9SW\83g3'Nçl_bpV"ֆXd]3xM[1W *PGz/Eg{ aoV:这1$RW,@56-,m/蹖 r5T*S(Vf89u գwa=<{ҡUr+dDF$`zNܮ0Q3~_^N=vpTLT}kqm<?ZhX_ݥ[) `ga_*2`'=F2EP l=8Wv%THqɿ<"GxH{#֫aJmKsVءM^ T ݛr߽m_?Wİ#uIENDB`json-c-json-c-0.17-20230812/doc/html/ftv2folderclosed.png000066400000000000000000000011501446575330000224120ustar00rootroot00000000000000PNG  IHDR}\/IDATx]MO@~uؐlp]#]PYEC\9y`xC &=qvZv3m؃vLN}}ޝZA@n ONp xKxj8s _[D'yye+ 7#rNlk* 0Ь_d_(Öz=xvhzP-䍒̪u$\DJcB4.:Ϗ-}LE #gN;B6䬜@p&h>p9EEάʑ"un$R"?{<%PNt$߶+^<"2Dqq\ҙaA"ԵP}#Ez{.8i p(ADwDE߂z;Kק8t q:uvvݛvEn{MFXgfZ֝*ߩ:jYq#3SWr'  IENDB`json-c-json-c-0.17-20230812/doc/html/ftv2folderopen.png000066400000000000000000000011251446575330000221040ustar00rootroot00000000000000PNG  IHDR}\IDATx]?oP9i4i;iiZ7`b٬,HU'$*T]TDP6w};C; aӝߟjAInS}9Hӎ|? =_Ɗue*;YEsYBėsٌ ɫYq !Gǿv̇خ F}qb]70)d-}PfY{4@}2ԗNIǃc%UImcƝ>xt9$ OVE*Û#׈r@l$PrHaa dZrqIoT\,tj2FAxv-Lp׌p TI/ \sf; jViTo^cpb]€<a՜y9:+,E f6NEKU}^;nZuUS4 ѬbN.kjT% iV )GJ@TxIENDB`json-c-json-c-0.17-20230812/doc/html/ftv2lastnode.png000066400000000000000000000001261446575330000215600ustar00rootroot00000000000000PNG  IHDRɪ|IDATxݱðScOx@ y}IENDB`json-c-json-c-0.17-20230812/doc/html/ftv2link.png000066400000000000000000000013521446575330000207060ustar00rootroot00000000000000PNG  IHDR}\IDATxMOS[sa?-XZ(PD4 AWbu`b 77wHFCԁ/`voAPqP@ 980 +y^Z9SW\83g3'Nçl_bpV"ֆXd]3xM[1W *PGz/Eg{ aoV:这1$RW,@56-,m/蹖 r5T*S(Vf89u գwa=<{ҡUr+dDF$`zNܮ0Q3~_^N=vpTLT}kqm<?ZhX_ݥ[) `ga_*2`'=F2EP l=8Wv%THqɿ<"GxH{#֫aJmKsVءM^ T ݛr߽m_?Wİ#uIENDB`json-c-json-c-0.17-20230812/doc/html/ftv2mlastnode.png000066400000000000000000000003661446575330000217430ustar00rootroot00000000000000PNG  IHDRɪ|IDATx!NA\ Um@`5i`h W7] b&ofdY4 c 3v=]\B I=BB;k WN@vy4]Y|M}]x6a }dׇY>||5?>|B"'IENDB`json-c-json-c-0.17-20230812/doc/html/ftv2mnode.png000066400000000000000000000003661446575330000210570ustar00rootroot00000000000000PNG  IHDRɪ|IDATx!NA\ Um@`5i`h W7] b&ofdY4 c 3v=]\B I=BB;k WN@vy4]Y|M}]x6a }dׇY>||5?>|B"'IENDB`json-c-json-c-0.17-20230812/doc/html/ftv2mo.png000066400000000000000000000006231446575330000203640ustar00rootroot00000000000000PNG  IHDR}\ZIDATx1K@iBҡ(h"EI'oک 8R- BTP]zB3 _㒻}]V}dIiJb+|K…,[P\ʘMƢ#F`JݤkA?Y4ck6"Z)0SHM@㋺Wmo4HJ+Qobt *~8_+3Y- PwA+^}+xhϕMAE]TD~EÞߴ^R)`A9pq-۾ۍ3tƛTH) ICxd#1 m@V?Zgo_3-\IENDB`json-c-json-c-0.17-20230812/doc/html/ftv2node.png000066400000000000000000000001261446575330000206740ustar00rootroot00000000000000PNG  IHDRɪ|IDATxݱðScOx@ y}IENDB`json-c-json-c-0.17-20230812/doc/html/ftv2ns.png000066400000000000000000000006041446575330000203700ustar00rootroot00000000000000PNG  IHDR}\KIDATx1K1 G⁂n lE(nࢋMA@ tK%ܕ ]BI%uͅa,e v祫i\tun0oV\$G.&@Y=%$um6'߫9Q\b)0-ZTH`pcsm 5:>ަI F] jgo[ on Ԭvq?\ 6Tee lQ c3*dWTM\rh61F fIENDB`json-c-json-c-0.17-20230812/doc/html/ftv2plastnode.png000066400000000000000000000003451446575330000217430ustar00rootroot00000000000000PNG  IHDRɪ|IDATx=QFDk:FPK؃=V@ճ 8SHx0bnrr{򽿾$ TP XOd6"SOB(Q)+YĈ ҪR>Vtsm9(k-@ȧ-$ b [he Kp-l|CApRG'rͭaIENDB`json-c-json-c-0.17-20230812/doc/html/ftv2pnode.png000066400000000000000000000003451446575330000210570ustar00rootroot00000000000000PNG  IHDRɪ|IDATx=QFDk:FPK؃=V@ճ 8SHx0bnrr{򽿾$ TP XOd6"SOB(Q)+YĈ ҪR>Vtsm9(k-@ȧ-$ b [he Kp-l|CApRG'rͭaIENDB`json-c-json-c-0.17-20230812/doc/html/ftv2splitbar.png000066400000000000000000000004721446575330000215730ustar00rootroot00000000000000PNG  IHDRMIDATxݡJCa( %4 bȘͶ3v^EL ,b;{Ï/aYկq:\IIIIIIIIIIIIIIIIII-l揊_t/ϻYQVYivk_ۣI@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$C[V=[fIENDB`json-c-json-c-0.17-20230812/doc/html/ftv2vertline.png000066400000000000000000000001261446575330000215770ustar00rootroot00000000000000PNG  IHDRɪ|IDATxݱðScOx@ y}IENDB`json-c-json-c-0.17-20230812/doc/html/functions.html000066400000000000000000000236541446575330000213500ustar00rootroot00000000000000 json-c: Data Fields
Here is a list of all struct and union fields with links to the structures/unions they belong to:

- a -

- b -

- c -

- d -

- e -

- f -

- h -

- i -

- k -

- l -

- m -

- n -

- o -

- p -

- q -

- s -

- t -

- u -

- v -

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/functions_vars.html000066400000000000000000000235001446575330000223710ustar00rootroot00000000000000 json-c: Data Fields - Variables
 

- a -

- b -

- c -

- d -

- e -

- f -

- h -

- i -

- k -

- l -

- m -

- n -

- o -

- p -

- q -

- s -

- t -

- u -

- v -

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/globals.html000066400000000000000000000117301446575330000207530ustar00rootroot00000000000000 json-c: Globals
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:

- a -

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/globals_0x69.html000066400000000000000000000066671446575330000215560ustar00rootroot00000000000000 json-c: Globals
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:

- i -

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/globals_0x6a.html000066400000000000000000000763211446575330000216200ustar00rootroot00000000000000 json-c: Globals
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:

- j -

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/globals_0x6c.html000066400000000000000000000153171446575330000216200ustar00rootroot00000000000000 json-c: Globals
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:

- l -

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/globals_0x70.html000066400000000000000000000107131446575330000215310ustar00rootroot00000000000000 json-c: Globals
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:

- p -

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/globals_0x73.html000066400000000000000000000066571446575330000215500ustar00rootroot00000000000000 json-c: Globals
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:

- s -

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/globals_0x75.html000066400000000000000000000066711446575330000215460ustar00rootroot00000000000000 json-c: Globals
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:

- u -

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/globals_defs.html000066400000000000000000000226341446575330000217610ustar00rootroot00000000000000 json-c: Globals
 

- a -

- j -

- l -

- p -

- s -

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/globals_enum.html000066400000000000000000000054751446575330000220100ustar00rootroot00000000000000 json-c: Globals
 
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/globals_eval.html000066400000000000000000000261271446575330000217700ustar00rootroot00000000000000 json-c: Globals
 

- j -

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/globals_func.html000066400000000000000000000506411446575330000217720ustar00rootroot00000000000000 json-c: Globals
 

- a -

- j -

- l -

- p -

- s -

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/globals_type.html000066400000000000000000000116341446575330000220170ustar00rootroot00000000000000 json-c: Globals
 
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/globals_vars.html000066400000000000000000000055451446575330000220150ustar00rootroot00000000000000 json-c: Globals
 
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/index.html000066400000000000000000000462631446575330000204500ustar00rootroot00000000000000 json-c: Main Page
json-c Documentation

json-c

  1. Overview and Build Status
  2. Getting Help
  3. Building on Unix
  4. CMake options
  5. Testing
  6. Building with `vcpkg`
  7. Building for Android
  1. Linking to libjson-c
  2. Using json-c

JSON-C - A JSON implementation in C

JSON-C implements a reference counting object model that allows you to easily construct JSON objects in C, output them as JSON formatted strings and parse JSON formatted strings back into the C representation of JSON objects. It aims to conform to RFC 8259.

Skip down to Using json-c or check out the API docs, if you already have json-c installed and ready to use.

Home page for json-c: https://github.com/json-c/json-c/wiki

Getting Help

If you have questions about using json-c, please start a thread on our forums at: https://groups.google.com/forum/#!forum/json-c

If you believe you've discovered a bug, report it at (https://github.com/json-c/json-c/issues). Please be sure to include the version of json-c you're using, the OS you're running on, and any other relevant details. Fully reproducible test cases and/or patches to fix problems are greatly appreciated.

Fixes for bugs, or small new features can be directly submitted as a pull request. For major new features or large changes of any kind, please first start a discussion on the forums.

Building on Unix with git, gcc and cmake

If you already have json-c installed, see Linking to `libjson-c` for how to build and link your program against it.

Build Status

Test Status

Prerequisites:

  • gcc, clang, or another C compiler
  • cmake>=2.8, >=3.16 recommended, cmake=>3.1 for tests

To generate docs you'll also need:

  • doxygen>=1.8.13

If you are on a relatively modern system, you'll likely be able to install the prerequisites using your OS's packaging system.

Install using apt (e.g. Ubuntu 16.04.2 LTS)

sudo apt install git
sudo apt install cmake
sudo apt install doxygen  # optional
sudo apt install valgrind # optional

Build instructions:

json-c GitHub repo: https://github.com/json-c/json-c 

$ git clone https://github.com/json-c/json-c.git
$ mkdir json-c-build
$ cd json-c-build
$ cmake ../json-c   # See CMake section below for custom arguments

Note: it's also possible to put your build directory inside the json-c source directory, or even not use a separate build directory at all, but certain things might not work quite right (notably, make distcheck)

Then: 

$ make
$ make test
$ make USE_VALGRIND=0 test   # optionally skip using valgrind
$ sudo make install          # it could be necessary to execute make install

Generating documentation with Doxygen:

The library documentation can be generated directly from the source code using Doxygen tool: 

# in build directory
make doc
google-chrome doc/html/index.html

CMake Options

The json-c library is built with CMake, which can take a few options.

Variable Type Description
CMAKE_INSTALL_PREFIX String The install location.
CMAKE_BUILD_TYPE String Defaults to "debug".
BUILD_SHARED_LIBS Bool The default build generates a dynamic (dll/so) library. Set this to OFF to create a static library only.
BUILD_STATIC_LIBS Bool The default build generates a static (lib/a) library. Set this to OFF to create a shared library only.
DISABLE_STATIC_FPIC Bool The default builds position independent code. Set this to OFF to create a shared library only.
DISABLE_BSYMBOLIC Bool Disable use of -Bsymbolic-functions.
DISABLE_THREAD_LOCAL_STORAGE Bool Disable use of Thread-Local Storage (HAVE___THREAD).
DISABLE_WERROR Bool Disable use of -Werror.
DISABLE_EXTRA_LIBS Bool Disable use of extra libraries, libbsd
DISABLE_JSON_POINTER Bool Omit json_pointer support from the build.
ENABLE_RDRAND Bool Enable RDRAND Hardware RNG Hash Seed.
ENABLE_THREADING Bool Enable partial threading support.
OVERRIDE_GET_RANDOM_SEED String A block of code to use instead of the default implementation of json_c_get_random_seed(), e.g. on embedded platforms where not even the fallback to time() works. Must be a single line.

Pass these options as -D on CMake's command-line. 

# build a static library only
cmake -DBUILD_SHARED_LIBS=OFF ..

Building with partial threading support

Although json-c does not support fully multi-threaded access to object trees, it has some code to help make its use in threaded programs a bit safer. Currently, this is limited to using atomic operations for json_object_get() and json_object_put().

Since this may have a performance impact, of at least 3x slower according to https://stackoverflow.com/a/11609063, it is disabled by default. You may turn it on by adjusting your cmake command with: -DENABLE_THREADING=ON

Separately, the default hash function used for object field keys, lh_char_hash, uses a compare-and-swap operation to ensure the random seed is only generated once. Because this is a one-time operation, it is always compiled in when the compare-and-swap operation is available.

cmake-configure wrapper script

For those familiar with the old autoconf/autogen.sh/configure method, there is a cmake-configure wrapper script to ease the transition to cmake. 

mkdir build
cd build
../cmake-configure --prefix=/some/install/path
make

cmake-configure can take a few options.

options Description
prefix=PREFIX install architecture-independent files in PREFIX
enable-threading Enable code to support partly multi-threaded use
enable-rdrand Enable RDRAND Hardware RNG Hash Seed generation on supported x86/x64 platforms.
enable-shared build shared libraries [default=yes]
enable-static build static libraries [default=yes]
disable-Bsymbolic Avoid linking with -Bsymbolic-function
disable-werror Avoid treating compiler warnings as fatal errors

Testing:

By default, if valgrind is available running tests uses it. That can slow the tests down considerably, so to disable it use: 

export USE_VALGRIND=0

To run tests a separate build directory is recommended: 

mkdir build-test
cd build-test
# VALGRIND=1 causes -DVALGRIND=1 to be passed when compiling code
# which uses slightly slower, but valgrind-safe code.
VALGRIND=1 cmake ..
make

make test
# By default, if valgrind is available running tests uses it.
make USE_VALGRIND=0 test   # optionally skip using valgrind

If a test fails, check Testing/Temporary/LastTest.log, tests/testSubDir/${testname}/${testname}.vg.out, and other similar files. If there is insufficient output try: 

VERBOSE=1 CTEST_OUTPUT_ON_FAILURE=1 make test

or 

JSONC_TEST_TRACE=1 make test

and check the log files again.

Building on Unix and Windows with vcpkg

You can download and install JSON-C using the vcpkg dependency manager: 

git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
vcpkg install json-c

The JSON-C port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please create an issue or pull request on the vcpkg repository.

Building for Android

Building on Android is now particularly well supported, but there have been some reports of success using https://developer.android.com/ndk/guides/cmake 

mkdir json-c-build
cd json-c-build/
export NDK_HOME=~/Library/Android/sdk/ndk/22.1.7171670/
cmake \
    --toolchain=$NDK_HOME/build/cmake/android.toolchain.cmake \
    -DANDROID_STL=none \
    -DANDROID_ABI=arm64-v8a \
    -DANDROID_PLATFORM=android-29 \
    -DANDROID_LD=lld \
    -DCMAKE_BUILD_TYPE=MinSizeRel \
    -DCMAKE_INSTALL_PREFIX=<install prefix> \
    -DENABLE_THREADING=true \
    ..
make install

Linking to libjson-c

If your system has pkgconfig, then you can just add this to your makefile: 

CFLAGS += $(shell pkg-config --cflags json-c)
LDFLAGS += $(shell pkg-config --libs json-c)

Without pkgconfig, you might do something like this: 

JSON_C_DIR=/path/to/json_c/install
CFLAGS += -I$(JSON_C_DIR)/include/json-c
# Or to use lines like: #include <json-c/json_object.h>
#CFLAGS += -I$(JSON_C_DIR)/include
LDFLAGS+= -L$(JSON_C_DIR)/lib -ljson-c

If your project uses cmake:

  • Add to your CMakeLists.txt file:

    find_package(json-c CONFIG) target_link_libraries(${PROJECT_NAME} PRIVATE json-c::json-c)

  • Then you might run in your project:

    cd build cmake -DCMAKE_PREFIX_PATH=/path/to/json_c/install/lib64/cmake ..

Using json-c

To use json-c you can either include json.h, or preferably, one of the following more specific header files:

For a full list of headers see files.html

The primary type in json-c is json_object. It describes a reference counted tree of json objects which are created by either parsing text with a json_tokener (i.e. json_tokener_parse_ex()), or by creating (with json_object_new_object(), json_object_new_int(), etc...) and adding (with json_object_object_add(), json_object_array_add(), etc...) them individually. Typically, every object in the tree will have one reference, from its parent. When you are done with the tree of objects, you call json_object_put() on just the root object to free it, which recurses down through any child objects calling json_object_put() on each one of those in turn.

You can get a reference to a single child (json_object_object_get() or json_object_array_get_idx()) and use that object as long as its parent is valid. If you need a child object to live longer than its parent, you can increment the child's refcount (json_object_get()) to allow it to survive the parent being freed or it being removed from its parent (json_object_object_del() or json_object_array_del_idx())

When parsing text, the json_tokener object is independent from the json_object that it returns. It can be allocated (json_tokener_new()) used one or multiple times (json_tokener_parse_ex(), and freed (json_tokener_free()) while the json_object objects live on.

A json_object tree can be serialized back into a string with json_object_to_json_string_ext(). The string that is returned is only valid until the next "to_json_string" call on that same object. Also, it is freed when the json_object is freed.

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/issues__closed__for__0_813_8md.html000066400000000000000000000040361446575330000250620ustar00rootroot00000000000000 json-c: issues_closed_for_0.13.md File Reference
issues_closed_for_0.13.md File Reference
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/issues__closed__for__0_814_8md.html000066400000000000000000000040361446575330000250630ustar00rootroot00000000000000 json-c: issues_closed_for_0.14.md File Reference
issues_closed_for_0.14.md File Reference
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/issues__closed__for__0_815_8md.html000066400000000000000000000040361446575330000250640ustar00rootroot00000000000000 json-c: issues_closed_for_0.15.md File Reference
issues_closed_for_0.15.md File Reference
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/issues__closed__for__0_816_8md.html000066400000000000000000000040361446575330000250650ustar00rootroot00000000000000 json-c: issues_closed_for_0.16.md File Reference
issues_closed_for_0.16.md File Reference
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/issues__closed__for__0_817_8md.html000066400000000000000000000040361446575330000250660ustar00rootroot00000000000000 json-c: issues_closed_for_0.17.md File Reference
issues_closed_for_0.17.md File Reference
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/jquery.js000066400000000000000000002672611446575330000203330ustar00rootroot00000000000000/*! jQuery v1.7.1 jquery.com | jquery.org/license */ (function(a,b){function cy(a){return f.isWindow(a)?a:a.nodeType===9?a.defaultView||a.parentWindow:!1}function cv(a){if(!ck[a]){var b=c.body,d=f("<"+a+">").appendTo(b),e=d.css("display");d.remove();if(e==="none"||e===""){cl||(cl=c.createElement("iframe"),cl.frameBorder=cl.width=cl.height=0),b.appendChild(cl);if(!cm||!cl.createElement)cm=(cl.contentWindow||cl.contentDocument).document,cm.write((c.compatMode==="CSS1Compat"?"":"")+""),cm.close();d=cm.createElement(a),cm.body.appendChild(d),e=f.css(d,"display"),b.removeChild(cl)}ck[a]=e}return ck[a]}function cu(a,b){var c={};f.each(cq.concat.apply([],cq.slice(0,b)),function(){c[this]=a});return c}function ct(){cr=b}function cs(){setTimeout(ct,0);return cr=f.now()}function cj(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}function ci(){try{return new a.XMLHttpRequest}catch(b){}}function cc(a,c){a.dataFilter&&(c=a.dataFilter(c,a.dataType));var d=a.dataTypes,e={},g,h,i=d.length,j,k=d[0],l,m,n,o,p;for(g=1;g0){if(c!=="border")for(;g=0===c})}function S(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function K(){return!0}function J(){return!1}function n(a,b,c){var d=b+"defer",e=b+"queue",g=b+"mark",h=f._data(a,d);h&&(c==="queue"||!f._data(a,e))&&(c==="mark"||!f._data(a,g))&&setTimeout(function(){!f._data(a,e)&&!f._data(a,g)&&(f.removeData(a,d,!0),h.fire())},0)}function m(a){for(var b in a){if(b==="data"&&f.isEmptyObject(a[b]))continue;if(b!=="toJSON")return!1}return!0}function l(a,c,d){if(d===b&&a.nodeType===1){var e="data-"+c.replace(k,"-$1").toLowerCase();d=a.getAttribute(e);if(typeof d=="string"){try{d=d==="true"?!0:d==="false"?!1:d==="null"?null:f.isNumeric(d)?parseFloat(d):j.test(d)?f.parseJSON(d):d}catch(g){}f.data(a,c,d)}else d=b}return d}function h(a){var b=g[a]={},c,d;a=a.split(/\s+/);for(c=0,d=a.length;c)[^>]*$|#([\w\-]*)$)/,j=/\S/,k=/^\s+/,l=/\s+$/,m=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,n=/^[\],:{}\s]*$/,o=/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,p=/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,q=/(?:^|:|,)(?:\s*\[)+/g,r=/(webkit)[ \/]([\w.]+)/,s=/(opera)(?:.*version)?[ \/]([\w.]+)/,t=/(msie) ([\w.]+)/,u=/(mozilla)(?:.*? rv:([\w.]+))?/,v=/-([a-z]|[0-9])/ig,w=/^-ms-/,x=function(a,b){return(b+"").toUpperCase()},y=d.userAgent,z,A,B,C=Object.prototype.toString,D=Object.prototype.hasOwnProperty,E=Array.prototype.push,F=Array.prototype.slice,G=String.prototype.trim,H=Array.prototype.indexOf,I={};e.fn=e.prototype={constructor:e,init:function(a,d,f){var g,h,j,k;if(!a)return this;if(a.nodeType){this.context=this[0]=a,this.length=1;return this}if(a==="body"&&!d&&c.body){this.context=c,this[0]=c.body,this.selector=a,this.length=1;return this}if(typeof a=="string"){a.charAt(0)!=="<"||a.charAt(a.length-1)!==">"||a.length<3?g=i.exec(a):g=[null,a,null];if(g&&(g[1]||!d)){if(g[1]){d=d instanceof e?d[0]:d,k=d?d.ownerDocument||d:c,j=m.exec(a),j?e.isPlainObject(d)?(a=[c.createElement(j[1])],e.fn.attr.call(a,d,!0)):a=[k.createElement(j[1])]:(j=e.buildFragment([g[1]],[k]),a=(j.cacheable?e.clone(j.fragment):j.fragment).childNodes);return e.merge(this,a)}h=c.getElementById(g[2]);if(h&&h.parentNode){if(h.id!==g[2])return f.find(a);this.length=1,this[0]=h}this.context=c,this.selector=a;return this}return!d||d.jquery?(d||f).find(a):this.constructor(d).find(a)}if(e.isFunction(a))return f.ready(a);a.selector!==b&&(this.selector=a.selector,this.context=a.context);return e.makeArray(a,this)},selector:"",jquery:"1.7.1",length:0,size:function(){return this.length},toArray:function(){return F.call(this,0)},get:function(a){return a==null?this.toArray():a<0?this[this.length+a]:this[a]},pushStack:function(a,b,c){var d=this.constructor();e.isArray(a)?E.apply(d,a):e.merge(d,a),d.prevObject=this,d.context=this.context,b==="find"?d.selector=this.selector+(this.selector?" ":"")+c:b&&(d.selector=this.selector+"."+b+"("+c+")");return d},each:function(a,b){return e.each(this,a,b)},ready:function(a){e.bindReady(),A.add(a);return this},eq:function(a){a=+a;return a===-1?this.slice(a):this.slice(a,a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(F.apply(this,arguments),"slice",F.call(arguments).join(","))},map:function(a){return this.pushStack(e.map(this,function(b,c){return a.call(b,c,b)}))},end:function(){return this.prevObject||this.constructor(null)},push:E,sort:[].sort,splice:[].splice},e.fn.init.prototype=e.fn,e.extend=e.fn.extend=function(){var a,c,d,f,g,h,i=arguments[0]||{},j=1,k=arguments.length,l=!1;typeof i=="boolean"&&(l=i,i=arguments[1]||{},j=2),typeof i!="object"&&!e.isFunction(i)&&(i={}),k===j&&(i=this,--j);for(;j0)return;A.fireWith(c,[e]),e.fn.trigger&&e(c).trigger("ready").off("ready")}},bindReady:function(){if(!A){A=e.Callbacks("once memory");if(c.readyState==="complete")return setTimeout(e.ready,1);if(c.addEventListener)c.addEventListener("DOMContentLoaded",B,!1),a.addEventListener("load",e.ready,!1);else if(c.attachEvent){c.attachEvent("onreadystatechange",B),a.attachEvent("onload",e.ready);var b=!1;try{b=a.frameElement==null}catch(d){}c.documentElement.doScroll&&b&&J()}}},isFunction:function(a){return e.type(a)==="function"},isArray:Array.isArray||function(a){return e.type(a)==="array"},isWindow:function(a){return a&&typeof a=="object"&&"setInterval"in a},isNumeric:function(a){return!isNaN(parseFloat(a))&&isFinite(a)},type:function(a){return a==null?String(a):I[C.call(a)]||"object"},isPlainObject:function(a){if(!a||e.type(a)!=="object"||a.nodeType||e.isWindow(a))return!1;try{if(a.constructor&&!D.call(a,"constructor")&&!D.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}var d;for(d in a);return d===b||D.call(a,d)},isEmptyObject:function(a){for(var b in a)return!1;return!0},error:function(a){throw new Error(a)},parseJSON:function(b){if(typeof b!="string"||!b)return null;b=e.trim(b);if(a.JSON&&a.JSON.parse)return a.JSON.parse(b);if(n.test(b.replace(o,"@").replace(p,"]").replace(q,"")))return(new Function("return "+b))();e.error("Invalid JSON: "+b)},parseXML:function(c){var d,f;try{a.DOMParser?(f=new DOMParser,d=f.parseFromString(c,"text/xml")):(d=new ActiveXObject("Microsoft.XMLDOM"),d.async="false",d.loadXML(c))}catch(g){d=b}(!d||!d.documentElement||d.getElementsByTagName("parsererror").length)&&e.error("Invalid XML: "+c);return d},noop:function(){},globalEval:function(b){b&&j.test(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(w,"ms-").replace(v,x)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toUpperCase()===b.toUpperCase()},each:function(a,c,d){var f,g=0,h=a.length,i=h===b||e.isFunction(a);if(d){if(i){for(f in a)if(c.apply(a[f],d)===!1)break}else for(;g0&&a[0]&&a[j-1]||j===0||e.isArray(a));if(k)for(;i1?i.call(arguments,0):b,j.notifyWith(k,e)}}function l(a){return function(c){b[a]=arguments.length>1?i.call(arguments,0):c,--g||j.resolveWith(j,b)}}var b=i.call(arguments,0),c=0,d=b.length,e=Array(d),g=d,h=d,j=d<=1&&a&&f.isFunction(a.promise)?a:f.Deferred(),k=j.promise();if(d>1){for(;c
a",d=q.getElementsByTagName("*"),e=q.getElementsByTagName("a")[0];if(!d||!d.length||!e)return{};g=c.createElement("select"),h=g.appendChild(c.createElement("option")),i=q.getElementsByTagName("input")[0],b={leadingWhitespace:q.firstChild.nodeType===3,tbody:!q.getElementsByTagName("tbody").length,htmlSerialize:!!q.getElementsByTagName("link").length,style:/top/.test(e.getAttribute("style")),hrefNormalized:e.getAttribute("href")==="/a",opacity:/^0.55/.test(e.style.opacity),cssFloat:!!e.style.cssFloat,checkOn:i.value==="on",optSelected:h.selected,getSetAttribute:q.className!=="t",enctype:!!c.createElement("form").enctype,html5Clone:c.createElement("nav").cloneNode(!0).outerHTML!=="<:nav>",submitBubbles:!0,changeBubbles:!0,focusinBubbles:!1,deleteExpando:!0,noCloneEvent:!0,inlineBlockNeedsLayout:!1,shrinkWrapBlocks:!1,reliableMarginRight:!0},i.checked=!0,b.noCloneChecked=i.cloneNode(!0).checked,g.disabled=!0,b.optDisabled=!h.disabled;try{delete q.test}catch(s){b.deleteExpando=!1}!q.addEventListener&&q.attachEvent&&q.fireEvent&&(q.attachEvent("onclick",function(){b.noCloneEvent=!1}),q.cloneNode(!0).fireEvent("onclick")),i=c.createElement("input"),i.value="t",i.setAttribute("type","radio"),b.radioValue=i.value==="t",i.setAttribute("checked","checked"),q.appendChild(i),k=c.createDocumentFragment(),k.appendChild(q.lastChild),b.checkClone=k.cloneNode(!0).cloneNode(!0).lastChild.checked,b.appendChecked=i.checked,k.removeChild(i),k.appendChild(q),q.innerHTML="",a.getComputedStyle&&(j=c.createElement("div"),j.style.width="0",j.style.marginRight="0",q.style.width="2px",q.appendChild(j),b.reliableMarginRight=(parseInt((a.getComputedStyle(j,null)||{marginRight:0}).marginRight,10)||0)===0);if(q.attachEvent)for(o in{submit:1,change:1,focusin:1})n="on"+o,p=n in q,p||(q.setAttribute(n,"return;"),p=typeof q[n]=="function"),b[o+"Bubbles"]=p;k.removeChild(q),k=g=h=j=q=i=null,f(function(){var a,d,e,g,h,i,j,k,m,n,o,r=c.getElementsByTagName("body")[0];!r||(j=1,k="position:absolute;top:0;left:0;width:1px;height:1px;margin:0;",m="visibility:hidden;border:0;",n="style='"+k+"border:5px solid #000;padding:0;'",o="
"+""+"
",a=c.createElement("div"),a.style.cssText=m+"width:0;height:0;position:static;top:0;margin-top:"+j+"px",r.insertBefore(a,r.firstChild),q=c.createElement("div"),a.appendChild(q),q.innerHTML="
t
",l=q.getElementsByTagName("td"),p=l[0].offsetHeight===0,l[0].style.display="",l[1].style.display="none",b.reliableHiddenOffsets=p&&l[0].offsetHeight===0,q.innerHTML="",q.style.width=q.style.paddingLeft="1px",f.boxModel=b.boxModel=q.offsetWidth===2,typeof q.style.zoom!="undefined"&&(q.style.display="inline",q.style.zoom=1,b.inlineBlockNeedsLayout=q.offsetWidth===2,q.style.display="",q.innerHTML="
",b.shrinkWrapBlocks=q.offsetWidth!==2),q.style.cssText=k+m,q.innerHTML=o,d=q.firstChild,e=d.firstChild,h=d.nextSibling.firstChild.firstChild,i={doesNotAddBorder:e.offsetTop!==5,doesAddBorderForTableAndCells:h.offsetTop===5},e.style.position="fixed",e.style.top="20px",i.fixedPosition=e.offsetTop===20||e.offsetTop===15,e.style.position=e.style.top="",d.style.overflow="hidden",d.style.position="relative",i.subtractsBorderForOverflowNotVisible=e.offsetTop===-5,i.doesNotIncludeMarginInBodyOffset=r.offsetTop!==j,r.removeChild(a),q=a=null,f.extend(b,i))});return b}();var j=/^(?:\{.*\}|\[.*\])$/,k=/([A-Z])/g;f.extend({cache:{},uuid:0,expando:"jQuery"+(f.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:!0,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:!0},hasData:function(a){a=a.nodeType?f.cache[a[f.expando]]:a[f.expando];return!!a&&!m(a)},data:function(a,c,d,e){if(!!f.acceptData(a)){var g,h,i,j=f.expando,k=typeof c=="string",l=a.nodeType,m=l?f.cache:a,n=l?a[j]:a[j]&&j,o=c==="events";if((!n||!m[n]||!o&&!e&&!m[n].data)&&k&&d===b)return;n||(l?a[j]=n=++f.uuid:n=j),m[n]||(m[n]={},l||(m[n].toJSON=f.noop));if(typeof c=="object"||typeof c=="function")e?m[n]=f.extend(m[n],c):m[n].data=f.extend(m[n].data,c);g=h=m[n],e||(h.data||(h.data={}),h=h.data),d!==b&&(h[f.camelCase(c)]=d);if(o&&!h[c])return g.events;k?(i=h[c],i==null&&(i=h[f.camelCase(c)])):i=h;return i}},removeData:function(a,b,c){if(!!f.acceptData(a)){var d,e,g,h=f.expando,i=a.nodeType,j=i?f.cache:a,k=i?a[h]:h;if(!j[k])return;if(b){d=c?j[k]:j[k].data;if(d){f.isArray(b)||(b in d?b=[b]:(b=f.camelCase(b),b in d?b=[b]:b=b.split(" ")));for(e=0,g=b.length;e-1)return!0;return!1},val:function(a){var c,d,e,g=this[0];{if(!!arguments.length){e=f.isFunction(a);return this.each(function(d){var g=f(this),h;if(this.nodeType===1){e?h=a.call(this,d,g.val()):h=a,h==null?h="":typeof h=="number"?h+="":f.isArray(h)&&(h=f.map(h,function(a){return a==null?"":a+""})),c=f.valHooks[this.nodeName.toLowerCase()]||f.valHooks[this.type];if(!c||!("set"in c)||c.set(this,h,"value")===b)this.value=h}})}if(g){c=f.valHooks[g.nodeName.toLowerCase()]||f.valHooks[g.type];if(c&&"get"in c&&(d=c.get(g,"value"))!==b)return d;d=g.value;return typeof d=="string"?d.replace(q,""):d==null?"":d}}}}),f.extend({valHooks:{option:{get:function(a){var b=a.attributes.value;return!b||b.specified?a.value:a.text}},select:{get:function(a){var b,c,d,e,g=a.selectedIndex,h=[],i=a.options,j=a.type==="select-one";if(g<0)return null;c=j?g:0,d=j?g+1:i.length;for(;c=0}),c.length||(a.selectedIndex=-1);return c}}},attrFn:{val:!0,css:!0,html:!0,text:!0,data:!0,width:!0,height:!0,offset:!0},attr:function(a,c,d,e){var g,h,i,j=a.nodeType;if(!!a&&j!==3&&j!==8&&j!==2){if(e&&c in f.attrFn)return f(a)[c](d);if(typeof a.getAttribute=="undefined")return f.prop(a,c,d);i=j!==1||!f.isXMLDoc(a),i&&(c=c.toLowerCase(),h=f.attrHooks[c]||(u.test(c)?x:w));if(d!==b){if(d===null){f.removeAttr(a,c);return}if(h&&"set"in h&&i&&(g=h.set(a,d,c))!==b)return g;a.setAttribute(c,""+d);return d}if(h&&"get"in h&&i&&(g=h.get(a,c))!==null)return g;g=a.getAttribute(c);return g===null?b:g}},removeAttr:function(a,b){var c,d,e,g,h=0;if(b&&a.nodeType===1){d=b.toLowerCase().split(p),g=d.length;for(;h=0}})});var z=/^(?:textarea|input|select)$/i,A=/^([^\.]*)?(?:\.(.+))?$/,B=/\bhover(\.\S+)?\b/,C=/^key/,D=/^(?:mouse|contextmenu)|click/,E=/^(?:focusinfocus|focusoutblur)$/,F=/^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,G=function(a){var b=F.exec(a);b&&(b[1]=(b[1]||"").toLowerCase(),b[3]=b[3]&&new RegExp("(?:^|\\s)"+b[3]+"(?:\\s|$)"));return b},H=function(a,b){var c=a.attributes||{};return(!b[1]||a.nodeName.toLowerCase()===b[1])&&(!b[2]||(c.id||{}).value===b[2])&&(!b[3]||b[3].test((c["class"]||{}).value))},I=function(a){return f.event.special.hover?a:a.replace(B,"mouseenter$1 mouseleave$1")}; f.event={add:function(a,c,d,e,g){var h,i,j,k,l,m,n,o,p,q,r,s;if(!(a.nodeType===3||a.nodeType===8||!c||!d||!(h=f._data(a)))){d.handler&&(p=d,d=p.handler),d.guid||(d.guid=f.guid++),j=h.events,j||(h.events=j={}),i=h.handle,i||(h.handle=i=function(a){return typeof f!="undefined"&&(!a||f.event.triggered!==a.type)?f.event.dispatch.apply(i.elem,arguments):b},i.elem=a),c=f.trim(I(c)).split(" ");for(k=0;k=0&&(h=h.slice(0,-1),k=!0),h.indexOf(".")>=0&&(i=h.split("."),h=i.shift(),i.sort());if((!e||f.event.customEvent[h])&&!f.event.global[h])return;c=typeof c=="object"?c[f.expando]?c:new f.Event(h,c):new f.Event(h),c.type=h,c.isTrigger=!0,c.exclusive=k,c.namespace=i.join("."),c.namespace_re=c.namespace?new RegExp("(^|\\.)"+i.join("\\.(?:.*\\.)?")+"(\\.|$)"):null,o=h.indexOf(":")<0?"on"+h:"";if(!e){j=f.cache;for(l in j)j[l].events&&j[l].events[h]&&f.event.trigger(c,d,j[l].handle.elem,!0);return}c.result=b,c.target||(c.target=e),d=d!=null?f.makeArray(d):[],d.unshift(c),p=f.event.special[h]||{};if(p.trigger&&p.trigger.apply(e,d)===!1)return;r=[[e,p.bindType||h]];if(!g&&!p.noBubble&&!f.isWindow(e)){s=p.delegateType||h,m=E.test(s+h)?e:e.parentNode,n=null;for(;m;m=m.parentNode)r.push([m,s]),n=m;n&&n===e.ownerDocument&&r.push([n.defaultView||n.parentWindow||a,s])}for(l=0;le&&i.push({elem:this,matches:d.slice(e)});for(j=0;j0?this.on(b,null,a,c):this.trigger(b)},f.attrFn&&(f.attrFn[b]=!0),C.test(b)&&(f.event.fixHooks[b]=f.event.keyHooks),D.test(b)&&(f.event.fixHooks[b]=f.event.mouseHooks)}),function(){function x(a,b,c,e,f,g){for(var h=0,i=e.length;h0){k=j;break}}j=j[a]}e[h]=k}}}function w(a,b,c,e,f,g){for(var h=0,i=e.length;h+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,d="sizcache"+(Math.random()+"").replace(".",""),e=0,g=Object.prototype.toString,h=!1,i=!0,j=/\\/g,k=/\r\n/g,l=/\W/;[0,0].sort(function(){i=!1;return 0});var m=function(b,d,e,f){e=e||[],d=d||c;var h=d;if(d.nodeType!==1&&d.nodeType!==9)return[];if(!b||typeof b!="string")return e;var i,j,k,l,n,q,r,t,u=!0,v=m.isXML(d),w=[],x=b;do{a.exec(""),i=a.exec(x);if(i){x=i[3],w.push(i[1]);if(i[2]){l=i[3];break}}}while(i);if(w.length>1&&p.exec(b))if(w.length===2&&o.relative[w[0]])j=y(w[0]+w[1],d,f);else{j=o.relative[w[0]]?[d]:m(w.shift(),d);while(w.length)b=w.shift(),o.relative[b]&&(b+=w.shift()),j=y(b,j,f)}else{!f&&w.length>1&&d.nodeType===9&&!v&&o.match.ID.test(w[0])&&!o.match.ID.test(w[w.length-1])&&(n=m.find(w.shift(),d,v),d=n.expr?m.filter(n.expr,n.set)[0]:n.set[0]);if(d){n=f?{expr:w.pop(),set:s(f)}:m.find(w.pop(),w.length===1&&(w[0]==="~"||w[0]==="+")&&d.parentNode?d.parentNode:d,v),j=n.expr?m.filter(n.expr,n.set):n.set,w.length>0?k=s(j):u=!1;while(w.length)q=w.pop(),r=q,o.relative[q]?r=w.pop():q="",r==null&&(r=d),o.relative[q](k,r,v)}else k=w=[]}k||(k=j),k||m.error(q||b);if(g.call(k)==="[object Array]")if(!u)e.push.apply(e,k);else if(d&&d.nodeType===1)for(t=0;k[t]!=null;t++)k[t]&&(k[t]===!0||k[t].nodeType===1&&m.contains(d,k[t]))&&e.push(j[t]);else for(t=0;k[t]!=null;t++)k[t]&&k[t].nodeType===1&&e.push(j[t]);else s(k,e);l&&(m(l,h,e,f),m.uniqueSort(e));return e};m.uniqueSort=function(a){if(u){h=i,a.sort(u);if(h)for(var b=1;b0},m.find=function(a,b,c){var d,e,f,g,h,i;if(!a)return[];for(e=0,f=o.order.length;e":function(a,b){var c,d=typeof b=="string",e=0,f=a.length;if(d&&!l.test(b)){b=b.toLowerCase();for(;e=0)?c||d.push(h):c&&(b[g]=!1));return!1},ID:function(a){return a[1].replace(j,"")},TAG:function(a,b){return a[1].replace(j,"").toLowerCase()},CHILD:function(a){if(a[1]==="nth"){a[2]||m.error(a[0]),a[2]=a[2].replace(/^\+|\s*/g,"");var b=/(-?)(\d*)(?:n([+\-]?\d*))?/.exec(a[2]==="even"&&"2n"||a[2]==="odd"&&"2n+1"||!/\D/.test(a[2])&&"0n+"+a[2]||a[2]);a[2]=b[1]+(b[2]||1)-0,a[3]=b[3]-0}else a[2]&&m.error(a[0]);a[0]=e++;return a},ATTR:function(a,b,c,d,e,f){var g=a[1]=a[1].replace(j,"");!f&&o.attrMap[g]&&(a[1]=o.attrMap[g]),a[4]=(a[4]||a[5]||"").replace(j,""),a[2]==="~="&&(a[4]=" "+a[4]+" ");return a},PSEUDO:function(b,c,d,e,f){if(b[1]==="not")if((a.exec(b[3])||"").length>1||/^\w/.test(b[3]))b[3]=m(b[3],null,null,c);else{var g=m.filter(b[3],c,d,!0^f);d||e.push.apply(e,g);return!1}else if(o.match.POS.test(b[0])||o.match.CHILD.test(b[0]))return!0;return b},POS:function(a){a.unshift(!0);return a}},filters:{enabled:function(a){return a.disabled===!1&&a.type!=="hidden"},disabled:function(a){return a.disabled===!0},checked:function(a){return a.checked===!0},selected:function(a){a.parentNode&&a.parentNode.selectedIndex;return a.selected===!0},parent:function(a){return!!a.firstChild},empty:function(a){return!a.firstChild},has:function(a,b,c){return!!m(c[3],a).length},header:function(a){return/h\d/i.test(a.nodeName)},text:function(a){var b=a.getAttribute("type"),c=a.type;return a.nodeName.toLowerCase()==="input"&&"text"===c&&(b===c||b===null)},radio:function(a){return a.nodeName.toLowerCase()==="input"&&"radio"===a.type},checkbox:function(a){return a.nodeName.toLowerCase()==="input"&&"checkbox"===a.type},file:function(a){return a.nodeName.toLowerCase()==="input"&&"file"===a.type},password:function(a){return a.nodeName.toLowerCase()==="input"&&"password"===a.type},submit:function(a){var b=a.nodeName.toLowerCase();return(b==="input"||b==="button")&&"submit"===a.type},image:function(a){return a.nodeName.toLowerCase()==="input"&&"image"===a.type},reset:function(a){var b=a.nodeName.toLowerCase();return(b==="input"||b==="button")&&"reset"===a.type},button:function(a){var b=a.nodeName.toLowerCase();return b==="input"&&"button"===a.type||b==="button"},input:function(a){return/input|select|textarea|button/i.test(a.nodeName)},focus:function(a){return a===a.ownerDocument.activeElement}},setFilters:{first:function(a,b){return b===0},last:function(a,b,c,d){return b===d.length-1},even:function(a,b){return b%2===0},odd:function(a,b){return b%2===1},lt:function(a,b,c){return bc[3]-0},nth:function(a,b,c){return c[3]-0===b},eq:function(a,b,c){return c[3]-0===b}},filter:{PSEUDO:function(a,b,c,d){var e=b[1],f=o.filters[e];if(f)return f(a,c,b,d);if(e==="contains")return(a.textContent||a.innerText||n([a])||"").indexOf(b[3])>=0;if(e==="not"){var g=b[3];for(var h=0,i=g.length;h=0}},ID:function(a,b){return a.nodeType===1&&a.getAttribute("id")===b},TAG:function(a,b){return b==="*"&&a.nodeType===1||!!a.nodeName&&a.nodeName.toLowerCase()===b},CLASS:function(a,b){return(" "+(a.className||a.getAttribute("class"))+" ").indexOf(b)>-1},ATTR:function(a,b){var c=b[1],d=m.attr?m.attr(a,c):o.attrHandle[c]?o.attrHandle[c](a):a[c]!=null?a[c]:a.getAttribute(c),e=d+"",f=b[2],g=b[4];return d==null?f==="!=":!f&&m.attr?d!=null:f==="="?e===g:f==="*="?e.indexOf(g)>=0:f==="~="?(" "+e+" ").indexOf(g)>=0:g?f==="!="?e!==g:f==="^="?e.indexOf(g)===0:f==="$="?e.substr(e.length-g.length)===g:f==="|="?e===g||e.substr(0,g.length+1)===g+"-":!1:e&&d!==!1},POS:function(a,b,c,d){var e=b[2],f=o.setFilters[e];if(f)return f(a,c,b,d)}}},p=o.match.POS,q=function(a,b){return"\\"+(b-0+1)};for(var r in o.match)o.match[r]=new RegExp(o.match[r].source+/(?![^\[]*\])(?![^\(]*\))/.source),o.leftMatch[r]=new RegExp(/(^(?:.|\r|\n)*?)/.source+o.match[r].source.replace(/\\(\d+)/g,q));var s=function(a,b){a=Array.prototype.slice.call(a,0);if(b){b.push.apply(b,a);return b}return a};try{Array.prototype.slice.call(c.documentElement.childNodes,0)[0].nodeType}catch(t){s=function(a,b){var c=0,d=b||[];if(g.call(a)==="[object Array]")Array.prototype.push.apply(d,a);else if(typeof a.length=="number")for(var e=a.length;c",e.insertBefore(a,e.firstChild),c.getElementById(d)&&(o.find.ID=function(a,c,d){if(typeof c.getElementById!="undefined"&&!d){var e=c.getElementById(a[1]);return e?e.id===a[1]||typeof e.getAttributeNode!="undefined"&&e.getAttributeNode("id").nodeValue===a[1]?[e]:b:[]}},o.filter.ID=function(a,b){var c=typeof a.getAttributeNode!="undefined"&&a.getAttributeNode("id");return a.nodeType===1&&c&&c.nodeValue===b}),e.removeChild(a),e=a=null}(),function(){var a=c.createElement("div");a.appendChild(c.createComment("")),a.getElementsByTagName("*").length>0&&(o.find.TAG=function(a,b){var c=b.getElementsByTagName(a[1]);if(a[1]==="*"){var d=[];for(var e=0;c[e];e++)c[e].nodeType===1&&d.push(c[e]);c=d}return c}),a.innerHTML="",a.firstChild&&typeof a.firstChild.getAttribute!="undefined"&&a.firstChild.getAttribute("href")!=="#"&&(o.attrHandle.href=function(a){return a.getAttribute("href",2)}),a=null}(),c.querySelectorAll&&function(){var a=m,b=c.createElement("div"),d="__sizzle__";b.innerHTML="

";if(!b.querySelectorAll||b.querySelectorAll(".TEST").length!==0){m=function(b,e,f,g){e=e||c;if(!g&&!m.isXML(e)){var h=/^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec(b);if(h&&(e.nodeType===1||e.nodeType===9)){if(h[1])return s(e.getElementsByTagName(b),f);if(h[2]&&o.find.CLASS&&e.getElementsByClassName)return s(e.getElementsByClassName(h[2]),f)}if(e.nodeType===9){if(b==="body"&&e.body)return s([e.body],f);if(h&&h[3]){var i=e.getElementById(h[3]);if(!i||!i.parentNode)return s([],f);if(i.id===h[3])return s([i],f)}try{return s(e.querySelectorAll(b),f)}catch(j){}}else if(e.nodeType===1&&e.nodeName.toLowerCase()!=="object"){var k=e,l=e.getAttribute("id"),n=l||d,p=e.parentNode,q=/^\s*[+~]/.test(b);l?n=n.replace(/'/g,"\\$&"):e.setAttribute("id",n),q&&p&&(e=e.parentNode);try{if(!q||p)return s(e.querySelectorAll("[id='"+n+"'] "+b),f)}catch(r){}finally{l||k.removeAttribute("id")}}}return a(b,e,f,g)};for(var e in a)m[e]=a[e];b=null}}(),function(){var a=c.documentElement,b=a.matchesSelector||a.mozMatchesSelector||a.webkitMatchesSelector||a.msMatchesSelector;if(b){var d=!b.call(c.createElement("div"),"div"),e=!1;try{b.call(c.documentElement,"[test!='']:sizzle")}catch(f){e=!0}m.matchesSelector=function(a,c){c=c.replace(/\=\s*([^'"\]]*)\s*\]/g,"='$1']");if(!m.isXML(a))try{if(e||!o.match.PSEUDO.test(c)&&!/!=/.test(c)){var f=b.call(a,c);if(f||!d||a.document&&a.document.nodeType!==11)return f}}catch(g){}return m(c,null,null,[a]).length>0}}}(),function(){var a=c.createElement("div");a.innerHTML="
";if(!!a.getElementsByClassName&&a.getElementsByClassName("e").length!==0){a.lastChild.className="e";if(a.getElementsByClassName("e").length===1)return;o.order.splice(1,0,"CLASS"),o.find.CLASS=function(a,b,c){if(typeof b.getElementsByClassName!="undefined"&&!c)return b.getElementsByClassName(a[1])},a=null}}(),c.documentElement.contains?m.contains=function(a,b){return a!==b&&(a.contains?a.contains(b):!0)}:c.documentElement.compareDocumentPosition?m.contains=function(a,b){return!!(a.compareDocumentPosition(b)&16)}:m.contains=function(){return!1},m.isXML=function(a){var b=(a?a.ownerDocument||a:0).documentElement;return b?b.nodeName!=="HTML":!1};var y=function(a,b,c){var d,e=[],f="",g=b.nodeType?[b]:b;while(d=o.match.PSEUDO.exec(a))f+=d[0],a=a.replace(o.match.PSEUDO,"");a=o.relative[a]?a+"*":a;for(var h=0,i=g.length;h0)for(h=g;h=0:f.filter(a,this).length>0:this.filter(a).length>0)},closest:function(a,b){var c=[],d,e,g=this[0];if(f.isArray(a)){var h=1;while(g&&g.ownerDocument&&g!==b){for(d=0;d-1:f.find.matchesSelector(g,a)){c.push(g);break}g=g.parentNode;if(!g||!g.ownerDocument||g===b||g.nodeType===11)break}}c=c.length>1?f.unique(c):c;return this.pushStack(c,"closest",a)},index:function(a){if(!a)return this[0]&&this[0].parentNode?this.prevAll().length:-1;if(typeof a=="string")return f.inArray(this[0],f(a));return f.inArray(a.jquery?a[0]:a,this)},add:function(a,b){var c=typeof a=="string"?f(a,b):f.makeArray(a&&a.nodeType?[a]:a),d=f.merge(this.get(),c);return this.pushStack(S(c[0])||S(d[0])?d:f.unique(d))},andSelf:function(){return this.add(this.prevObject)}}),f.each({parent:function(a){var b=a.parentNode;return b&&b.nodeType!==11?b:null},parents:function(a){return f.dir(a,"parentNode")},parentsUntil:function(a,b,c){return f.dir(a,"parentNode",c)},next:function(a){return f.nth(a,2,"nextSibling")},prev:function(a){return f.nth(a,2,"previousSibling")},nextAll:function(a){return f.dir(a,"nextSibling")},prevAll:function(a){return f.dir(a,"previousSibling")},nextUntil:function(a,b,c){return f.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return f.dir(a,"previousSibling",c)},siblings:function(a){return f.sibling(a.parentNode.firstChild,a)},children:function(a){return f.sibling(a.firstChild)},contents:function(a){return f.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:f.makeArray(a.childNodes)}},function(a,b){f.fn[a]=function(c,d){var e=f.map(this,b,c);L.test(a)||(d=c),d&&typeof d=="string"&&(e=f.filter(d,e)),e=this.length>1&&!R[a]?f.unique(e):e,(this.length>1||N.test(d))&&M.test(a)&&(e=e.reverse());return this.pushStack(e,a,P.call(arguments).join(","))}}),f.extend({filter:function(a,b,c){c&&(a=":not("+a+")");return b.length===1?f.find.matchesSelector(b[0],a)?[b[0]]:[]:f.find.matches(a,b)},dir:function(a,c,d){var e=[],g=a[c];while(g&&g.nodeType!==9&&(d===b||g.nodeType!==1||!f(g).is(d)))g.nodeType===1&&e.push(g),g=g[c];return e},nth:function(a,b,c,d){b=b||1;var e=0;for(;a;a=a[c])if(a.nodeType===1&&++e===b)break;return a},sibling:function(a,b){var c=[];for(;a;a=a.nextSibling)a.nodeType===1&&a!==b&&c.push(a);return c}});var V="abbr|article|aside|audio|canvas|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",W=/ jQuery\d+="(?:\d+|null)"/g,X=/^\s+/,Y=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,Z=/<([\w:]+)/,$=/",""],legend:[1,"
","
"],thead:[1,"","
"],tr:[2,"","
"],td:[3,"","
"],col:[2,"","
"],area:[1,"",""],_default:[0,"",""]},bh=U(c);bg.optgroup=bg.option,bg.tbody=bg.tfoot=bg.colgroup=bg.caption=bg.thead,bg.th=bg.td,f.support.htmlSerialize||(bg._default=[1,"div
","
"]),f.fn.extend({text:function(a){if(f.isFunction(a))return this.each(function(b){var c=f(this);c.text(a.call(this,b,c.text()))});if(typeof a!="object"&&a!==b)return this.empty().append((this[0]&&this[0].ownerDocument||c).createTextNode(a));return f.text(this)},wrapAll:function(a){if(f.isFunction(a))return this.each(function(b){f(this).wrapAll(a.call(this,b))});if(this[0]){var b=f(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&a.firstChild.nodeType===1)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){if(f.isFunction(a))return this.each(function(b){f(this).wrapInner(a.call(this,b))});return this.each(function(){var b=f(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=f.isFunction(a);return this.each(function(c){f(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(){return this.parent().each(function(){f.nodeName(this,"body")||f(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,!0,function(a){this.nodeType===1&&this.appendChild(a)})},prepend:function(){return this.domManip(arguments,!0,function(a){this.nodeType===1&&this.insertBefore(a,this.firstChild)})},before:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this)});if(arguments.length){var a=f.clean(arguments);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this.nextSibling)});if(arguments.length){var a=this.pushStack(this,"after",arguments);a.push.apply(a,f.clean(arguments));return a}},remove:function(a,b){for(var c=0,d;(d=this[c])!=null;c++)if(!a||f.filter(a,[d]).length)!b&&d.nodeType===1&&(f.cleanData(d.getElementsByTagName("*")), f.cleanData([d])),d.parentNode&&d.parentNode.removeChild(d);return this},empty:function() {for(var a=0,b;(b=this[a])!=null;a++){b.nodeType===1&&f.cleanData(b.getElementsByTagName("*"));while(b.firstChild)b.removeChild(b.firstChild)}return this},clone:function(a,b){a=a==null?!1:a,b=b==null?a:b;return this.map(function(){return f.clone(this,a,b)})},html:function(a){if(a===b)return this[0]&&this[0].nodeType===1?this[0].innerHTML.replace(W,""):null;if(typeof a=="string"&&!ba.test(a)&&(f.support.leadingWhitespace||!X.test(a))&&!bg[(Z.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(Y,"<$1>");try{for(var c=0,d=this.length;c1&&l0?this.clone(!0):this).get();f(e[h])[b](j),d=d.concat(j)}return this.pushStack(d,a,e.selector)}}),f.extend({clone:function(a,b,c){var d,e,g,h=f.support.html5Clone||!bc.test("<"+a.nodeName)?a.cloneNode(!0):bo(a);if((!f.support.noCloneEvent||!f.support.noCloneChecked)&&(a.nodeType===1||a.nodeType===11)&&!f.isXMLDoc(a)){bk(a,h),d=bl(a),e=bl(h);for(g=0;d[g];++g)e[g]&&bk(d[g],e[g])}if(b){bj(a,h);if(c){d=bl(a),e=bl(h);for(g=0;d[g];++g)bj(d[g],e[g])}}d=e=null;return h},clean:function(a,b,d,e){var g;b=b||c,typeof b.createElement=="undefined"&&(b=b.ownerDocument||b[0]&&b[0].ownerDocument||c);var h=[],i;for(var j=0,k;(k=a[j])!=null;j++){typeof k=="number"&&(k+="");if(!k)continue;if(typeof k=="string")if(!_.test(k))k=b.createTextNode(k);else{k=k.replace(Y,"<$1>");var l=(Z.exec(k)||["",""])[1].toLowerCase(),m=bg[l]||bg._default,n=m[0],o=b.createElement("div");b===c?bh.appendChild(o):U(b).appendChild(o),o.innerHTML=m[1]+k+m[2];while(n--)o=o.lastChild;if(!f.support.tbody){var p=$.test(k),q=l==="table"&&!p?o.firstChild&&o.firstChild.childNodes:m[1]===""&&!p?o.childNodes:[];for(i=q.length-1;i>=0;--i)f.nodeName(q[i],"tbody")&&!q[i].childNodes.length&&q[i].parentNode.removeChild(q[i])}!f.support.leadingWhitespace&&X.test(k)&&o.insertBefore(b.createTextNode(X.exec(k)[0]),o.firstChild),k=o.childNodes}var r;if(!f.support.appendChecked)if(k[0]&&typeof (r=k.length)=="number")for(i=0;i=0)return b+"px"}}}),f.support.opacity||(f.cssHooks.opacity={get:function(a,b){return br.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?parseFloat(RegExp.$1)/100+"":b?"1":""},set:function(a,b){var c=a.style,d=a.currentStyle,e=f.isNumeric(b)?"alpha(opacity="+b*100+")":"",g=d&&d.filter||c.filter||"";c.zoom=1;if(b>=1&&f.trim(g.replace(bq,""))===""){c.removeAttribute("filter");if(d&&!d.filter)return}c.filter=bq.test(g)?g.replace(bq,e):g+" "+e}}),f(function(){f.support.reliableMarginRight||(f.cssHooks.marginRight={get:function(a,b){var c;f.swap(a,{display:"inline-block"},function(){b?c=bz(a,"margin-right","marginRight"):c=a.style.marginRight});return c}})}),c.defaultView&&c.defaultView.getComputedStyle&&(bA=function(a,b){var c,d,e;b=b.replace(bs,"-$1").toLowerCase(),(d=a.ownerDocument.defaultView)&&(e=d.getComputedStyle(a,null))&&(c=e.getPropertyValue(b),c===""&&!f.contains(a.ownerDocument.documentElement,a)&&(c=f.style(a,b)));return c}),c.documentElement.currentStyle&&(bB=function(a,b){var c,d,e,f=a.currentStyle&&a.currentStyle[b],g=a.style;f===null&&g&&(e=g[b])&&(f=e),!bt.test(f)&&bu.test(f)&&(c=g.left,d=a.runtimeStyle&&a.runtimeStyle.left,d&&(a.runtimeStyle.left=a.currentStyle.left),g.left=b==="fontSize"?"1em":f||0,f=g.pixelLeft+"px",g.left=c,d&&(a.runtimeStyle.left=d));return f===""?"auto":f}),bz=bA||bB,f.expr&&f.expr.filters&&(f.expr.filters.hidden=function(a){var b=a.offsetWidth,c=a.offsetHeight;return b===0&&c===0||!f.support.reliableHiddenOffsets&&(a.style&&a.style.display||f.css(a,"display"))==="none"},f.expr.filters.visible=function(a){return!f.expr.filters.hidden(a)});var bD=/%20/g,bE=/\[\]$/,bF=/\r?\n/g,bG=/#.*$/,bH=/^(.*?):[ \t]*([^\r\n]*)\r?$/mg,bI=/^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,bJ=/^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,bK=/^(?:GET|HEAD)$/,bL=/^\/\//,bM=/\?/,bN=/)<[^<]*)*<\/script>/gi,bO=/^(?:select|textarea)/i,bP=/\s+/,bQ=/([?&])_=[^&]*/,bR=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,bS=f.fn.load,bT={},bU={},bV,bW,bX=["*/"]+["*"];try{bV=e.href}catch(bY){bV=c.createElement("a"),bV.href="",bV=bV.href}bW=bR.exec(bV.toLowerCase())||[],f.fn.extend({load:function(a,c,d){if(typeof a!="string"&&bS)return bS.apply(this,arguments);if(!this.length)return this;var e=a.indexOf(" ");if(e>=0){var g=a.slice(e,a.length);a=a.slice(0,e)}var h="GET";c&&(f.isFunction(c)?(d=c,c=b):typeof c=="object"&&(c=f.param(c,f.ajaxSettings.traditional),h="POST"));var i=this;f.ajax({url:a,type:h,dataType:"html",data:c,complete:function(a,b,c){c=a.responseText,a.isResolved()&&(a.done(function(a){c=a}),i.html(g?f("
").append(c.replace(bN,"")).find(g):c)),d&&i.each(d,[c,b,a])}});return this},serialize:function(){return f.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?f.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||bO.test(this.nodeName)||bI.test(this.type))}).map(function(a,b){var c=f(this).val();return c==null?null:f.isArray(c)?f.map(c,function(a,c){return{name:b.name,value:a.replace(bF,"\r\n")}}):{name:b.name,value:c.replace(bF,"\r\n")}}).get()}}),f.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){f.fn[b]=function(a){return this.on(b,a)}}),f.each(["get","post"],function(a,c){f[c]=function(a,d,e,g){f.isFunction(d)&&(g=g||e,e=d,d=b);return f.ajax({type:c,url:a,data:d,success:e,dataType:g})}}),f.extend({getScript:function(a,c){return f.get(a,b,c,"script")},getJSON:function(a,b,c){return f.get(a,b,c,"json")},ajaxSetup:function(a,b){b?b_(a,f.ajaxSettings):(b=a,a=f.ajaxSettings),b_(a,b);return a},ajaxSettings:{url:bV,isLocal:bJ.test(bW[1]),global:!0,type:"GET",contentType:"application/x-www-form-urlencoded",processData:!0,async:!0,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":bX},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":a.String,"text html":!0,"text json":f.parseJSON,"text xml":f.parseXML},flatOptions:{context:!0,url:!0}},ajaxPrefilter:bZ(bT),ajaxTransport:bZ(bU),ajax:function(a,c){function w(a,c,l,m){if(s!==2){s=2,q&&clearTimeout(q),p=b,n=m||"",v.readyState=a>0?4:0;var o,r,u,w=c,x=l?cb(d,v,l):b,y,z;if(a>=200&&a<300||a===304){if(d.ifModified){if(y=v.getResponseHeader("Last-Modified"))f.lastModified[k]=y;if(z=v.getResponseHeader("Etag"))f.etag[k]=z}if(a===304)w="notmodified",o=!0;else try{r=cc(d,x),w="success",o=!0}catch(A){w="parsererror",u=A}}else{u=w;if(!w||a)w="error",a<0&&(a=0)}v.status=a,v.statusText=""+(c||w),o?h.resolveWith(e,[r,w,v]):h.rejectWith(e,[v,w,u]),v.statusCode(j),j=b,t&&g.trigger("ajax"+(o?"Success":"Error"),[v,d,o?r:u]),i.fireWith(e,[v,w]),t&&(g.trigger("ajaxComplete",[v,d]),--f.active||f.event.trigger("ajaxStop"))}}typeof a=="object"&&(c=a,a=b),c=c||{};var d=f.ajaxSetup({},c),e=d.context||d,g=e!==d&&(e.nodeType||e instanceof f)?f(e):f.event,h=f.Deferred(),i=f.Callbacks("once memory"),j=d.statusCode||{},k,l={},m={},n,o,p,q,r,s=0,t,u,v={readyState:0,setRequestHeader:function(a,b){if(!s){var c=a.toLowerCase();a=m[c]=m[c]||a,l[a]=b}return this},getAllResponseHeaders:function(){return s===2?n:null},getResponseHeader:function(a){var c;if(s===2){if(!o){o={};while(c=bH.exec(n))o[c[1].toLowerCase()]=c[2]}c=o[a.toLowerCase()]}return c===b?null:c},overrideMimeType:function(a){s||(d.mimeType=a);return this},abort:function(a){a=a||"abort",p&&p.abort(a),w(0,a);return this}};h.promise(v),v.success=v.done,v.error=v.fail,v.complete=i.add,v.statusCode=function(a){if(a){var b;if(s<2)for(b in a)j[b]=[j[b],a[b]];else b=a[v.status],v.then(b,b)}return this},d.url=((a||d.url)+"").replace(bG,"").replace(bL,bW[1]+"//"),d.dataTypes=f.trim(d.dataType||"*").toLowerCase().split(bP),d.crossDomain==null&&(r=bR.exec(d.url.toLowerCase()),d.crossDomain=!(!r||r[1]==bW[1]&&r[2]==bW[2]&&(r[3]||(r[1]==="http:"?80:443))==(bW[3]||(bW[1]==="http:"?80:443)))),d.data&&d.processData&&typeof d.data!="string"&&(d.data=f.param(d.data,d.traditional)),b$(bT,d,c,v);if(s===2)return!1;t=d.global,d.type=d.type.toUpperCase(),d.hasContent=!bK.test(d.type),t&&f.active++===0&&f.event.trigger("ajaxStart");if(!d.hasContent){d.data&&(d.url+=(bM.test(d.url)?"&":"?")+d.data,delete d.data),k=d.url;if(d.cache===!1){var x=f.now(),y=d.url.replace(bQ,"$1_="+x);d.url=y+(y===d.url?(bM.test(d.url)?"&":"?")+"_="+x:"")}}(d.data&&d.hasContent&&d.contentType!==!1||c.contentType)&&v.setRequestHeader("Content-Type",d.contentType),d.ifModified&&(k=k||d.url,f.lastModified[k]&&v.setRequestHeader("If-Modified-Since",f.lastModified[k]),f.etag[k]&&v.setRequestHeader("If-None-Match",f.etag[k])),v.setRequestHeader("Accept",d.dataTypes[0]&&d.accepts[d.dataTypes[0]]?d.accepts[d.dataTypes[0]]+(d.dataTypes[0]!=="*"?", "+bX+"; q=0.01":""):d.accepts["*"]);for(u in d.headers)v.setRequestHeader(u,d.headers[u]);if(d.beforeSend&&(d.beforeSend.call(e,v,d)===!1||s===2)){v.abort();return!1}for(u in{success:1,error:1,complete:1})v[u](d[u]);p=b$(bU,d,c,v);if(!p)w(-1,"No Transport");else{v.readyState=1,t&&g.trigger("ajaxSend",[v,d]),d.async&&d.timeout>0&&(q=setTimeout(function(){v.abort("timeout")},d.timeout));try{s=1,p.send(l,w)}catch(z){if(s<2)w(-1,z);else throw z}}return v},param:function(a,c){var d=[],e=function(a,b){b=f.isFunction(b)?b():b,d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};c===b&&(c=f.ajaxSettings.traditional);if(f.isArray(a)||a.jquery&&!f.isPlainObject(a))f.each(a,function(){e(this.name,this.value)});else for(var g in a)ca(g,a[g],c,e);return d.join("&").replace(bD,"+")}}),f.extend({active:0,lastModified:{},etag:{}});var cd=f.now(),ce=/(\=)\?(&|$)|\?\?/i;f.ajaxSetup({jsonp:"callback",jsonpCallback:function(){return f.expando+"_"+cd++}}),f.ajaxPrefilter("json jsonp",function(b,c,d){var e=b.contentType==="application/x-www-form-urlencoded"&&typeof b.data=="string";if(b.dataTypes[0]==="jsonp"||b.jsonp!==!1&&(ce.test(b.url)||e&&ce.test(b.data))){var g,h=b.jsonpCallback=f.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,i=a[h],j=b.url,k=b.data,l="$1"+h+"$2";b.jsonp!==!1&&(j=j.replace(ce,l),b.url===j&&(e&&(k=k.replace(ce,l)),b.data===k&&(j+=(/\?/.test(j)?"&":"?")+b.jsonp+"="+h))),b.url=j,b.data=k,a[h]=function(a){g=[a]},d.always(function(){a[h]=i,g&&f.isFunction(i)&&a[h](g[0])}),b.converters["script json"]=function(){g||f.error(h+" was not called");return g[0]},b.dataTypes[0]="json";return"script"}}),f.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/javascript|ecmascript/},converters:{"text script":function(a){f.globalEval(a);return a}}}),f.ajaxPrefilter("script",function(a){a.cache===b&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),f.ajaxTransport("script",function(a){if(a.crossDomain){var d,e=c.head||c.getElementsByTagName("head")[0]||c.documentElement;return{send:function(f,g){d=c.createElement("script"),d.async="async",a.scriptCharset&&(d.charset=a.scriptCharset),d.src=a.url,d.onload=d.onreadystatechange=function(a,c){if(c||!d.readyState||/loaded|complete/.test(d.readyState))d.onload=d.onreadystatechange=null,e&&d.parentNode&&e.removeChild(d),d=b,c||g(200,"success")},e.insertBefore(d,e.firstChild)},abort:function(){d&&d.onload(0,1)}}}});var cf=a.ActiveXObject?function(){for(var a in ch)ch[a](0,1)}:!1,cg=0,ch;f.ajaxSettings.xhr=a.ActiveXObject?function(){return!this.isLocal&&ci()||cj()}:ci,function(a){f.extend(f.support,{ajax:!!a,cors:!!a&&"withCredentials"in a})}(f.ajaxSettings.xhr()),f.support.ajax&&f.ajaxTransport(function(c) {if(!c.crossDomain||f.support.cors){var d;return{send:function(e,g){var h=c.xhr(),i,j;c.username?h.open(c.type,c.url,c.async,c.username,c.password):h.open(c.type,c.url,c.async);if(c.xhrFields)for(j in c.xhrFields)h[j]=c.xhrFields[j];c.mimeType&&h.overrideMimeType&&h.overrideMimeType(c.mimeType),!c.crossDomain&&!e["X-Requested-With"]&&(e["X-Requested-With"]="XMLHttpRequest");try{for(j in e)h.setRequestHeader(j,e[j])}catch(k){}h.send(c.hasContent&&c.data||null),d=function(a,e){var j,k,l,m,n;try{if(d&&(e||h.readyState===4)){d=b,i&&(h.onreadystatechange=f.noop,cf&&delete ch[i]);if(e)h.readyState!==4&&h.abort();else{j=h.status,l=h.getAllResponseHeaders(),m={},n=h.responseXML,n&&n.documentElement&&(m.xml=n),m.text=h.responseText;try{k=h.statusText}catch(o){k=""}!j&&c.isLocal&&!c.crossDomain?j=m.text?200:404:j===1223&&(j=204)}}}catch(p){e||g(-1,p)}m&&g(j,k,m,l)},!c.async||h.readyState===4?d():(i=++cg,cf&&(ch||(ch={},f(a).unload(cf)),ch[i]=d),h.onreadystatechange=d)},abort:function(){d&&d(0,1)}}}});var ck={},cl,cm,cn=/^(?:toggle|show|hide)$/,co=/^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,cp,cq=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]],cr;f.fn.extend({show:function(a,b,c){var d,e;if(a||a===0)return this.animate(cu("show",3),a,b,c);for(var g=0,h=this.length;g=i.duration+this.startTime){this.now=this.end,this.pos=this.state=1,this.update(),i.animatedProperties[this.prop]=!0;for(b in i.animatedProperties)i.animatedProperties[b]!==!0&&(g=!1);if(g){i.overflow!=null&&!f.support.shrinkWrapBlocks&&f.each(["","X","Y"],function(a,b){h.style["overflow"+b]=i.overflow[a]}),i.hide&&f(h).hide();if(i.hide||i.show)for(b in i.animatedProperties)f.style(h,b,i.orig[b]),f.removeData(h,"fxshow"+b,!0),f.removeData(h,"toggle"+b,!0);d=i.complete,d&&(i.complete=!1,d.call(h))}return!1}i.duration==Infinity?this.now=e:(c=e-this.startTime,this.state=c/i.duration,this.pos=f.easing[i.animatedProperties[this.prop]](this.state,c,0,1,i.duration),this.now=this.start+(this.end-this.start)*this.pos),this.update();return!0}},f.extend(f.fx,{tick:function(){var a,b=f.timers,c=0;for(;c-1,k={},l={},m,n;j?(l=e.position(),m=l.top,n=l.left):(m=parseFloat(h)||0,n=parseFloat(i)||0),f.isFunction(b)&&(b=b.call(a,c,g)),b.top!=null&&(k.top=b.top-g.top+m),b.left!=null&&(k.left=b.left-g.left+n),"using"in b?b.using.call(a,k):e.css(k)}},f.fn.extend({position:function(){if(!this[0])return null;var a=this[0],b=this.offsetParent(),c=this.offset(),d=cx.test(b[0].nodeName)?{top:0,left:0}:b.offset();c.top-=parseFloat(f.css(a,"marginTop"))||0,c.left-=parseFloat(f.css(a,"marginLeft"))||0,d.top+=parseFloat(f.css(b[0],"borderTopWidth"))||0,d.left+=parseFloat(f.css(b[0],"borderLeftWidth"))||0;return{top:c.top-d.top,left:c.left-d.left}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||c.body;while(a&&!cx.test(a.nodeName)&&f.css(a,"position")==="static")a=a.offsetParent;return a})}}),f.each(["Left","Top"],function(a,c){var d="scroll"+c;f.fn[d]=function(c){var e,g;if(c===b){e=this[0];if(!e)return null;g=cy(e);return g?"pageXOffset"in g?g[a?"pageYOffset":"pageXOffset"]:f.support.boxModel&&g.document.documentElement[d]||g.document.body[d]:e[d]}return this.each(function(){g=cy(this),g?g.scrollTo(a?f(g).scrollLeft():c,a?c:f(g).scrollTop()):this[d]=c})}}),f.each(["Height","Width"],function(a,c){var d=c.toLowerCase();f.fn["inner"+c]=function(){var a=this[0];return a?a.style?parseFloat(f.css(a,d,"padding")):this[d]():null},f.fn["outer"+c]=function(a){var b=this[0];return b?b.style?parseFloat(f.css(b,d,a?"margin":"border")):this[d]():null},f.fn[d]=function(a){var e=this[0];if(!e)return a==null?null:this;if(f.isFunction(a))return this.each(function(b){var c=f(this);c[d](a.call(this,b,c[d]()))});if(f.isWindow(e)){var g=e.document.documentElement["client"+c],h=e.document.body;return e.document.compatMode==="CSS1Compat"&&g||h&&h["client"+c]||g}if(e.nodeType===9)return Math.max(e.documentElement["client"+c],e.body["scroll"+c],e.documentElement["scroll"+c],e.body["offset"+c],e.documentElement["offset"+c]);if(a===b){var i=f.css(e,d),j=parseFloat(i);return f.isNumeric(j)?j:i}return this.css(d,typeof a=="string"?a:a+"px")}}),a.jQuery=a.$=f,typeof define=="function"&&define.amd&&define.amd.jQuery&&define("jquery",[],function(){return f})})(window); json-c-json-c-0.17-20230812/doc/html/json_8h.html000066400000000000000000000047461446575330000207110ustar00rootroot00000000000000 json-c: /home/erh/distcheck/json.h File Reference
json-c  0.17
json.h File Reference

A convenience header that may be included instead of other individual ones. More...

Detailed Description

A convenience header that may be included instead of other individual ones.

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/json__c__version_8h.html000066400000000000000000000244531446575330000232530ustar00rootroot00000000000000 json-c: json_c_version.h File Reference
Macros | Functions
json_c_version.h File Reference

Methods for retrieving the json-c version. More...

Macros

#define JSON_C_MAJOR_VERSION   0
 
#define JSON_C_MINOR_VERSION   17
 
#define JSON_C_MICRO_VERSION   0
 
#define JSON_C_VERSION_NUM   ((JSON_C_MAJOR_VERSION << 16) | (JSON_C_MINOR_VERSION << 8) | JSON_C_MICRO_VERSION)
 
#define JSON_C_VERSION   "0.17"
 
#define JSON_EXPORT   extern
 

Functions

JSON_EXPORT const char * json_c_version (void)
 
JSON_EXPORT int json_c_version_num (void)
 

Detailed Description

Methods for retrieving the json-c version.

Macro Definition Documentation

#define JSON_C_MAJOR_VERSION   0
#define JSON_C_MICRO_VERSION   0
#define JSON_C_MINOR_VERSION   17
#define JSON_C_VERSION   "0.17"
#define JSON_C_VERSION_NUM   ((JSON_C_MAJOR_VERSION << 16) | (JSON_C_MINOR_VERSION << 8) | JSON_C_MICRO_VERSION)
#define JSON_EXPORT   extern

Function Documentation

JSON_EXPORT const char* json_c_version ( void  )
See Also
JSON_C_VERSION
Returns
the version of the json-c library as a string
JSON_EXPORT int json_c_version_num ( void  )

The json-c version encoded into an int, with the low order 8 bits being the micro version, the next higher 8 bits being the minor version and the next higher 8 bits being the major version. For example, 7.12.99 would be 0x00070B63.

See Also
JSON_C_VERSION_NUM
Returns
the version of the json-c library as an int
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/json__inttypes_8h.html000066400000000000000000000175441446575330000230070ustar00rootroot00000000000000 json-c: json_inttypes.h File Reference
Macros | Typedefs
json_inttypes.h File Reference

Do not use, json-c internal, may be changed or removed at any time. More...

Macros

#define PRId64   "I64d"
 
#define SCNd64   "I64d"
 
#define PRIu64   "I64u"
 

Typedefs

typedef __int32 int32_t
 
typedef unsigned __int32 uint32_t
 
typedef __int64 int64_t
 
typedef unsigned __int64 uint64_t
 

Detailed Description

Do not use, json-c internal, may be changed or removed at any time.

Macro Definition Documentation

#define PRId64   "I64d"
#define PRIu64   "I64u"
#define SCNd64   "I64d"

Typedef Documentation

typedef __int32 int32_t
typedef __int64 int64_t
typedef unsigned __int32 uint32_t
typedef unsigned __int64 uint64_t
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/json__object_8h.html000066400000000000000000005060501446575330000223710ustar00rootroot00000000000000 json-c: json_object.h File Reference
Macros | Typedefs | Functions | Variables
json_object.h File Reference

Core json-c API. Start here, or with json_tokener.h. More...

Macros

#define JSON_C_CONST_FUNCTION(func)   func
 
#define JSON_OBJECT_DEF_HASH_ENTRIES   16
 
#define JSON_C_TO_STRING_PLAIN   0
 
#define JSON_C_TO_STRING_SPACED   (1 << 0)
 
#define JSON_C_TO_STRING_PRETTY   (1 << 1)
 
#define JSON_C_TO_STRING_PRETTY_TAB   (1 << 3)
 
#define JSON_C_TO_STRING_NOZERO   (1 << 2)
 
#define JSON_C_TO_STRING_NOSLASHESCAPE   (1 << 4)
 
#define JSON_C_TO_STRING_COLOR   (1 << 5)
 
#define JSON_C_OBJECT_ADD_KEY_IS_NEW   (1 << 1)
 
#define JSON_C_OBJECT_ADD_CONSTANT_KEY   (1 << 2)
 
#define JSON_C_OBJECT_KEY_IS_CONSTANT   JSON_C_OBJECT_ADD_CONSTANT_KEY
 
#define JSON_C_OPTION_GLOBAL   (0)
 
#define JSON_C_OPTION_THREAD   (1)
 
#define json_object_object_foreach(obj, key, val)
 
#define json_object_object_foreachC(obj, iter)
 

Typedefs

typedef int( json_c_shallow_copy_fn )(json_object *src, json_object *parent, const char *key, size_t index, json_object **dst)
 

Functions

JSON_EXPORT struct json_object * json_object_get (struct json_object *obj)
 
JSON_EXPORT int json_object_put (struct json_object *obj)
 
JSON_EXPORT int json_object_is_type (const struct json_object *obj, enum json_type type)
 
JSON_EXPORT enum json_type json_object_get_type (const struct json_object *obj)
 
JSON_EXPORT const char * json_object_to_json_string (struct json_object *obj)
 
JSON_EXPORT const char * json_object_to_json_string_ext (struct json_object *obj, int flags)
 
JSON_EXPORT const char * json_object_to_json_string_length (struct json_object *obj, int flags, size_t *length)
 
JSON_EXPORT void * json_object_get_userdata (json_object *jso)
 
JSON_EXPORT void json_object_set_userdata (json_object *jso, void *userdata, json_object_delete_fn *user_delete)
 
JSON_EXPORT void json_object_set_serializer (json_object *jso, json_object_to_json_string_fn *to_string_func, void *userdata, json_object_delete_fn *user_delete)
 
JSON_EXPORT struct json_object * json_object_new_object (void)
 
JSON_EXPORT struct lh_table * json_object_get_object (const struct json_object *obj)
 
JSON_EXPORT int json_object_object_length (const struct json_object *obj)
 
size_t json_c_object_sizeof (void)
 
JSON_EXPORT int json_object_object_add (struct json_object *obj, const char *key, struct json_object *val)
 
JSON_EXPORT int json_object_object_add_ex (struct json_object *obj, const char *const key, struct json_object *const val, const unsigned opts)
 
JSON_EXPORT struct json_object * json_object_object_get (const struct json_object *obj, const char *key)
 
JSON_EXPORT json_bool json_object_object_get_ex (const struct json_object *obj, const char *key, struct json_object **value)
 
JSON_EXPORT void json_object_object_del (struct json_object *obj, const char *key)
 
JSON_EXPORT struct json_object * json_object_new_array (void)
 
JSON_EXPORT struct json_object * json_object_new_array_ext (int initial_size)
 
JSON_EXPORT struct array_list * json_object_get_array (const struct json_object *obj)
 
JSON_EXPORT size_t json_object_array_length (const struct json_object *obj)
 
JSON_EXPORT void json_object_array_sort (struct json_object *jso, int(*sort_fn)(const void *, const void *))
 
JSON_EXPORT struct json_object * json_object_array_bsearch (const struct json_object *key, const struct json_object *jso, int(*sort_fn)(const void *, const void *))
 
JSON_EXPORT int json_object_array_add (struct json_object *obj, struct json_object *val)
 
JSON_EXPORT int json_object_array_put_idx (struct json_object *obj, size_t idx, struct json_object *val)
 
JSON_EXPORT int json_object_array_insert_idx (struct json_object *obj, size_t idx, struct json_object *val)
 
JSON_EXPORT struct json_object * json_object_array_get_idx (const struct json_object *obj, size_t idx)
 
JSON_EXPORT int json_object_array_del_idx (struct json_object *obj, size_t idx, size_t count)
 
JSON_EXPORT int json_object_array_shrink (struct json_object *jso, int empty_slots)
 
JSON_EXPORT struct json_object * json_object_new_boolean (json_bool b)
 
JSON_EXPORT json_bool json_object_get_boolean (const struct json_object *obj)
 
JSON_EXPORT int json_object_set_boolean (struct json_object *obj, json_bool new_value)
 
JSON_EXPORT struct json_object * json_object_new_int (int32_t i)
 
JSON_EXPORT struct json_object * json_object_new_int64 (int64_t i)
 
JSON_EXPORT struct json_object * json_object_new_uint64 (uint64_t i)
 
JSON_EXPORT int32_t json_object_get_int (const struct json_object *obj)
 
JSON_EXPORT int json_object_set_int (struct json_object *obj, int new_value)
 
JSON_EXPORT int json_object_int_inc (struct json_object *obj, int64_t val)
 
JSON_EXPORT int64_t json_object_get_int64 (const struct json_object *obj)
 
JSON_EXPORT uint64_t json_object_get_uint64 (const struct json_object *obj)
 
JSON_EXPORT int json_object_set_int64 (struct json_object *obj, int64_t new_value)
 
JSON_EXPORT int json_object_set_uint64 (struct json_object *obj, uint64_t new_value)
 
JSON_EXPORT struct json_object * json_object_new_double (double d)
 
JSON_EXPORT struct json_object * json_object_new_double_s (double d, const char *ds)
 
JSON_EXPORT int json_c_set_serialization_double_format (const char *double_format, int global_or_thread)
 
JSON_EXPORT int json_object_double_to_json_string (struct json_object *jso, struct printbuf *pb, int level, int flags)
 
JSON_EXPORT double json_object_get_double (const struct json_object *obj)
 
JSON_EXPORT int json_object_set_double (struct json_object *obj, double new_value)
 
JSON_EXPORT struct json_object * json_object_new_string (const char *s)
 
JSON_EXPORT struct json_object * json_object_new_string_len (const char *s, const int len)
 
JSON_EXPORT const char * json_object_get_string (struct json_object *obj)
 
JSON_EXPORT int json_object_get_string_len (const struct json_object *obj)
 
JSON_EXPORT int json_object_set_string (json_object *obj, const char *new_value)
 
JSON_EXPORT int json_object_set_string_len (json_object *obj, const char *new_value, int len)
 
JSON_EXPORT struct json_object * json_object_new_null (void)
 
JSON_EXPORT int json_object_equal (struct json_object *obj1, struct json_object *obj2)
 
JSON_EXPORT int json_object_deep_copy (struct json_object *src, struct json_object **dst, json_c_shallow_copy_fn *shallow_copy)
 

Variables

JSON_EXPORT json_object_delete_fn json_object_free_userdata
 
JSON_EXPORT
json_object_to_json_string_fn 		json_object_userdata_to_json_string
 
JSON_EXPORT json_c_shallow_copy_fn json_c_shallow_copy_default
 

Detailed Description

Core json-c API. Start here, or with json_tokener.h.

Macro Definition Documentation

#define JSON_C_CONST_FUNCTION (   func)    func
#define JSON_C_OBJECT_ADD_CONSTANT_KEY   (1 << 2)

A flag for the json_object_object_add_ex function which flags the key as being constant memory. This means that the key will NOT be copied via strdup(), resulting in a potentially huge performance win (malloc, strdup and free are usually performance hogs). It is acceptable to use this flag for keys in non-constant memory blocks if the caller ensure that the memory holding the key lives longer than the corresponding json object. However, this is somewhat dangerous and should only be done if really justified. The general use-case for this flag is cases where the key is given as a real constant value in the function call, e.g. as in json_object_object_add_ex(obj, "ip", json, JSON_C_OBJECT_ADD_CONSTANT_KEY);

#define JSON_C_OBJECT_ADD_KEY_IS_NEW   (1 << 1)

A flag for the json_object_object_add_ex function which causes the value to be added without a check if it already exists. Note: it is the responsibility of the caller to ensure that no key is added multiple times. If this is done, results are unpredictable. While this option is somewhat dangerous, it permits potentially large performance savings in code that knows for sure the key values are unique (e.g. because the code adds a well-known set of constant key values).

#define JSON_C_OBJECT_KEY_IS_CONSTANT   JSON_C_OBJECT_ADD_CONSTANT_KEY

This flag is an alias to JSON_C_OBJECT_ADD_CONSTANT_KEY. Historically, this flag was used first and the new name JSON_C_OBJECT_ADD_CONSTANT_KEY was introduced for version 0.16.00 in order to have regular naming. Use of this flag is now legacy.

#define JSON_C_OPTION_GLOBAL   (0)

Set the global value of an option, which will apply to all current and future threads that have not set a thread-local value.

See Also
json_c_set_serialization_double_format
#define JSON_C_OPTION_THREAD   (1)

Set a thread-local value of an option, overriding the global value. This will fail if json-c is not compiled with threading enabled, and with the __thread specifier (or equivalent) available.

See Also
json_c_set_serialization_double_format
#define JSON_C_TO_STRING_COLOR   (1 << 5)

A flag for the json_object_to_json_string_ext() and json_object_to_file_ext() functions which causes the output to be formatted.

Use color for printing json.

#define JSON_C_TO_STRING_NOSLASHESCAPE   (1 << 4)

Don't escape forward slashes.

#define JSON_C_TO_STRING_NOZERO   (1 << 2)

A flag to drop trailing zero for float values

#define JSON_C_TO_STRING_PLAIN   0

A flag for the json_object_to_json_string_ext() and json_object_to_file_ext() functions which causes the output to have no extra whitespace or formatting applied.

#define JSON_C_TO_STRING_PRETTY   (1 << 1)

A flag for the json_object_to_json_string_ext() and json_object_to_file_ext() functions which causes the output to be formatted.

See the "Two Space Tab" option at https://jsonformatter.curiousconcept.com/ for an example of the format.

#define JSON_C_TO_STRING_PRETTY_TAB   (1 << 3)

A flag for the json_object_to_json_string_ext() and json_object_to_file_ext() functions which causes the output to be formatted.

Instead of a "Two Space Tab" this gives a single tab character.

#define JSON_C_TO_STRING_SPACED   (1 << 0)

A flag for the json_object_to_json_string_ext() and json_object_to_file_ext() functions which causes the output to have minimal whitespace inserted to make things slightly more readable.

#define JSON_OBJECT_DEF_HASH_ENTRIES   16
#define json_object_object_foreach (   obj,
  key,
  val 
)
Value:
char *key = NULL; \
struct json_object *val = NULL; \
struct lh_entry *entry##key; \
struct lh_entry *entry_next##key = NULL; \
for (entry##key = lh_table_head(json_object_get_object(obj)); \
(entry##key ? (key = (char *)lh_entry_k(entry##key), \
val = (struct json_object *)lh_entry_v(entry##key), \
entry_next##key = lh_entry_next(entry##key), entry##key) \
: 0); \
entry##key = entry_next##key)

Iterate through all keys and values of an object.

Adding keys to the object while iterating is NOT allowed.

Deleting an existing key, or replacing an existing key with a new value IS allowed.

Parameters
objthe json_object instance
keythe local name for the char* key variable defined in the body
valthe local name for the json_object* object variable defined in the body
#define json_object_object_foreachC (   obj,
  iter 
)
Value:
for (iter.entry = lh_table_head(json_object_get_object(obj)); \
(iter.entry ? (iter.key = (char *)lh_entry_k(iter.entry), \
iter.val = (struct json_object *)lh_entry_v(iter.entry), iter.entry) \
: 0); \
iter.entry = lh_entry_next(iter.entry))

Iterate through all keys and values of an object (ANSI C Safe)

Parameters
objthe json_object instance
iterthe object iterator, use type json_object_iter

Typedef Documentation

typedef int( json_c_shallow_copy_fn)(json_object *src, json_object *parent, const char *key, size_t index, json_object **dst)

Perform a shallow copy of src into *dst as part of an overall json_object_deep_copy().

If src is part of a containing object or array, parent will be non-NULL, and key or index will be provided. When shallow_copy is called *dst will be NULL, and must be non-NULL when it returns. src will never be NULL.

If shallow_copy sets the serializer on an object, return 2 to indicate to json_object_deep_copy that it should not attempt to use the standard userdata copy function.

Returns
On success 1 or 2, -1 on errors

Function Documentation

size_t json_c_object_sizeof ( void  )

Get the sizeof (struct json_object).

Returns
a size_t with the sizeof (struct json_object)
JSON_EXPORT int json_c_set_serialization_double_format ( const char *  double_format,
int  global_or_thread 
)

Set a global or thread-local json-c option, depending on whether JSON_C_OPTION_GLOBAL or JSON_C_OPTION_THREAD is passed. Thread-local options default to undefined, and inherit from the global value, even if the global value is changed after the thread is created. Attempting to set thread-local options when threading is not compiled in will result in an error. Be sure to check the return value.

double_format is a "%g" printf format, such as "%.20g"

Returns
-1 on errors, 0 on success.
JSON_EXPORT int json_object_array_add ( struct json_object *  obj,
struct json_object *  val 
)

Add an element to the end of a json_object of type json_type_array

The reference count will not be incremented. This is to make adding fields to objects in code more compact. If you want to retain a reference to an added object you must wrap the passed object with json_object_get

Parameters
objthe json_object instance
valthe json_object to be added
JSON_EXPORT struct json_object* json_object_array_bsearch ( const struct json_object *  key,
const struct json_object *  jso,
int(*)(const void *, const void *)  sort_fn 
)
read

Binary search a sorted array for a specified key object.

It depends on your compare function what's sufficient as a key. Usually you create some dummy object with the parameter compared in it, to identify the right item you're actually looking for.

See Also
json_object_array_sort() for hints on the compare function.
Parameters
keya dummy json_object with the right key
jsothe array object we're searching
sort_fnthe sort/compare function
Returns
the wanted json_object instance
JSON_EXPORT int json_object_array_del_idx ( struct json_object *  obj,
size_t  idx,
size_t  count 
)

Delete an elements from a specified index in an array (a json_object of type json_type_array)

The reference count will be decremented for each of the deleted objects. If there are no more owners of an element that is being deleted, then the value is freed. Otherwise, the reference to the value will remain in memory.

Parameters
objthe json_object instance
idxthe index to start deleting elements at
countthe number of elements to delete
Returns
0 if the elements were successfully deleted
JSON_EXPORT struct json_object* json_object_array_get_idx ( const struct json_object *  obj,
size_t  idx 
)
read

Get the element at specified index of array obj (which must be a json_object of type json_type_array)

No reference counts will be changed, and ownership of the returned object remains with obj. See json_object_object_get() for additional implications of this behavior.

Calling this with anything other than a json_type_array will trigger an assert.

Parameters
objthe json_object instance
idxthe index to get the element at
Returns
the json_object at the specified index (or NULL)
JSON_EXPORT int json_object_array_insert_idx ( struct json_object *  obj,
size_t  idx,
struct json_object *  val 
)

Insert an element at a specified index in an array (a json_object of type json_type_array)

The reference count will not be incremented. This is to make adding fields to objects in code more compact. If you want to retain a reference to an added object you must wrap the passed object with json_object_get

The array size will be automatically be expanded to the size of the index if the index is larger than the current size. If the index is within the existing array limits, then the element will be inserted and all elements will be shifted. This is the only difference between this function and json_object_array_put_idx().

Parameters
objthe json_object instance
idxthe index to insert the element at
valthe json_object to be added
JSON_EXPORT size_t json_object_array_length ( const struct json_object *  obj)

Get the length of a json_object of type json_type_array

Parameters
objthe json_object instance
Returns
an int
JSON_EXPORT int json_object_array_put_idx ( struct json_object *  obj,
size_t  idx,
struct json_object *  val 
)

Insert or replace an element at a specified index in an array (a json_object of type json_type_array)

The reference count will not be incremented. This is to make adding fields to objects in code more compact. If you want to retain a reference to an added object you must wrap the passed object with json_object_get

The reference count of a replaced object will be decremented.

The array size will be automatically be expanded to the size of the index if the index is larger than the current size.

Parameters
objthe json_object instance
idxthe index to insert the element at
valthe json_object to be added
JSON_EXPORT int json_object_array_shrink ( struct json_object *  jso,
int  empty_slots 
)

Shrink the internal memory allocation of the array to just enough to fit the number of elements in it, plus empty_slots.

Parameters
jsothe json_object instance, must be json_type_array
empty_slotsthe number of empty slots to leave allocated
JSON_EXPORT void json_object_array_sort ( struct json_object *  jso,
int(*)(const void *, const void *)  sort_fn 
)

Sorts the elements of jso of type json_type_array

Pointers to the json_object pointers will be passed as the two arguments to sort_fn

Parameters
jsothe json_object instance
sort_fna sorting function
JSON_EXPORT int json_object_deep_copy ( struct json_object *  src,
struct json_object **  dst,
json_c_shallow_copy_fn *  shallow_copy 
)

Copy the contents of the JSON object. The destination object must be initialized to NULL, to make sure this function won't overwrite an existing JSON object.

This does roughly the same thing as json_tokener_parse(json_object_get_string(src)).

Parameters
srcsource JSON object whose contents will be copied
dstpointer to the destination object where the contents of src; make sure this pointer is initialized to NULL
shallow_copyan optional function to copy individual objects, needed when custom serializers are in use. See also json_object set_serializer.
Returns
0 if the copy went well, -1 if an error occurred during copy or if the destination pointer is non-NULL
JSON_EXPORT int json_object_double_to_json_string ( struct json_object *  jso,
struct printbuf *  pb,
int  level,
int  flags 
)

Serialize a json_object of type json_type_double to a string.

This function isn't meant to be called directly. Instead, you can set a custom format string for the serialization of this double using the following call (where "%.17g" actually is the default):

jso = json_object_new_double(d);
json_object_set_serializer(jso, json_object_double_to_json_string,
"%.17g", NULL);
See Also
printf(3) man page for format strings
Parameters
jsoThe json_type_double object that is serialized.
pbThe destination buffer.
levelIgnored.
flagsIgnored.
JSON_EXPORT int json_object_equal ( struct json_object *  obj1,
struct json_object *  obj2 
)

Check if two json_object's are equal

If the passed objects are equal 1 will be returned. Equality is defined as follows:

  • json_objects of different types are never equal
  • json_objects of the same primitive type are equal if the c-representation of their value is equal
  • json-arrays are considered equal if all values at the same indices are equal (same order)
  • Complex json_objects are considered equal if all contained objects referenced by their key are equal, regardless their order.
Parameters
obj1the first json_object instance
obj2the second json_object instance
Returns
whether both objects are equal or not
JSON_EXPORT struct json_object* json_object_get ( struct json_object *  obj)
read

Increment the reference count of json_object, thereby taking ownership of it.

Cases where you might need to increase the refcount include:

Parameters
objthe json_object instance
See Also
json_object_put()
json_object_object_get()
json_object_array_get_idx()
JSON_EXPORT struct array_list* json_object_get_array ( const struct json_object *  obj)
read

Get the arraylist of a json_object of type json_type_array

Parameters
objthe json_object instance
Returns
an arraylist
JSON_EXPORT json_bool json_object_get_boolean ( const struct json_object *  obj)

Get the json_bool value of a json_object

The type is coerced to a json_bool if the passed object is not a json_bool. integer and double objects will return 0 if there value is zero or 1 otherwise. If the passed object is a string it will return 1 if it has a non zero length. If any other object type is passed 0 will be returned, even non-empty json_type_array and json_type_object objects.

Parameters
objthe json_object instance
Returns
a json_bool
JSON_EXPORT double json_object_get_double ( const struct json_object *  obj)

Get the double floating point value of a json_object

The type is coerced to a double if the passed object is not a double. integer objects will return their double conversion. Strings will be parsed as a double. If no conversion exists then 0.0 is returned and errno is set to EINVAL. null is equivalent to 0 (no error values set)

If the value is too big to fit in a double, then the value is set to the closest infinity with errno set to ERANGE. If strings cannot be converted to their double value, then EINVAL is set & NaN is returned.

Arrays of length 0 are interpreted as 0 (with no error flags set). Arrays of length 1 are effectively cast to the equivalent object and converted using the above rules. All other arrays set the error to EINVAL & return NaN.

NOTE: Set errno to 0 directly before a call to this function to determine whether or not conversion was successful (it does not clear the value for you).

Parameters
objthe json_object instance
Returns
a double floating point number
JSON_EXPORT int32_t json_object_get_int ( const struct json_object *  obj)

Get the int value of a json_object

The type is coerced to a int if the passed object is not a int. double objects will return their integer conversion. Strings will be parsed as an integer. If no conversion exists then 0 is returned and errno is set to EINVAL. null is equivalent to 0 (no error values set)

Note that integers are stored internally as 64-bit values. If the value of too big or too small to fit into 32-bit, INT32_MAX or INT32_MIN are returned, respectively.

Parameters
objthe json_object instance
Returns
an int
JSON_EXPORT int64_t json_object_get_int64 ( const struct json_object *  obj)

Get the int value of a json_object

The type is coerced to a int64 if the passed object is not a int64. double objects will return their int64 conversion. Strings will be parsed as an int64. If no conversion exists then 0 is returned.

NOTE: Set errno to 0 directly before a call to this function to determine whether or not conversion was successful (it does not clear the value for you).

Parameters
objthe json_object instance
Returns
an int64
JSON_EXPORT struct lh_table* json_object_get_object ( const struct json_object *  obj)
read

Get the hashtable of a json_object of type json_type_object

Parameters
objthe json_object instance
Returns
a linkhash
JSON_EXPORT const char* json_object_get_string ( struct json_object *  obj)

Get the string value of a json_object

If the passed object is of type json_type_null (i.e. obj == NULL), NULL is returned.

If the passed object of type json_type_string, the string contents are returned.

Otherwise the JSON representation of the object is returned.

The returned string memory is managed by the json_object and will be freed when the reference count of the json_object drops to zero.

Parameters
objthe json_object instance
Returns
a string or NULL
JSON_EXPORT int json_object_get_string_len ( const struct json_object *  obj)

Get the string length of a json_object

If the passed object is not of type json_type_string then zero will be returned.

Parameters
objthe json_object instance
Returns
int
JSON_EXPORT enum json_type json_object_get_type ( const struct json_object *  obj)

Get the type of the json_object. See also json_type_to_name() to turn this into a string suitable, for instance, for logging.

Parameters
objthe json_object instance
Returns
type being one of: json_type_null (i.e. obj == NULL), json_type_boolean, json_type_double, json_type_int, json_type_object, json_type_array, json_type_string
JSON_EXPORT uint64_t json_object_get_uint64 ( const struct json_object *  obj)

Get the uint value of a json_object

The type is coerced to a uint64 if the passed object is not a uint64. double objects will return their uint64 conversion. Strings will be parsed as an uint64. If no conversion exists then 0 is returned.

NOTE: Set errno to 0 directly before a call to this function to determine whether or not conversion was successful (it does not clear the value for you).

Parameters
objthe json_object instance
Returns
an uint64
JSON_EXPORT void* json_object_get_userdata ( json_object *  jso)

Returns the userdata set by json_object_set_userdata() or json_object_set_serializer()

Parameters
jsothe object to return the userdata for
JSON_EXPORT int json_object_int_inc ( struct json_object *  obj,
int64_t  val 
)

Increment a json_type_int object by the given amount, which may be negative.

If the type of obj is not json_type_int then 0 is returned with no further action taken. If the addition would result in a overflow, the object value is set to INT64_MAX. If the addition would result in a underflow, the object value is set to INT64_MIN. Neither overflow nor underflow affect the return value.

Parameters
objthe json_object instance
valthe value to add
Returns
1 if the increment succeeded, 0 otherwise
JSON_EXPORT int json_object_is_type ( const struct json_object *  obj,
enum json_type  type 
)

Check if the json_object is of a given type

Parameters
objthe json_object instance
typeone of: json_type_null (i.e. obj == NULL), json_type_boolean, json_type_double, json_type_int, json_type_object, json_type_array, json_type_string
JSON_EXPORT struct json_object* json_object_new_array ( void  )
read

Create a new empty json_object of type json_type_array with 32 slots allocated. If you know the array size you'll need ahead of time, use json_object_new_array_ext() instead.

See Also
json_object_new_array_ext()
json_object_array_shrink()
Returns
a json_object of type json_type_array
JSON_EXPORT struct json_object* json_object_new_array_ext ( int  initial_size)
read

Create a new empty json_object of type json_type_array with the desired number of slots allocated.

See Also
json_object_array_shrink()
Parameters
initial_sizethe number of slots to allocate
Returns
a json_object of type json_type_array
JSON_EXPORT struct json_object* json_object_new_boolean ( json_bool  b)
read

Create a new empty json_object of type json_type_boolean

Parameters
ba json_bool 1 or 0
Returns
a json_object of type json_type_boolean
JSON_EXPORT struct json_object* json_object_new_double ( double  d)
read

Create a new empty json_object of type json_type_double

See Also
json_object_double_to_json_string() for how to set a custom format string.
Parameters
dthe double
Returns
a json_object of type json_type_double
JSON_EXPORT struct json_object* json_object_new_double_s ( double  d,
const char *  ds 
)
read

Create a new json_object of type json_type_double, using the exact serialized representation of the value.

This allows for numbers that would otherwise get displayed inefficiently (e.g. 12.3 => "12.300000000000001") to be serialized with the more convenient form.

Notes:

This is used by json_tokener_parse_ex() to allow for an exact re-serialization of a parsed object.

The userdata field is used to store the string representation, so it can't be used for other data if this function is used.

A roughly equivalent sequence of calls, with the difference being that the serialization function won't be reset by json_object_set_double(), is:

jso = json_object_new_double(d);
json_object_set_serializer(jso, json_object_userdata_to_json_string,
strdup(ds), json_object_free_userdata);
Parameters
dthe numeric value of the double.
dsthe string representation of the double. This will be copied.
JSON_EXPORT struct json_object* json_object_new_int ( int32_t  i)
read

Create a new empty json_object of type json_type_int Note that values are stored as 64-bit values internally. To ensure the full range is maintained, use json_object_new_int64 instead.

Parameters
ithe integer
Returns
a json_object of type json_type_int
JSON_EXPORT struct json_object* json_object_new_int64 ( int64_t  i)
read

Create a new empty json_object of type json_type_int

Parameters
ithe integer
Returns
a json_object of type json_type_int
JSON_EXPORT struct json_object* json_object_new_null ( void  )
read

This method exists only to provide a complementary function along the lines of the other json_object_new_* functions. It always returns NULL, and it is entirely acceptable to simply use NULL directly.

JSON_EXPORT struct json_object* json_object_new_object ( void  )
read

Create a new empty object with a reference count of 1. The caller of this object initially has sole ownership. Remember, when using json_object_object_add or json_object_array_put_idx, ownership will transfer to the object/array. Call json_object_get if you want to maintain shared ownership or also add this object as a child of multiple objects or arrays. Any ownerships you acquired but did not transfer must be released through json_object_put.

Returns
a json_object of type json_type_object
JSON_EXPORT struct json_object* json_object_new_string ( const char *  s)
read

Create a new empty json_object of type json_type_string

A copy of the string is made and the memory is managed by the json_object

Parameters
sthe string
Returns
a json_object of type json_type_string
See Also
json_object_new_string_len()
JSON_EXPORT struct json_object* json_object_new_string_len ( const char *  s,
const int  len 
)
read

Create a new empty json_object of type json_type_string and allocate len characters for the new string.

A copy of the string is made and the memory is managed by the json_object

Parameters
sthe string
lenmax length of the new string
Returns
a json_object of type json_type_string
See Also
json_object_new_string()
JSON_EXPORT struct json_object* json_object_new_uint64 ( uint64_t  i)
read

Create a new empty json_object of type json_type_uint

Parameters
ithe integer
Returns
a json_object of type json_type_uint
JSON_EXPORT int json_object_object_add ( struct json_object *  obj,
const char *  key,
struct json_object *  val 
)

Add an object field to a json_object of type json_type_object

The reference count of val will not be incremented, in effect transferring ownership that object to obj, and thus val will be freed when obj is. (i.e. through json_object_put(obj))

If you want to retain a reference to the added object, independent of the lifetime of obj, you must increment the refcount with json_object_get(val) (and later release it with json_object_put()).

Since ownership transfers to obj, you must make sure that you do in fact have ownership over val. For instance, json_object_new_object() will give you ownership until you transfer it, whereas json_object_object_get() does not.

Any previous object stored under key in obj will have its refcount decremented, and be freed normally if that drops to zero.

Parameters
objthe json_object instance
keythe object field name (a private copy will be duplicated)
vala json_object or NULL member to associate with the given field
Returns
On success, 0 is returned. On error, a negative value is returned.
JSON_EXPORT int json_object_object_add_ex ( struct json_object *  obj,
const char *const  key,
struct json_object *const  val,
const unsigned  opts 
)

Add an object field to a json_object of type json_type_object

The semantics are identical to json_object_object_add, except that an additional flag fields gives you more control over some detail aspects of processing. See the description of JSON_C_OBJECT_ADD_* flags for more details.

Parameters
objthe json_object instance
keythe object field name (a private copy will be duplicated)
vala json_object or NULL member to associate with the given field
optsprocess-modifying options. To specify multiple options, use (OPT1|OPT2)
JSON_EXPORT void json_object_object_del ( struct json_object *  obj,
const char *  key 
)

Delete the given json_object field

The reference count will be decremented for the deleted object. If there are no more owners of the value represented by this key, then the value is freed. Otherwise, the reference to the value will remain in memory.

Parameters
objthe json_object instance
keythe object field name
JSON_EXPORT struct json_object* json_object_object_get ( const struct json_object *  obj,
const char *  key 
)
read

Get the json_object associate with a given object field. Deprecated/discouraged: used json_object_object_get_ex instead.

This returns NULL if the field is found but its value is null, or if the field is not found, or if obj is not a json_type_object. If you need to distinguish between these cases, use json_object_object_get_ex().

No reference counts will be changed. There is no need to manually adjust reference counts through the json_object_put/json_object_get methods unless you need to have the child (value) reference maintain a different lifetime than the owning parent (obj). Ownership of the returned value is retained by obj (do not do json_object_put unless you have done a json_object_get). If you delete the value from obj (json_object_object_del) and wish to access the returned reference afterwards, make sure you have first gotten shared ownership through json_object_get (& don't forget to do a json_object_put or transfer ownership to prevent a memory leak).

Parameters
objthe json_object instance
keythe object field name
Returns
the json_object associated with the given field name
JSON_EXPORT json_bool json_object_object_get_ex ( const struct json_object *  obj,
const char *  key,
struct json_object **  value 
)

Get the json_object associated with a given object field.

This returns true if the key is found, false in all other cases (including if obj isn't a json_type_object).

No reference counts will be changed. There is no need to manually adjust reference counts through the json_object_put/json_object_get methods unless you need to have the child (value) reference maintain a different lifetime than the owning parent (obj). Ownership of value is retained by obj.

Parameters
objthe json_object instance
keythe object field name
valuea pointer where to store a reference to the json_object associated with the given field name.

It is safe to pass a NULL value.

Returns
whether or not the key exists
JSON_EXPORT int json_object_object_length ( const struct json_object *  obj)

Get the size of an object in terms of the number of fields it has.

Parameters
objthe json_object whose length to return
JSON_EXPORT int json_object_put ( struct json_object *  obj)

Decrement the reference count of json_object and free if it reaches zero.

You must have ownership of obj prior to doing this or you will cause an imbalance in the reference count, leading to a classic use-after-free bug. In particular, you normally do not need to call json_object_put() on the json_object returned by json_object_object_get() or json_object_array_get_idx().

Just like after calling free() on a block of memory, you must not use obj after calling json_object_put() on it or any object that it is a member of (unless you know you've called json_object_get(obj) to explicitly increment the refcount).

NULL may be passed, which which case this is a no-op.

Parameters
objthe json_object instance
Returns
1 if the object was freed.
See Also
json_object_get()
JSON_EXPORT int json_object_set_boolean ( struct json_object *  obj,
json_bool  new_value 
)

Set the json_bool value of a json_object

The type of obj is checked to be a json_type_boolean and 0 is returned if it is not without any further actions. If type of obj is json_type_boolean the object value is changed to new_value

Parameters
objthe json_object instance
new_valuethe value to be set
Returns
1 if value is set correctly, 0 otherwise
JSON_EXPORT int json_object_set_double ( struct json_object *  obj,
double  new_value 
)

Set the double value of a json_object

The type of obj is checked to be a json_type_double and 0 is returned if it is not without any further actions. If type of obj is json_type_double the object value is changed to new_value

If the object was created with json_object_new_double_s(), the serialization function is reset to the default and the cached serialized value is cleared.

Parameters
objthe json_object instance
new_valuethe value to be set
Returns
1 if value is set correctly, 0 otherwise
JSON_EXPORT int json_object_set_int ( struct json_object *  obj,
int  new_value 
)

Set the int value of a json_object

The type of obj is checked to be a json_type_int and 0 is returned if it is not without any further actions. If type of obj is json_type_int the object value is changed to new_value

Parameters
objthe json_object instance
new_valuethe value to be set
Returns
1 if value is set correctly, 0 otherwise
JSON_EXPORT int json_object_set_int64 ( struct json_object *  obj,
int64_t  new_value 
)

Set the int64_t value of a json_object

The type of obj is checked to be a json_type_int and 0 is returned if it is not without any further actions. If type of obj is json_type_int the object value is changed to new_value

Parameters
objthe json_object instance
new_valuethe value to be set
Returns
1 if value is set correctly, 0 otherwise
JSON_EXPORT void json_object_set_serializer ( json_object *  jso,
json_object_to_json_string_fn *  to_string_func,
void *  userdata,
json_object_delete_fn *  user_delete 
)

Set a custom serialization function to be used when this particular object is converted to a string by json_object_to_json_string.

If custom userdata is already set on this object, any existing user_delete function is called before the new one is set.

If to_string_func is NULL the default behaviour is reset (but the userdata and user_delete fields are still set).

The userdata parameter is optional and may be passed as NULL. It can be used to provide additional data for to_string_func to use. This parameter may be NULL even if user_delete is non-NULL.

The user_delete parameter is optional and may be passed as NULL, even if the userdata parameter is non-NULL. It will be called just before the json_object is deleted, after it's reference count goes to zero (see json_object_put()). If this is not provided, it is up to the caller to free the userdata at an appropriate time. (i.e. after the json_object is deleted)

Note that the userdata is the same as set by json_object_set_userdata(), so care must be taken not to overwrite the value when both a custom serializer and json_object_set_userdata() are used.

Parameters
jsothe object to customize
to_string_functhe custom serialization function
userdataan optional opaque cookie
user_deletean optional function from freeing userdata
JSON_EXPORT int json_object_set_string ( json_object *  obj,
const char *  new_value 
)

Set the string value of a json_object with zero terminated strings equivalent to json_object_set_string_len (obj, new_value, strlen(new_value))

Returns
1 if value is set correctly, 0 otherwise
JSON_EXPORT int json_object_set_string_len ( json_object *  obj,
const char *  new_value,
int  len 
)

Set the string value of a json_object str

The type of obj is checked to be a json_type_string and 0 is returned if it is not without any further actions. If type of obj is json_type_string the object value is changed to new_value

Parameters
objthe json_object instance
new_valuethe value to be set; Since string length is given in len this need not be zero terminated
lenthe length of new_value
Returns
1 if value is set correctly, 0 otherwise
JSON_EXPORT int json_object_set_uint64 ( struct json_object *  obj,
uint64_t  new_value 
)

Set the uint64_t value of a json_object

The type of obj is checked to be a json_type_uint and 0 is returned if it is not without any further actions. If type of obj is json_type_uint the object value is changed to new_value

Parameters
objthe json_object instance
new_valuethe value to be set
Returns
1 if value is set correctly, 0 otherwise
JSON_EXPORT void json_object_set_userdata ( json_object *  jso,
void *  userdata,
json_object_delete_fn *  user_delete 
)

Set an opaque userdata value for an object

The userdata can be retrieved using json_object_get_userdata().

If custom userdata is already set on this object, any existing user_delete function is called before the new one is set.

The user_delete parameter is optional and may be passed as NULL, even if the userdata parameter is non-NULL. It will be called just before the json_object is deleted, after it's reference count goes to zero (see json_object_put()). If this is not provided, it is up to the caller to free the userdata at an appropriate time. (i.e. after the json_object is deleted)

Note: Objects created by parsing strings may have custom serializers set which expect the userdata to contain specific data (due to use of json_object_new_double_s()). In this case, json_object_set_serialiser() with NULL as to_string_func should be used instead to set the userdata and reset the serializer to its default value.

Parameters
jsothe object to set the userdata for
userdataan optional opaque cookie
user_deletean optional function from freeing userdata
JSON_EXPORT const char* json_object_to_json_string ( struct json_object *  obj)

Stringify object to json format. Equivalent to json_object_to_json_string_ext(obj, JSON_C_TO_STRING_SPACED) The pointer you get is an internal of your json object. You don't have to free it, later use of json_object_put() should be sufficient. If you can not ensure there's no concurrent access to *obj use strdup().

Parameters
objthe json_object instance
Returns
a string in JSON format
JSON_EXPORT const char* json_object_to_json_string_ext ( struct json_object *  obj,
int  flags 
)

Stringify object to json format

See Also
json_object_to_json_string() for details on how to free string.
Parameters
objthe json_object instance
flagsformatting options, see JSON_C_TO_STRING_PRETTY and other constants
Returns
a string in JSON format
JSON_EXPORT const char* json_object_to_json_string_length ( struct json_object *  obj,
int  flags,
size_t *  length 
)

Stringify object to json format

See Also
json_object_to_json_string() for details on how to free string.
Parameters
objthe json_object instance
flagsformatting options, see JSON_C_TO_STRING_PRETTY and other constants
lengtha pointer where, if not NULL, the length (without null) is stored
Returns
a string in JSON format and the length if not NULL

Variable Documentation

JSON_EXPORT json_c_shallow_copy_fn json_c_shallow_copy_default

The default shallow copy implementation for use with json_object_deep_copy(). This simply calls the appropriate json_object_new_<type>() function and copies over the serializer function (_to_json_string internal field of the json_object structure) but not any _userdata or _user_delete values.

If you're writing a custom shallow_copy function, perhaps because you're using your own custom serializer, you can call this first to create the new object before customizing it with json_object_set_serializer().

Returns
1 on success, -1 on errors, but never 2.
JSON_EXPORT json_object_delete_fn json_object_free_userdata

Simply call free on the userdata pointer. Can be used with json_object_set_serializer().

Parameters
jsounused
userdatathe pointer that is passed to free().
JSON_EXPORT json_object_to_json_string_fn json_object_userdata_to_json_string

Copy the jso->_userdata string over to pb as-is. Can be used with json_object_set_serializer().

Parameters
jsoThe object whose _userdata is used.
pbThe destination buffer.
levelIgnored.
flagsIgnored.
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/json__object__iterator_8h.html000066400000000000000000000562011446575330000244370ustar00rootroot00000000000000 json-c: json_object_iterator.h File Reference
Data Structures | Functions
json_object_iterator.h File Reference

An API for iterating over json_type_object objects, styled to be familiar to C++ programmers. Unlike json_object_object_foreach() and json_object_object_foreachC(), this avoids the need to expose json-c internals like lh_entry. More...

Data Structures

struct  json_object_iterator
 

Functions

JSON_EXPORT struct
json_object_iterator 		json_object_iter_init_default (void)
 
JSON_EXPORT struct
json_object_iterator 		json_object_iter_begin (struct json_object *obj)
 
JSON_EXPORT struct
json_object_iterator 		json_object_iter_end (const struct json_object *obj)
 
JSON_EXPORT void json_object_iter_next (struct json_object_iterator *iter)
 
JSON_EXPORT const char * json_object_iter_peek_name (const struct json_object_iterator *iter)
 
JSON_EXPORT struct json_object * json_object_iter_peek_value (const struct json_object_iterator *iter)
 
JSON_EXPORT json_bool json_object_iter_equal (const struct json_object_iterator *iter1, const struct json_object_iterator *iter2)
 

Detailed Description

An API for iterating over json_type_object objects, styled to be familiar to C++ programmers. Unlike json_object_object_foreach() and json_object_object_foreachC(), this avoids the need to expose json-c internals like lh_entry.

Copyright (c) 2009-2012 Hewlett-Packard Development Company, L.P.

This library is free software; you can redistribute it and/or modify it under the terms of the MIT license. See COPYING for details.

API attributes:

  • Thread-safe: NO
  • Reentrant: NO

Function Documentation

JSON_EXPORT struct json_object_iterator json_object_iter_begin ( struct json_object *  obj)
read

Retrieves an iterator to the first pair of the JSON Object.

Warning
Any modification of the underlying pair invalidates all iterators to that pair.
Parameters
objJSON Object instance (MUST be of type json_object)
Returns
json_object_iterator If the JSON Object has at least one pair, on return, the iterator refers to the first pair. If the JSON Object doesn't have any pairs, the returned iterator is equivalent to the "end" iterator for the same JSON Object instance.
struct json_object_iterator it;
struct json_object_iterator itEnd;
struct json_object* obj;
obj = json_tokener_parse("{'first':'george', 'age':100}");
it = json_object_iter_begin(obj);
itEnd = json_object_iter_end(obj);
while (!json_object_iter_equal(&it, &itEnd)) {
printf("%s\n",
json_object_iter_peek_name(&it));
json_object_iter_next(&it);
}
JSON_EXPORT struct json_object_iterator json_object_iter_end ( const struct json_object *  obj)
read

Retrieves the iterator that represents the position beyond the last pair of the given JSON Object instance.

Warning
Do NOT write code that assumes that the "end" iterator value is NULL, even if it is so in a particular instance of the implementation.
Note
The reason we do not (and MUST NOT) provide "json_object_iter_is_end(json_object_iterator* iter)" type of API is because it would limit the underlying representation of name/value containment (or force us to add additional, otherwise unnecessary, fields to the iterator structure). The "end" iterator and the equality test method, on the other hand, permit us to cleanly abstract pretty much any reasonable underlying representation without burdening the iterator structure with unnecessary data.
For performance reasons, memorize the "end" iterator prior to any loop.
Parameters
objJSON Object instance (MUST be of type json_object)
Returns
json_object_iterator On return, the iterator refers to the "end" of the Object instance's pairs (i.e., NOT the last pair, but "beyond the last pair" value)
JSON_EXPORT json_bool json_object_iter_equal ( const struct json_object_iterator *  iter1,
const struct json_object_iterator *  iter2 
)

Tests two iterators for equality. Typically used to test for end of iteration by comparing an iterator to the corresponding "end" iterator (that was derived from the same JSON Object instance).

Note
The reason we do not (and MUST NOT) provide "json_object_iter_is_end(json_object_iterator* iter)" type of API is because it would limit the underlying representation of name/value containment (or force us to add additional, otherwise unnecessary, fields to the iterator structure). The equality test method, on the other hand, permits us to cleanly abstract pretty much any reasonable underlying representation.
Parameters
iter1Pointer to first valid, non-NULL iterator
iter2POinter to second valid, non-NULL iterator
Warning
if a NULL iterator pointer or an uninitialized or invalid iterator, or iterators derived from different JSON Object instances are passed, bad things will happen!
Returns
json_bool non-zero if iterators are equal (i.e., both reference the same name/value pair or are both at "end"); zero if they are not equal.
JSON_EXPORT struct json_object_iterator json_object_iter_init_default ( void  )
read

Initializes an iterator structure to a "default" value that is convenient for initializing an iterator variable to a default state (e.g., initialization list in a class' constructor).

struct json_object_iterator iter = json_object_iter_init_default();
MyClass() : iter_(json_object_iter_init_default())
Note
The initialized value doesn't reference any specific pair, is considered an invalid iterator, and MUST NOT be passed to any json-c API that expects a valid iterator.
User and internal code MUST NOT make any assumptions about and dependencies on the value of the "default" iterator value.
Returns
json_object_iterator
JSON_EXPORT void json_object_iter_next ( struct json_object_iterator *  iter)

Returns an iterator to the next pair, if any

Warning
Any modification of the underlying pair invalidates all iterators to that pair.
Parameters
iter[IN/OUT] Pointer to iterator that references a name/value pair; MUST be a valid, non-end iterator. WARNING: bad things will happen if invalid or "end" iterator is passed. Upon return will contain the reference to the next pair if there is one; if there are no more pairs, will contain the "end" iterator value, which may be compared against the return value of json_object_iter_end() for the same JSON Object instance.
JSON_EXPORT const char* json_object_iter_peek_name ( const struct json_object_iterator *  iter)

Returns a const pointer to the name of the pair referenced by the given iterator.

Parameters
iterpointer to iterator that references a name/value pair; MUST be a valid, non-end iterator.
Warning
bad things will happen if an invalid or "end" iterator is passed.
Returns
const char* Pointer to the name of the referenced name/value pair. The name memory belongs to the name/value pair, will be freed when the pair is deleted or modified, and MUST NOT be modified or freed by the user.
JSON_EXPORT struct json_object* json_object_iter_peek_value ( const struct json_object_iterator *  iter)
read

Returns a pointer to the json-c instance representing the value of the referenced name/value pair, without altering the instance's reference count.

Parameters
iterpointer to iterator that references a name/value pair; MUST be a valid, non-end iterator.
Warning
bad things will happen if invalid or "end" iterator is passed.
Returns
struct json_object* Pointer to the json-c value instance of the referenced name/value pair; the value's reference count is not changed by this function: if you plan to hold on to this json-c node, take a look at json_object_get() and json_object_put(). IMPORTANT: json-c API represents the JSON Null value as a NULL json_object instance pointer.
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/json__patch_8h.html000066400000000000000000000155061446575330000222230ustar00rootroot00000000000000 json-c: json_patch.h File Reference
Data Structures | Functions
json_patch.h File Reference

JSON Patch (RFC 6902) implementation for manipulating JSON objects. More...

Data Structures

struct  json_patch_error
 

Functions

JSON_EXPORT int json_patch_apply (struct json_object *copy_from, struct json_object *patch, struct json_object **base, struct json_patch_error *patch_error)
 

Detailed Description

JSON Patch (RFC 6902) implementation for manipulating JSON objects.

Function Documentation

JSON_EXPORT int json_patch_apply ( struct json_object *  copy_from,
struct json_object *  patch,
struct json_object **  base,
struct json_patch_error *  patch_error 
)

Apply the JSON patch to the base object. The patch object must be formatted as per RFC 6902, i.e. a json_type_array containing patch operations. If the patch is not correctly formatted, an error will be returned.

The json_object at *base will be modified in place. Exactly one of *base or copy_from must be non-NULL. If *base is NULL, a new copy of copy_from will allocated and populated using json_object_deep_copy(). In this case json_object_put() must be used to free *base even if the overall patching operation fails.

If anything fails during patching a negative value will be returned, and patch_error (if non-NULL) will be populated with error details.

Parameters
basea pointer to the JSON object which to patch
patchthe JSON object that describes the patch to be applied
copy_froma JSON object to copy to *base
patch_erroroptional, details about errors
Returns
negative if an error (or not found), or 0 if patch completely applied
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/json__pointer_8h.html000066400000000000000000000365071446575330000226100ustar00rootroot00000000000000 json-c: json_pointer.h File Reference
Functions
json_pointer.h File Reference

JSON Pointer (RFC 6901) implementation for retrieving objects from a json-c object tree. More...

Functions

JSON_EXPORT int json_pointer_get (struct json_object *obj, const char *path, struct json_object **res)
 
JSON_EXPORT int json_pointer_getf (struct json_object *obj, struct json_object **res, const char *path_fmt,...)
 
JSON_EXPORT int json_pointer_set (struct json_object **obj, const char *path, struct json_object *value)
 
JSON_EXPORT int json_pointer_setf (struct json_object **obj, struct json_object *value, const char *path_fmt,...)
 

Detailed Description

JSON Pointer (RFC 6901) implementation for retrieving objects from a json-c object tree.

Function Documentation

JSON_EXPORT int json_pointer_get ( struct json_object *  obj,
const char *  path,
struct json_object **  res 
)

Retrieves a JSON sub-object from inside another JSON object using the JSON pointer notation as defined in RFC 6901 https://tools.ietf.org/html/rfc6901

The returned JSON sub-object is equivalent to parsing manually the 'obj' JSON tree ; i.e. it's not a new object that is created, but rather a pointer inside the JSON tree.

Internally, this is equivalent to doing a series of 'json_object_object_get()' and 'json_object_array_get_idx()' along the given 'path'.

Parameters
objthe json_object instance/tree from where to retrieve sub-objects
patha (RFC6901) string notation for the sub-object to retrieve
resa pointer that stores a reference to the json_object associated with the given path
Returns
negative if an error (or not found), or 0 if succeeded
JSON_EXPORT int json_pointer_getf ( struct json_object *  obj,
struct json_object **  res,
const char *  path_fmt,
  ... 
)

This is a variant of 'json_pointer_get()' that supports printf() style arguments.

Variable arguments go after the 'path_fmt' parameter.

Example: json_pointer_getf(obj, res, "/foo/%d/%s", 0, "bar") This also means that you need to escape '' with '%' (just like in printf())

Please take into consideration all recommended 'printf()' format security aspects when using this function.

Parameters
objthe json_object instance/tree to which to add a sub-object
resa pointer that stores a reference to the json_object associated with the given path
path_fmta printf() style format for the path
Returns
negative if an error (or not found), or 0 if succeeded
JSON_EXPORT int json_pointer_set ( struct json_object **  obj,
const char *  path,
struct json_object *  value 
)

Sets JSON object 'value' in the 'obj' tree at the location specified by the 'path'. 'path' is JSON pointer notation as defined in RFC 6901 https://tools.ietf.org/html/rfc6901

Note that 'obj' is a double pointer, mostly for the "" (empty string) case, where the entire JSON object would be replaced by 'value'. In the case of the "" path, the object at '*obj' will have it's refcount decremented with 'json_object_put()' and the 'value' object will be assigned to it.

For other cases (JSON sub-objects) ownership of 'value' will be transferred into '*obj' via 'json_object_object_add()' & 'json_object_array_put_idx()', so the only time the refcount should be decremented for 'value' is when the return value of 'json_pointer_set()' is negative (meaning the 'value' object did not get set into '*obj').

That also implies that 'json_pointer_set()' does not do any refcount incrementing. (Just that single decrement that was mentioned above).

Parameters
objthe json_object instance/tree to which to add a sub-object
patha (RFC6901) string notation for the sub-object to set in the tree
valueobject to set at path
Returns
negative if an error (or not found), or 0 if succeeded
JSON_EXPORT int json_pointer_setf ( struct json_object **  obj,
struct json_object *  value,
const char *  path_fmt,
  ... 
)

This is a variant of 'json_pointer_set()' that supports printf() style arguments.

Variable arguments go after the 'path_fmt' parameter.

Example: json_pointer_setf(obj, value, "/foo/%d/%s", 0, "bar") This also means that you need to escape '' with '%' (just like in printf())

Please take into consideration all recommended 'printf()' format security aspects when using this function.

Parameters
objthe json_object instance/tree to which to add a sub-object
valueobject to set at path
path_fmta printf() style format for the path
Returns
negative if an error (or not found), or 0 if succeeded
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/json__pointer__private_8h.html000066400000000000000000000206251446575330000244730ustar00rootroot00000000000000 json-c: json_pointer_private.h File Reference
Data Structures | Typedefs | Functions
json_pointer_private.h File Reference

Do not use, json-c internal, may be changed or removed at any time. More...

Data Structures

struct  json_pointer_get_result
 

Typedefs

typedef int(* json_pointer_array_set_cb )(json_object *parent, size_t idx, json_object *value, void *priv)
 

Functions

int json_pointer_get_internal (struct json_object *obj, const char *path, struct json_pointer_get_result *res)
 
int json_pointer_set_with_array_cb (struct json_object **obj, const char *path, struct json_object *value, json_pointer_array_set_cb array_set_cb, void *priv)
 

Detailed Description

Do not use, json-c internal, may be changed or removed at any time.

Typedef Documentation

typedef int(* json_pointer_array_set_cb)(json_object *parent, size_t idx, json_object *value, void *priv)

Function Documentation

int json_pointer_get_internal ( struct json_object *  obj,
const char *  path,
struct json_pointer_get_result *  res 
)
int json_pointer_set_with_array_cb ( struct json_object **  obj,
const char *  path,
struct json_object *  value,
json_pointer_array_set_cb  array_set_cb,
void *  priv 
)
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/json__tokener_8h.html000066400000000000000000001426701446575330000225760ustar00rootroot00000000000000 json-c: json_tokener.h File Reference
Data Structures | Macros | Typedefs | Enumerations | Functions
json_tokener.h File Reference

Methods to parse an input string into a tree of json_object objects. More...

Data Structures

struct  json_tokener_srec
 
struct  json_tokener
 

Macros

#define JSON_TOKENER_DEFAULT_DEPTH   32
 
#define JSON_TOKENER_STRICT   0x01
 
#define JSON_TOKENER_ALLOW_TRAILING_CHARS   0x02
 
#define JSON_TOKENER_VALIDATE_UTF8   0x10
 

Typedefs

typedef struct json_tokener json_tokener
 

Enumerations

enum  json_tokener_error {
  json_tokener_success, json_tokener_continue, json_tokener_error_depth, json_tokener_error_parse_eof,
  json_tokener_error_parse_unexpected, json_tokener_error_parse_null, json_tokener_error_parse_boolean, json_tokener_error_parse_number,
  json_tokener_error_parse_array, json_tokener_error_parse_object_key_name, json_tokener_error_parse_object_key_sep, json_tokener_error_parse_object_value_sep,
  json_tokener_error_parse_string, json_tokener_error_parse_comment, json_tokener_error_parse_utf8_string, json_tokener_error_memory,
  json_tokener_error_size
}
 
enum  json_tokener_state {
  json_tokener_state_eatws, json_tokener_state_start, json_tokener_state_finish, json_tokener_state_null,
  json_tokener_state_comment_start, json_tokener_state_comment, json_tokener_state_comment_eol, json_tokener_state_comment_end,
  json_tokener_state_string, json_tokener_state_string_escape, json_tokener_state_escape_unicode, json_tokener_state_escape_unicode_need_escape,
  json_tokener_state_escape_unicode_need_u, json_tokener_state_boolean, json_tokener_state_number, json_tokener_state_array,
  json_tokener_state_array_add, json_tokener_state_array_sep, json_tokener_state_object_field_start, json_tokener_state_object_field,
  json_tokener_state_object_field_end, json_tokener_state_object_value, json_tokener_state_object_value_add, json_tokener_state_object_sep,
  json_tokener_state_array_after_sep, json_tokener_state_object_field_start_after_sep, json_tokener_state_inf
}
 

Functions

JSON_EXPORT size_t json_tokener_get_parse_end (struct json_tokener *tok)
 
JSON_EXPORT const char * json_tokener_error_desc (enum json_tokener_error jerr)
 
JSON_EXPORT enum json_tokener_error json_tokener_get_error (struct json_tokener *tok)
 
JSON_EXPORT struct json_tokener * json_tokener_new (void)
 
JSON_EXPORT struct json_tokener * json_tokener_new_ex (int depth)
 
JSON_EXPORT void json_tokener_free (struct json_tokener *tok)
 
JSON_EXPORT void json_tokener_reset (struct json_tokener *tok)
 
JSON_EXPORT struct json_object * json_tokener_parse (const char *str)
 
JSON_EXPORT struct json_object * json_tokener_parse_verbose (const char *str, enum json_tokener_error *error)
 
JSON_EXPORT void json_tokener_set_flags (struct json_tokener *tok, int flags)
 
JSON_EXPORT struct json_object * json_tokener_parse_ex (struct json_tokener *tok, const char *str, int len)
 

Detailed Description

Methods to parse an input string into a tree of json_object objects.

Macro Definition Documentation

#define JSON_TOKENER_ALLOW_TRAILING_CHARS   0x02

Use with JSON_TOKENER_STRICT to allow trailing characters after the first parsed object.

See Also
json_tokener_set_flags()
#define JSON_TOKENER_DEFAULT_DEPTH   32
#define JSON_TOKENER_STRICT   0x01

Be strict when parsing JSON input. Use caution with this flag as what is considered valid may become more restrictive from one release to the next, causing your code to fail on previously working input.

Note that setting this will also effectively disable parsing of multiple json objects in a single character stream (e.g. {"foo":123}{"bar":234}); if you want to allow that also set JSON_TOKENER_ALLOW_TRAILING_CHARS

This flag is not set by default.

See Also
json_tokener_set_flags()
#define JSON_TOKENER_VALIDATE_UTF8   0x10

Cause json_tokener_parse_ex() to validate that input is UTF8. If this flag is specified and validation fails, then json_tokener_get_error(tok) will return json_tokener_error_parse_utf8_string

This flag is not set by default.

See Also
json_tokener_set_flags()

Typedef Documentation

typedef struct json_tokener json_tokener
Deprecated:
Unused in json-c code

Enumeration Type Documentation

enum json_tokener_error
Enumerator:
json_tokener_success 
json_tokener_continue 
json_tokener_error_depth 
json_tokener_error_parse_eof 
json_tokener_error_parse_unexpected 
json_tokener_error_parse_null 
json_tokener_error_parse_boolean 
json_tokener_error_parse_number 
json_tokener_error_parse_array 
json_tokener_error_parse_object_key_name 
json_tokener_error_parse_object_key_sep 
json_tokener_error_parse_object_value_sep 
json_tokener_error_parse_string 
json_tokener_error_parse_comment 
json_tokener_error_parse_utf8_string 
json_tokener_error_memory 
json_tokener_error_size 
enum json_tokener_state
Deprecated:
Don't use this outside of json_tokener.c, it will be made private in a future release.
Enumerator:
json_tokener_state_eatws 
json_tokener_state_start 
json_tokener_state_finish 
json_tokener_state_null 
json_tokener_state_comment_start 
json_tokener_state_comment 
json_tokener_state_comment_eol 
json_tokener_state_comment_end 
json_tokener_state_string 
json_tokener_state_string_escape 
json_tokener_state_escape_unicode 
json_tokener_state_escape_unicode_need_escape 
json_tokener_state_escape_unicode_need_u 
json_tokener_state_boolean 
json_tokener_state_number 
json_tokener_state_array 
json_tokener_state_array_add 
json_tokener_state_array_sep 
json_tokener_state_object_field_start 
json_tokener_state_object_field 
json_tokener_state_object_field_end 
json_tokener_state_object_value 
json_tokener_state_object_value_add 
json_tokener_state_object_sep 
json_tokener_state_array_after_sep 
json_tokener_state_object_field_start_after_sep 
json_tokener_state_inf 

Function Documentation

JSON_EXPORT const char* json_tokener_error_desc ( enum json_tokener_error  jerr)

Given an error previously returned by json_tokener_get_error(), return a human readable description of the error.

Returns
a generic error message is returned if an invalid error value is provided.
JSON_EXPORT void json_tokener_free ( struct json_tokener *  tok)

Free a json_tokener previously allocated with json_tokener_new().

JSON_EXPORT enum json_tokener_error json_tokener_get_error ( struct json_tokener *  tok)

Retrieve the error caused by the last call to json_tokener_parse_ex(), or json_tokener_success if there is no error.

When parsing a JSON string in pieces, if the tokener is in the middle of parsing this will return json_tokener_continue.

See Also
json_tokener_error_desc().
JSON_EXPORT size_t json_tokener_get_parse_end ( struct json_tokener *  tok)

Return the offset of the byte after the last byte parsed relative to the start of the most recent string passed in to json_tokener_parse_ex(). i.e. this is where parsing would start again if the input contains another JSON object after the currently parsed one.

Note that when multiple parse calls are issued, this is not the total number of characters parsed.

In the past this would have been accessed as tok->char_offset.

See json_tokener_parse_ex() for an example of how to use this.

JSON_EXPORT struct json_tokener* json_tokener_new ( void  )
read

Allocate a new json_tokener. When done using that to parse objects, free it with json_tokener_free(). See json_tokener_parse_ex() for usage details.

JSON_EXPORT struct json_tokener* json_tokener_new_ex ( int  depth)
read

Allocate a new json_tokener with a custom max nesting depth.

See Also
JSON_TOKENER_DEFAULT_DEPTH
JSON_EXPORT struct json_object* json_tokener_parse ( const char *  str)
read

Parse a json_object out of the string str.

If you need more control over how the parsing occurs, see json_tokener_parse_ex().

JSON_EXPORT struct json_object* json_tokener_parse_ex ( struct json_tokener *  tok,
const char *  str,
int  len 
)
read

Parse a string and return a non-NULL json_object if a valid JSON value is found. The string does not need to be a JSON object or array; it can also be a string, number or boolean value.

A partial JSON string can be parsed. If the parsing is incomplete, NULL will be returned and json_tokener_get_error() will return json_tokener_continue. json_tokener_parse_ex() can then be called with additional bytes in str to continue the parsing.

If json_tokener_parse_ex() returns NULL and the error is anything other than json_tokener_continue, a fatal error has occurred and parsing must be halted. Then, the tok object must not be reused until json_tokener_reset() is called.

When a valid JSON value is parsed, a non-NULL json_object will be returned, with a reference count of one which belongs to the caller. Also, json_tokener_get_error() will return json_tokener_success. Be sure to check the type with json_object_is_type() or json_object_get_type() before using the object.

Trailing characters after the parsed value do not automatically cause an error. It is up to the caller to decide whether to treat this as an error or to handle the additional characters, perhaps by parsing another json value starting from that point.

If the caller knows that they are at the end of their input, the length passed MUST include the final '\0' character, so values with no inherent end (i.e. numbers) can be properly parsed, rather than just returning json_tokener_continue.

Extra characters can be detected by comparing the value returned by json_tokener_get_parse_end() against the length of the last len parameter passed in.

The tokener does not maintain an internal buffer so the caller is responsible for a subsequent call to json_tokener_parse_ex with an appropriate str parameter starting with the extra characters.

This interface is presently not 64-bit clean due to the int len argument so the function limits the maximum string size to INT32_MAX (2GB). If the function is called with len == -1 then strlen is called to check the string length is less than INT32_MAX (2GB)

Example:

json_object *jobj = NULL;
const char *mystring = NULL;
int stringlen = 0;
enum json_tokener_error jerr;
do {
mystring = ... // get JSON string, e.g. read from file, etc...
stringlen = strlen(mystring);
if (end_of_input)
stringlen++; // Include the '\0' if we know we're at the end of input
jobj = json_tokener_parse_ex(tok, mystring, stringlen);
} while ((jerr = json_tokener_get_error(tok)) == json_tokener_continue);
if (jerr != json_tokener_success)
{
fprintf(stderr, "Error: %s\n", json_tokener_error_desc(jerr));
// Handle errors, as appropriate for your application.
}
if (json_tokener_get_parse_end(tok) < stringlen)
{
// Handle extra characters after parsed object as desired.
// e.g. issue an error, parse another object from that point, etc...
}
// Success, use jobj here.
Parameters
toka json_tokener previously allocated with json_tokener_new()
stran string with any valid JSON expression, or portion of. This does not need to be null terminated.
lenthe length of str
JSON_EXPORT struct json_object* json_tokener_parse_verbose ( const char *  str,
enum json_tokener_error *  error 
)
read

Parser a json_object out of the string str, but if it fails return the error in *error.

See Also
json_tokener_parse()
json_tokener_parse_ex()
JSON_EXPORT void json_tokener_reset ( struct json_tokener *  tok)

Reset the state of a json_tokener, to prepare to parse a brand new JSON object.

JSON_EXPORT void json_tokener_set_flags ( struct json_tokener *  tok,
int  flags 
)

Set flags that control how parsing will be done.

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/json__types_8h.html000066400000000000000000000317161446575330000222710ustar00rootroot00000000000000 json-c: json_types.h File Reference
Data Structures | Macros | Typedefs | Enumerations
json_types.h File Reference

Basic types used in a few places in json-c, but you should include "json_object.h" instead. More...

Data Structures

struct  json_object_iter
 

Macros

#define JSON_EXPORT   extern
 

Typedefs

typedef struct json_object_iter json_object_iter
 
typedef int json_bool
 
typedef struct json_object json_object
 The core type for all type of JSON objects handled by json-c.
 
typedef void( json_object_delete_fn )(struct json_object *jso, void *userdata)
 
typedef int( json_object_to_json_string_fn )(struct json_object *jso, struct printbuf *pb, int level, int flags)
 
typedef enum json_type json_type
 

Enumerations

enum  json_type {
  json_type_null, json_type_boolean, json_type_double, json_type_int,
  json_type_object, json_type_array, json_type_string
}
 

Detailed Description

Basic types used in a few places in json-c, but you should include "json_object.h" instead.

Macro Definition Documentation

#define JSON_EXPORT   extern

Typedef Documentation

typedef int json_bool
typedef struct json_object json_object

The core type for all type of JSON objects handled by json-c.

typedef void( json_object_delete_fn)(struct json_object *jso, void *userdata)

Type of custom user delete functions. See json_object_set_serializer.

typedef struct json_object_iter json_object_iter
typedef int( json_object_to_json_string_fn)(struct json_object *jso, struct printbuf *pb, int level, int flags)

Type of a custom serialization function. See json_object_set_serializer.

typedef enum json_type json_type

Enumeration Type Documentation

enum json_type
Enumerator:
json_type_null 
json_type_boolean 
json_type_double 
json_type_int 
json_type_object 
json_type_array 
json_type_string 
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/json__util_8h.html000066400000000000000000000604331446575330000221000ustar00rootroot00000000000000 json-c: json_util.h File Reference
Macros | Functions
json_util.h File Reference

Miscllaneous utility functions and macros. More...

Macros

#define json_min(a, b)   ((a) < (b) ? (a) : (b))
 
#define json_max(a, b)   ((a) > (b) ? (a) : (b))
 
#define JSON_FILE_BUF_SIZE   4096
 

Functions

JSON_EXPORT struct json_object * json_object_from_file (const char *filename)
 
JSON_EXPORT struct json_object * json_object_from_fd_ex (int fd, int depth)
 
JSON_EXPORT struct json_object * json_object_from_fd (int fd)
 
JSON_EXPORT int json_object_to_file (const char *filename, struct json_object *obj)
 
JSON_EXPORT int json_object_to_file_ext (const char *filename, struct json_object *obj, int flags)
 
JSON_EXPORT int json_object_to_fd (int fd, struct json_object *obj, int flags)
 
JSON_EXPORT const char * json_util_get_last_err (void)
 
JSON_EXPORT int json_parse_int64 (const char *buf, int64_t *retval)
 
JSON_EXPORT int json_parse_uint64 (const char *buf, uint64_t *retval)
 
JSON_EXPORT int json_parse_double (const char *buf, double *retval)
 
JSON_EXPORT const char * json_type_to_name (enum json_type o_type)
 

Detailed Description

Miscllaneous utility functions and macros.

Macro Definition Documentation

#define JSON_FILE_BUF_SIZE   4096
#define json_max (   a,
  b 
)    ((a) > (b) ? (a) : (b))
#define json_min (   a,
  b 
)    ((a) < (b) ? (a) : (b))

Function Documentation

JSON_EXPORT struct json_object* json_object_from_fd ( int  fd)
read

Create a JSON object from an already opened file descriptor, using the default maximum object depth. (JSON_TOKENER_DEFAULT_DEPTH)

See json_object_from_fd_ex() for details.

JSON_EXPORT struct json_object* json_object_from_fd_ex ( int  fd,
int  depth 
)
read

Create a JSON object from already opened file descriptor.

This function can be helpful, when you opened the file already, e.g. when you have a temp file. Note, that the fd must be readable at the actual position, i.e. use lseek(fd, 0, SEEK_SET) before.

The depth argument specifies the maximum object depth to pass to json_tokener_new_ex(). When depth == -1, JSON_TOKENER_DEFAULT_DEPTH is used instead.

Returns NULL on failure. See json_util_get_last_err() for details.

JSON_EXPORT struct json_object* json_object_from_file ( const char *  filename)
read

Read the full contents of the given file, then convert it to a json_object using json_tokener_parse().

Returns NULL on failure. See json_util_get_last_err() for details.

JSON_EXPORT int json_object_to_fd ( int  fd,
struct json_object *  obj,
int  flags 
)

Convert the json_object to a string and write it to the file descriptor. Handles partial writes and will keep writing until done, or an error occurs.

Parameters
fdan open, writable file descriptor to write to
objthe object to serializer and write
flagsflags to pass to json_object_to_json_string_ext()
Returns
-1 if something fails. See json_util_get_last_err() for details.
JSON_EXPORT int json_object_to_file ( const char *  filename,
struct json_object *  obj 
)

Equivalent to: json_object_to_file_ext(filename, obj, JSON_C_TO_STRING_PLAIN);

Returns -1 if something fails. See json_util_get_last_err() for details.

JSON_EXPORT int json_object_to_file_ext ( const char *  filename,
struct json_object *  obj,
int  flags 
)

Open and truncate the given file, creating it if necessary, then convert the json_object to a string and write it to the file.

Returns -1 if something fails. See json_util_get_last_err() for details.

JSON_EXPORT int json_parse_double ( const char *  buf,
double *  retval 
)
Deprecated:
JSON_EXPORT int json_parse_int64 ( const char *  buf,
int64_t *  retval 
)

A parsing helper for integer values. Returns 0 on success, with the parsed value assigned to *retval. Overflow/underflow are NOT considered errors, but errno will be set to ERANGE, just like the strtol/strtoll functions do.

JSON_EXPORT int json_parse_uint64 ( const char *  buf,
uint64_t *  retval 
)

A parsing help for integer values, providing one extra bit of magnitude beyond json_parse_int64().

JSON_EXPORT const char* json_type_to_name ( enum json_type  o_type)

Return a string describing the type of the object. e.g. "int", or "object", etc...

JSON_EXPORT const char* json_util_get_last_err ( void  )

Return the last error from various json-c functions, including: json_object_to_file{,ext}, json_object_to_fd() or json_object_from{file,fd}, or NULL if there is none.

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/json__visit_8h.html000066400000000000000000000311131446575330000222520ustar00rootroot00000000000000 json-c: json_visit.h File Reference
Macros | Typedefs | Functions
json_visit.h File Reference

Methods for walking a tree of objects. More...

Macros

#define JSON_C_VISIT_SECOND   0x02
 
#define JSON_C_VISIT_RETURN_CONTINUE   0
 
#define JSON_C_VISIT_RETURN_SKIP   7547
 
#define JSON_C_VISIT_RETURN_POP   767
 
#define JSON_C_VISIT_RETURN_STOP   7867
 
#define JSON_C_VISIT_RETURN_ERROR   -1
 

Typedefs

typedef int( json_c_visit_userfunc )(json_object *jso, int flags, json_object *parent_jso, const char *jso_key, size_t *jso_index, void *userarg)
 

Functions

JSON_EXPORT int json_c_visit (json_object *jso, int future_flags, json_c_visit_userfunc *userfunc, void *userarg)
 

Detailed Description

Methods for walking a tree of objects.

Macro Definition Documentation

#define JSON_C_VISIT_RETURN_CONTINUE   0

This json_c_visit_userfunc return value indicates that iteration should proceed normally.

#define JSON_C_VISIT_RETURN_ERROR   -1

This json_c_visit_userfunc return value indicates that iteration should stop immediately, and cause json_c_visit to return an error.

#define JSON_C_VISIT_RETURN_POP   767

This json_c_visit_userfunc return value indicates that iteration of the fields/elements of the containing object should stop and continue "popped up" a level of the object hierarchy. For example, returning this when handling arg will result in arg3 and any other fields being skipped. The next call to userfunc will be the JSON_C_VISIT_SECOND call on "foo", followed by a userfunc call on "bar". 

{
  "foo": {
    "arg1": 1,
    "arg2": 2,
    "arg3": 3,
    ...
  },
  "bar": {
    ...
  }
}
#define JSON_C_VISIT_RETURN_SKIP   7547

This json_c_visit_userfunc return value indicates that iteration over the members of the current object should be skipped. If the current object isn't a container (array or object), this is no different than JSON_C_VISIT_RETURN_CONTINUE.

#define JSON_C_VISIT_RETURN_STOP   7867

This json_c_visit_userfunc return value indicates that iteration should stop immediately, and cause json_c_visit to return success.

#define JSON_C_VISIT_SECOND   0x02

Passed to json_c_visit_userfunc as one of the flags values to indicate that this is the second time a container (array or object) is being called, after all of it's members have been iterated over.

Typedef Documentation

typedef int( json_c_visit_userfunc)(json_object *jso, int flags, json_object *parent_jso, const char *jso_key, size_t *jso_index, void *userarg)

Function Documentation

JSON_EXPORT int json_c_visit ( json_object *  jso,
int  future_flags,
json_c_visit_userfunc *  userfunc,
void *  userarg 
)

Visit each object in the JSON hierarchy starting at jso. For each object, userfunc is called, passing the object and userarg. If the object has a parent (i.e. anything other than jso itself) its parent will be passed as parent_jso, and either jso_key or jso_index will be set, depending on whether the parent is an object or an array.

Nodes will be visited depth first, but containers (arrays and objects) will be visited twice, the second time with JSON_C_VISIT_SECOND set in flags.

userfunc must return one of the defined return values, to indicate whether and how to continue visiting nodes, or one of various ways to stop.

Returns 0 if nodes were visited successfully, even if some were intentionally skipped due to what userfunc returned. Returns <0 if an error occurred during iteration, including if userfunc returned JSON_C_VISIT_RETURN_ERROR.

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/linkhash_8h.html000066400000000000000000001577171446575330000215500ustar00rootroot00000000000000 json-c: linkhash.h File Reference
Data Structures | Macros | Typedefs | Functions
linkhash.h File Reference

Internal methods for working with json_type_object objects. Although this is exposed by the json_object_get_object() function and within the json_object_iter type, it is not recommended for direct use. More...

Data Structures

struct  lh_entry
 
struct  lh_table
 

Macros

#define LH_PRIME   0x9e370001UL
 
#define LH_LOAD_FACTOR   0.66
 
#define LH_EMPTY   (void *)-1
 
#define LH_FREED   (void *)-2
 
#define JSON_C_STR_HASH_DFLT   0
 
#define JSON_C_STR_HASH_PERLLIKE   1
 
#define lh_foreach(table, entry)   for (entry = lh_table_head(table); entry; entry = lh_entry_next(entry))
 
#define lh_foreach_safe(table, entry, tmp)   for (entry = lh_table_head(table); entry && ((tmp = lh_entry_next(entry)) || 1); entry = tmp)
 

Typedefs

typedef void( lh_entry_free_fn )(struct lh_entry *e)
 
typedef unsigned long( lh_hash_fn )(const void *k)
 
typedef int( lh_equal_fn )(const void *k1, const void *k2)
 
typedef struct lh_table lh_table
 

Functions

int json_global_set_string_hash (const int h)
 
struct lh_table * lh_table_new (int size, lh_entry_free_fn *free_fn, lh_hash_fn *hash_fn, lh_equal_fn *equal_fn)
 
struct lh_table * lh_kchar_table_new (int size, lh_entry_free_fn *free_fn)
 
struct lh_table * lh_kptr_table_new (int size, lh_entry_free_fn *free_fn)
 
void lh_table_free (struct lh_table *t)
 
int lh_table_insert (struct lh_table *t, const void *k, const void *v)
 
int lh_table_insert_w_hash (struct lh_table *t, const void *k, const void *v, const unsigned long h, const unsigned opts)
 
struct lh_entry * lh_table_lookup_entry (struct lh_table *t, const void *k)
 
struct lh_entry * lh_table_lookup_entry_w_hash (struct lh_table *t, const void *k, const unsigned long h)
 
json_bool lh_table_lookup_ex (struct lh_table *t, const void *k, void **v)
 
int lh_table_delete_entry (struct lh_table *t, struct lh_entry *e)
 
int lh_table_delete (struct lh_table *t, const void *k)
 
int lh_table_length (struct lh_table *t)
 
int lh_table_resize (struct lh_table *t, int new_size)
 
static struct lh_entry * lh_table_head (const lh_table *t)
 
static unsigned long lh_get_hash (const struct lh_table *t, const void *k)
 
static void * lh_entry_k (const struct lh_entry *e)
 
static int lh_entry_k_is_constant (const struct lh_entry *e)
 
static void * lh_entry_v (const struct lh_entry *e)
 
static void lh_entry_set_val (struct lh_entry *e, void *newval)
 
static struct lh_entry * lh_entry_next (const struct lh_entry *e)
 
static struct lh_entry * lh_entry_prev (const struct lh_entry *e)
 

Detailed Description

Internal methods for working with json_type_object objects. Although this is exposed by the json_object_get_object() function and within the json_object_iter type, it is not recommended for direct use.

Macro Definition Documentation

#define JSON_C_STR_HASH_DFLT   0

default string hash function

#define JSON_C_STR_HASH_PERLLIKE   1

perl-like string hash function

#define LH_EMPTY   (void *)-1

sentinel pointer value for empty slots

#define lh_foreach (   table,
  entry 
)    for (entry = lh_table_head(table); entry; entry = lh_entry_next(entry))

Convenience list iterator.

#define lh_foreach_safe (   table,
  entry,
  tmp 
)    for (entry = lh_table_head(table); entry && ((tmp = lh_entry_next(entry)) || 1); entry = tmp)

lh_foreach_safe allows calling of deletion routine while iterating.

Parameters
tablea struct lh_table * to iterate over
entrya struct lh_entry * variable to hold each element
tmpa struct lh_entry * variable to hold a temporary pointer to the next element
#define LH_FREED   (void *)-2

sentinel pointer value for freed slots

#define LH_LOAD_FACTOR   0.66

The fraction of filled hash buckets until an insert will cause the table to be resized. This can range from just above 0 up to 1.0.

#define LH_PRIME   0x9e370001UL

golden prime used in hash functions

Typedef Documentation

typedef void( lh_entry_free_fn)(struct lh_entry *e)

callback function prototypes

typedef int( lh_equal_fn)(const void *k1, const void *k2)

callback function prototypes

typedef unsigned long( lh_hash_fn)(const void *k)

callback function prototypes

typedef struct lh_table lh_table

Function Documentation

int json_global_set_string_hash ( const int  h)

This function sets the hash function to be used for strings. Must be one of the JSON_C_STR_HASH_* values.

Returns
0 - ok, -1 if parameter was invalid
static void* lh_entry_k ( const struct lh_entry *  e)
inlinestatic

Return a non-const version of lh_entry.k.

lh_entry.k is const to indicate and help ensure that linkhash itself doesn't modify it, but callers are allowed to do what they want with it.

See Also
lh_entry_k_is_constant()

References lh_entry::k.

static int lh_entry_k_is_constant ( const struct lh_entry *  e)
inlinestatic

Returns 1 if the key for the given entry is constant, and thus does not need to be freed when the lh_entry is freed.

See Also
lh_table_insert_w_hash()

References lh_entry::k_is_constant.

static struct lh_entry* lh_entry_next ( const struct lh_entry *  e)
staticread

Return the next element, or NULL if there is no next element.

See Also
lh_table_head()
lh_entry_prev()

References lh_entry::next.

static struct lh_entry* lh_entry_prev ( const struct lh_entry *  e)
staticread

Return the previous element, or NULL if there is no previous element.

See Also
lh_table_head()
lh_entry_next()

References lh_entry::prev.

static void lh_entry_set_val ( struct lh_entry *  e,
void *  newval 
)
inlinestatic

Change the value for an entry. The caller is responsible for freeing the previous value.

References lh_entry::v.

static void* lh_entry_v ( const struct lh_entry *  e)
inlinestatic

Return a non-const version of lh_entry.v.

v is const to indicate and help ensure that linkhash itself doesn't modify it, but callers are allowed to do what they want with it.

References lh_entry::v.

static unsigned long lh_get_hash ( const struct lh_table *  t,
const void *  k 
)
inlinestatic

Calculate the hash of a key for a given table.

This is an extension to support functions that need to calculate the hash several times and allows them to do it just once and then pass in the hash to all utility functions. Depending on use case, this can be a considerable performance improvement.

Parameters
tthe table (used to obtain hash function)
ka pointer to the key to lookup
Returns
the key's hash

References lh_table::hash_fn.

struct lh_table* lh_kchar_table_new ( int  size,
lh_entry_free_fn *  free_fn 
)
read

Convenience function to create a new linkhash table with char keys.

Parameters
sizeinitial table size.
free_fncallback function used to free memory for entries.
Returns
On success, a pointer to the new linkhash table is returned. On error, a null pointer is returned.
struct lh_table* lh_kptr_table_new ( int  size,
lh_entry_free_fn *  free_fn 
)
read

Convenience function to create a new linkhash table with ptr keys.

Parameters
sizeinitial table size.
free_fncallback function used to free memory for entries.
Returns
On success, a pointer to the new linkhash table is returned. On error, a null pointer is returned.
int lh_table_delete ( struct lh_table *  t,
const void *  k 
)

Delete a record from the table.

If a callback free function is provided then it is called for the for the item being deleted.

Parameters
tthe table to delete from.
ka pointer to the key to delete.
Returns
0 if the item was deleted.
-1 if it was not found.
int lh_table_delete_entry ( struct lh_table *  t,
struct lh_entry *  e 
)

Delete a record from the table.

If a callback free function is provided then it is called for the for the item being deleted.

Parameters
tthe table to delete from.
ea pointer to the entry to delete.
Returns
0 if the item was deleted.
-1 if it was not found.
void lh_table_free ( struct lh_table *  t)

Free a linkhash table.

If a lh_entry_free_fn callback free function was provided then it is called for all entries in the table.

Parameters
ttable to free.
static struct lh_entry* lh_table_head ( const lh_table *  t)
staticread

Return the first entry in the lh_table.

See Also
lh_entry_next()

References lh_table::head.

int lh_table_insert ( struct lh_table *  t,
const void *  k,
const void *  v 
)

Insert a record into the table.

Parameters
tthe table to insert into.
ka pointer to the key to insert.
va pointer to the value to insert.
Returns
On success, 0 is returned. On error, a negative value is returned.
int lh_table_insert_w_hash ( struct lh_table *  t,
const void *  k,
const void *  v,
const unsigned long  h,
const unsigned  opts 
)

Insert a record into the table using a precalculated key hash.

The hash h, which should be calculated with lh_get_hash() on k, is provided by the caller, to allow for optimization when multiple operations with the same key are known to be needed.

Parameters
tthe table to insert into.
ka pointer to the key to insert.
va pointer to the value to insert.
hhash value of the key to insert
optsif set to JSON_C_OBJECT_ADD_CONSTANT_KEY, sets lh_entry.k_is_constant so t's free function knows to avoid freeing the key.
int lh_table_length ( struct lh_table *  t)

Return the number of entries in the table.

struct lh_entry* lh_table_lookup_entry ( struct lh_table *  t,
const void *  k 
)
read

Lookup a record in the table.

Parameters
tthe table to lookup
ka pointer to the key to lookup
Returns
a pointer to the record structure of the value or NULL if it does not exist.
struct lh_entry* lh_table_lookup_entry_w_hash ( struct lh_table *  t,
const void *  k,
const unsigned long  h 
)
read

Lookup a record in the table using a precalculated key hash.

The hash h, which should be calculated with lh_get_hash() on k, is provided by the caller, to allow for optimization when multiple operations with the same key are known to be needed.

Parameters
tthe table to lookup
ka pointer to the key to lookup
hhash value of the key to lookup
Returns
a pointer to the record structure of the value or NULL if it does not exist.
json_bool lh_table_lookup_ex ( struct lh_table *  t,
const void *  k,
void **  v 
)

Lookup a record in the table.

Parameters
tthe table to lookup
ka pointer to the key to lookup
va pointer to a where to store the found value (set to NULL if it doesn't exist).
Returns
whether or not the key was found
struct lh_table* lh_table_new ( int  size,
lh_entry_free_fn *  free_fn,
lh_hash_fn *  hash_fn,
lh_equal_fn *  equal_fn 
)
read

Create a new linkhash table.

Parameters
sizeinitial table size. The table is automatically resized although this incurs a performance penalty.
free_fncallback function used to free memory for entries when lh_table_free or lh_table_delete is called. If NULL is provided, then memory for keys and values must be freed by the caller.
hash_fnfunction used to hash keys. 2 standard ones are defined: lh_ptr_hash and lh_char_hash for hashing pointer values and C strings respectively.
equal_fncomparison function to compare keys. 2 standard ones defined: lh_ptr_hash and lh_char_hash for comparing pointer values and C strings respectively.
Returns
On success, a pointer to the new linkhash table is returned. On error, a null pointer is returned.
int lh_table_resize ( struct lh_table *  t,
int  new_size 
)

Resizes the specified table.

Parameters
tPointer to table to resize.
new_sizeNew table size. Must be positive.
Returns
On success, 0 is returned. On error, a negative value is returned.
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/md_README.html000066400000000000000000000034461446575330000207520ustar00rootroot00000000000000 json-c: README
README
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/md_issues_closed_for_0.html000066400000000000000000002742471446575330000237570ustar00rootroot00000000000000 json-c: issues_closed_for_0
issues_closed_for_0

This list was created with: 

curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2014-04-10+created%3A<2017-12-01&sort=created&order=asc&per_page=400&page=1" > issues1.out
curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2014-04-10+created%3A<2017-12-01&sort=created&order=asc&per_page=400&page=2" > issues2.out
curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2014-04-10+created%3A<2017-12-01&sort=created&order=asc&per_page=400&page=3" > issues3.out
jq -r '.items[] | "[" + .title + "](" + .url + ")" | tostring' issues?.out  > issues.md
sed -e's,^\[ *\(.*\)\](https://api.github.com/.*/\([0-9].*\)),[Issue #\2](https://github.com/json-c/json-c/issues/\2) - \1,' -i issues.md
#... manual editing ...

Issues and Pull Requests closed for the 0.13 release (since commit f84d9c, the 0.12 branch point, 2014-04-10)

This list was created with: 

curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2017-12-07+created%3A<2020-04-17&sort=created&order=asc&per_page=400&page=1" > issues1.out
curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2017-12-07+created%3A<2020-04-17&sort=created&order=asc&per_page=400&page=2" > issues2.out
curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2017-12-07+created%3A<2020-04-17&sort=created&order=asc&per_page=400&page=3" > issues3.out
jq -r '.items[] | "[" + .title + "](" + .url + ")" | tostring' issues?.out > issues.md
sed -e's,^\[ *\(.*\)\](https://api.github.com/.*/\([0-9].*\)),[Issue #\2](https://github.com/json-c/json-c/issues/\2) - \1,' -i issues.md
#... manual editing ...

Issues and Pull Requests closed for the 0.14 release (since commit d582d3a(2017-12-07) to a911439(2020-04-17))

This list was created with: 

curl "https://api.github.com/search/issues?q=repo%3Ajson-c%2Fjson-c+closed%3A>2020-04-18+created%3A<2020-07-23&sort=created&order=asc&per_page=100&page=1" > issues1.out
jq -r '.items[] | "[" + .title + "](" + .url + ")" | tostring' issues?.out > issues.md
sed -e's,^\[ *\(.*\)\](https://api.github.com/.*/\([0-9].*\)),* [Issue #\2](https://github.com/json-c/json-c/issues/\2) - \1,' -i issues.md
#... manual editing ...

Issues and Pull Requests closed for the 0.15 release (since commit 31ab57ca, the 0.14 branch point, 2020-04-19)

  • Issue #428 - Added new_null() function
  • Issue #429 - Conflict of interest between JSON_C_TO_STRING_SPACED and JSON_C_TO_STRING_PRETTY
  • Issue #451 - Add option to disable HAVE___THREAD
  • Issue #471 - create folders with mode 0755 when building
  • Issue #476 - Add new function named json_object_new_string_noalloc
  • Issue #484 - Add support for uint64
  • Issue #487 - Any plans to make new release? (0.14)
  • Issue #493 - Kdopen rename library
  • Issue #507 - Double value -1.0 converts to integer in json_object_to_json_string()
  • Issue #508 - Recommend enabling the -fPIC compiler flag by default
  • Issue #517 - Lja mods
  • Issue #534 - Both json-c and json-glib have json_object_get_type()
  • Issue #584 - CMake: SOVERSION and the major library VERSION need to be in lockstep.
  • Issue #585 - CMake: Do not install config.h, as it is not a public header file.
  • Issue #586 - 10796 Segmentation fault
  • Issue #588 - Broken RDRAND causes infinite looping
  • Issue #589 - Detect broken RDRAND during initialization
  • Issue #590 - Fix segmentation fault in CPUID check
  • Issue #591 - Update README.md
  • Issue #592 - Prevent out of boundary write on malicious input
  • Issue #593 - Building both static and shared libraries
  • Issue #594 - Some subsequent call of lh_get_hash not working
  • Issue #595 - Support to build both static and shared libraries
  • Issue #596 - QA Notice: Package triggers severe warnings
  • Issue #597 - json_parse demo: fix and use usage() function
  • Issue #598 - Turning off shared libs causes target duplication or build error
  • Issue #599 - cannot add more than 11 objects. Is this a known issue?
  • Issue #600 - Library name conflicts on Windows are back again
  • Issue #601 - json_tokener_parse() in master sets errno=1 "Operation not permitted"
  • Issue #602 - fix json_parse_uint64() internal error checking with errno
  • Issue #603 - Backport of fixes from master branch.
  • Issue #604 - commit f2e991a3419ee4078e8915e840b1a0d9003b349e breaks cross-compilation with mingw
  • Issue #605 - Update to 0.15 release
  • Issue #606 - Improved support for IBM operating systems
  • Issue #607 - json-c-0.13.x: Fix CVE-2020-12762 - json-c through 0.14 has an integer overflow and out-of-bounds write ...
  • Issue #608 - json-c-0.14: Fix CVE-2020-12762 - json-c through 0.14 has an integer overflow and out-of-bounds write ...
  • Issue #609 - use unsigned types for sizes in lh_table and entries
  • Issue #610 - let's not call lh_table_resize with INT_MAX
  • Issue #611 - json-c-0.12.x: Fix CVE-2020-12762 - json-c through 0.14 has an integer overflow and out-of-bounds write ...
  • Issue #613 - json-c-0.10: Fix CVE-2020-12762 - json-c through 0.14 has an integer overflow and out-of-bounds write ...
  • Issue #614 - Prevent truncation on custom double formatters.
  • Issue #615 - New release with security fix
  • Issue #616 - Parsing fails if UTF-16 low surrogate pair is not in same chunk is the high pair
  • Issue #617 - Add an option to disable the use of thread-local storage.
  • Issue #618 - test_deep_copy: Fix assertion value.
  • Issue #619 - CMake: Fix out-of-tree build for Doxygen documentation.
  • Issue #621 - json-c and jansson libraries have symbol conflicts
  • Issue #622 - doc: Move Doxyfile into doc subdir.
  • Issue #623 - json_tokener_parse : Segmentation fault
  • Issue #626 - Fixes for cmake 2.8.12 + link issue on AIX 6.1/cc 11.01
  • Issue #627 - Compat fixes
  • Issue #628 - get_cryptgenrandom_seed: compat with old windows + fallback
  • Issue #629 - [0.12] Remove the Visual Studio project file
  • Issue #630 - Linking with Windows MINGW not working
  • Issue #632 - Json object split
  • Issue #633 - fix issue 616: support the surrogate pair in split file.
  • Issue #634 - Issue #508: -fPIC to link libjson-c.a with libs
  • Issue #635 - expression has no effect warning in json_tokener.c
  • Issue #636 - json_object_get_string free str memory
  • Issue #637 - json_object_put() has 'double free or corruption (out) '
  • Issue #638 - json-c/json_object.c:50:2: error: #error Unable to determine size of ssize_t
  • Issue #639 - build: Add a symbol version to all exported symbols
  • Issue #640 - Fix build issues with SSIZE_MAX on 64bit Linux
  • Issue #641 - Formal verification of your test suite
  • Issue #642 - Please provide more precise informations about when to call json_object_put
  • Issue #643 - not able to compare with string
  • Issue #644 - Why src->_userdata not checked before calling strdup?
  • Issue #645 - Misuse of tolower() in json_tokener.c
  • Issue #646 - Cast to unsigned char instead of int when calling tolower (Fixes #645)

This list was created with: 

PREV=2020-07-23
NOW=2022-04-13
curl "https://api.github.com/search/issues?q=repo%3Ajson-c%2Fjson-c+closed%3A>${PREV}+created%3A<${NOW}&sort=created&order=asc&per_page=100&page=1" > issues1.out
jq -r '.items[] | "[" + .title + "](" + .url + ")" | tostring' issues?.out > issues.md
sed -e's,^\[ *\(.*\)\](https://api.github.com/.*/\([0-9].*\)),* [Issue #\2](https://github.com/json-c/json-c/issues/\2) - \1,' -i issues.md
cat issues.md >> issues_closed_for_0.16.md

This list was created with: 

PREV=2022-04-13
NOW=2023-08-12
curl "https://api.github.com/search/issues?q=repo%3Ajson-c%2Fjson-c+closed%3A>${PREV}+created%3A<${NOW}&sort=created&order=asc&per_page=100&page=1" > issues1.out
jq -r '.items[] | "[" + .title + "](" + .url + ")" | tostring' issues?.out > issues.md
sed -e's,^\[ *\(.*\)\](https://api.github.com/.*/\([0-9].*\)),* [Issue #\2](https://github.com/json-c/json-c/issues/\2) - \1,' -i issues.md
cat issues.md >> issues_closed_for_0.17.md
  • Issue #191 - Override int64 to only display uint64 strings
  • Issue #537 - Replace '\0' only when parsing key, not change data in value.
  • Issue #570 - Figure out what needs to be done with Android.configure.mk
  • Issue #587 - Store the hashValue to avoid repeating the hash calculation during the hash resize.
  • Issue #612 - json-c-0.11: Fix CVE-2020-12762 - json-c through 0.14 has an integer overflow and out-of-bounds write ...
  • Issue #620 - Introduce json_object_new_string_{ext,noalloc}().
  • Issue #624 - json-c-0.14: Detect broken RDRAND during initialization.
  • Issue #625 - json-c-0.13.x: Detect broken RDRAND during initialization.
  • Issue #668 - Memory usage regression due to newlocal() on older FreeBSD releases
  • Issue #676 - dereferencing type-punned pointer might break strict-aliasing rules [-Werror=strict-aliasing]
  • Issue #677 - Naming conflict when using both json-c and jansson
  • Issue #679 - Let json-c be used with obsolete compilers
  • Issue #681 - json_tokener_parse_ex: null (4 bytes) only parses as valid JSON when passed with null terminator (5 bytes). Documentation issue?
  • Issue #686 - Remove dependency on libM::getrandom
  • Issue #687 - Does not build on Apple Silicon M1
  • Issue #688 - json-c-0.15-nodoc.tar.gz build fails
  • Issue #702 - json_patch: add first implementation only with patch application
  • Issue #704 - add json_object_array_insert_idx() + test-cases + fix json_pointer doc-strings
  • Issue #705 - segmentation fault on json-c parsing methods in cross compiled target
  • Issue #721 - cmake test fails with building json-c with icc
  • Issue #730 - Need a comparison with other JSON libraries in C
  • Issue #733 - Official release? 1.0?
  • Issue #756 - Question: Is there any way to build this with Gnu Make?
  • Issue #757 - json_object_from_fd_ex: fail if file is too large
  • Issue #759 - json_tokener_parse_ex: handle out of memory errors
  • Issue #766 - Some people have trouble with undefined references to arc4random
  • Issue #767 - How to create a character array using json-c
  • Issue #768 - commits from May 30, 2022 killed my docker build process
  • Issue #769 - Issue #768
  • Issue #770 - json_parse.c:170:13: error: this statement may fall through
  • Issue #771 - fix fallthough warning
  • Issue #772 - add JSON_C_TO_STRING_COLOR option
  • Issue #773 - problem with u_int64_t
  • Issue #774 - The function add_compile_options was added to CMake version 2.8.12 and later but your minimum is 2.8 which will not work
  • Issue #775 - list(TRANSFORM ...) is not available prior to CMake 3.12.
  • Issue #776 - Fix typo
  • Issue #777 - Don't try to change locale when libc only supports the C locale
  • Issue #778 - Do not insert newlines when converting empty arrays to json string and JSON_C_TO_STRING_PRETTY is used
  • Issue #779 - Fix compiling for Android
  • Issue #780 - Memory Leak when setting empty strings when c_string.pdata is used
  • Issue #781 - Fix memory leak with emtpy strings in json_object_set_string
  • Issue #782 - Fix typos found by codespell
  • Issue #783 - Fix build with clang-15+
  • Issue #784 - get_time_seed(): silence warning emitted by Coverity Scan static analyzer
  • Issue #786 - ghpages update was not published for json-c-0.16
  • Issue #787 - -static linker flag result in building failed
  • Issue #788 - Clear sensitive information.
  • Issue #789 - Unnecessary struct declaration and unsafe function usage
  • Issue #790 - Small update to README file
  • Issue #791 - json_object_object_foreach not ISO-C compliant
  • Issue #792 - json_object_get_int does not set EINVAL on invalid string
  • Issue #794 - replaced
  • Issue #796 - Added Test for get int functions
  • Issue #797 - make uninstall
  • Issue #798 - API to deal with enums is missing
  • Issue #799 - json_object_put: Assertion `jso->_ref_count > 0' failed.
  • Issue #800 - String converted to scientific notation
  • Issue #801 - #error You do not have strncasecmp on your system.
  • Issue #802 - Problem: modern CMake warns about version 2.8
  • Issue #803 - Problem: confusing error message in snprintf_compat.h
  • Issue #804 - Problem: cmake 3.25.1 warns about CMP0042 not being set
  • Issue #806 - The problem is libjson-c.dylib incompatible with OS version
  • Issue #807 - json simple parse syntax
  • Issue #808 - iOS Build using cmake fails due to 64 to 32bits conversion precision loss
  • Issue #809 - Feature request json_object_new_uint()
  • Issue #810 - docs: update to Internet Standard reference
  • Issue #811 - dependence on execution character set
  • Issue #812 - Duplicate symbol when compiling with clang-cl
  • Issue #813 - Build apps only in project itself.
  • Issue #814 - Code execution order
  • Issue #816 - Hi I need to generate libjson-c.so.3 and libjson-c.so.3.0.1, please help with steps
  • Issue #818 - error: a function declaration without a prototype is deprecated in all versions of C
  • Issue #819 - build with intel 2023 fails on vasprintf
  • Issue #820 - ISO C forbids in
  • Issue #821 - Any release planing for 0.17?
  • Issue #822 - Added option to disable app build
  • Issue #823 - Symbol not found during linking stage of libjson-c.so
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/nav_f.png000066400000000000000000000002311446575330000202330ustar00rootroot00000000000000PNG  IHDR8`IDATxK Eі[BmkHprӼ.ꎤR6Z VIE5jliIJ0/u޿6sH yIENDB`json-c-json-c-0.17-20230812/doc/html/nav_g.png000066400000000000000000000001371446575330000202410ustar00rootroot00000000000000PNG  IHDR1&IDATx1 OHf_ ->~M iMS<IENDB`json-c-json-c-0.17-20230812/doc/html/nav_h.png000066400000000000000000000001421446575330000202360ustar00rootroot00000000000000PNG  IHDR ,@)IDATxA @BQۛТ) ) aܿoRlIENDB`json-c-json-c-0.17-20230812/doc/html/open.png000066400000000000000000000001731446575330000201100ustar00rootroot00000000000000PNG  IHDR BIDATx 0 ׬ՙ\39b!9{|I>$#ߴ8/z/>2[giU,/~\ 9ٸIENDB`json-c-json-c-0.17-20230812/doc/html/pages.html000066400000000000000000000050461446575330000204320ustar00rootroot00000000000000 json-c: Related Pages
Related Pages
Here is a list of all related documentation pages:
oissues_closed_for_0
oREADME
\Deprecated List
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/printbuf_8h.html000066400000000000000000000502121446575330000215560ustar00rootroot00000000000000 json-c: printbuf.h File Reference
Data Structures | Macros | Typedefs | Functions
printbuf.h File Reference

Internal string buffer handling. Unless you're writing a json_object_to_json_string_fn implementation for use with json_object_set_serializer() direct use of this is not recommended. More...

Data Structures

struct  printbuf
 

Macros

#define JSON_EXPORT   extern
 
#define printbuf_memappend_fast(p, bufptr, bufsize)
 
#define printbuf_length(p)   ((p)->bpos)
 
#define printbuf_strappend(pb, str)   printbuf_memappend((pb), _printbuf_check_literal(str), sizeof(str) - 1)
 

Typedefs

typedef struct printbuf printbuf
 

Functions

JSON_EXPORT struct printbuf * printbuf_new (void)
 
JSON_EXPORT int printbuf_memappend (struct printbuf *p, const char *buf, int size)
 
JSON_EXPORT int printbuf_memset (struct printbuf *pb, int offset, int charvalue, int len)
 
JSON_EXPORT int sprintbuf (struct printbuf *p, const char *msg,...)
 
JSON_EXPORT void printbuf_reset (struct printbuf *p)
 
JSON_EXPORT void printbuf_free (struct printbuf *p)
 

Detailed Description

Internal string buffer handling. Unless you're writing a json_object_to_json_string_fn implementation for use with json_object_set_serializer() direct use of this is not recommended.

Macro Definition Documentation

#define JSON_EXPORT   extern
#define printbuf_length (   p)    ((p)->bpos)
#define printbuf_memappend_fast (   p,
  bufptr,
  bufsize 
)
Value:
do \
{ \
if ((p->size - p->bpos) > bufsize) \
{ \
memcpy(p->buf + p->bpos, (bufptr), bufsize); \
p->bpos += bufsize; \
p->buf[p->bpos] = '\0'; \
} \
else \
{ \
printbuf_memappend(p, (bufptr), bufsize); \
} \
} while (0)
#define printbuf_strappend (   pb,
  str 
)    printbuf_memappend((pb), _printbuf_check_literal(str), sizeof(str) - 1)

This is an optimization wrapper around printbuf_memappend() that is useful for appending string literals. Since the size of string constants is known at compile time, using this macro can avoid a costly strlen() call. This is especially helpful when a constant string must be appended many times. If you got here because of a compilation error caused by passing something other than a string literal, use printbuf_memappend_fast() in conjunction with strlen().

See also: printbuf_memappend_fast() printbuf_memappend() sprintbuf()

Typedef Documentation

typedef struct printbuf printbuf

Function Documentation

JSON_EXPORT void printbuf_free ( struct printbuf *  p)
JSON_EXPORT int printbuf_memappend ( struct printbuf *  p,
const char *  buf,
int  size 
)
JSON_EXPORT int printbuf_memset ( struct printbuf *  pb,
int  offset,
int  charvalue,
int  len 
)

Set len bytes of the buffer to charvalue, starting at offset offset. Similar to calling memset(x, charvalue, len);

The memory allocated for the buffer is extended as necessary.

If offset is -1, this starts at the end of the current data in the buffer.

JSON_EXPORT struct printbuf* printbuf_new ( void  )
read
JSON_EXPORT void printbuf_reset ( struct printbuf *  p)
JSON_EXPORT int sprintbuf ( struct printbuf *  p,
const char *  msg,
  ... 
)

Formatted print to printbuf.

This function is the most expensive of the available functions for appending string data to a printbuf and should be used only where convenience is more important than speed. Avoid using this function in high performance code or tight loops; in these scenarios, consider using snprintf() with a static buffer in conjunction with one of the printbuf_*append() functions.

See also: printbuf_memappend_fast() printbuf_memappend() printbuf_strappend()

Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/structarray__list.html000066400000000000000000000122521446575330000231050ustar00rootroot00000000000000 json-c: array_list Struct Reference
Data Fields
array_list Struct Reference

Data Fields

void ** array
 
size_t length
 
size_t size
 
array_list_free_fn * free_fn
 

Field Documentation

void** array_list::array
array_list_free_fn* array_list::free_fn
size_t array_list::length
size_t array_list::size
The documentation for this struct was generated from the following file:
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/structjson__object__iter.html000066400000000000000000000117471446575330000244250ustar00rootroot00000000000000 json-c: json_object_iter Struct Reference
Data Fields
json_object_iter Struct Reference

Data Fields

char * key
 
struct json_object * val
 
struct lh_entry * entry
 

Detailed Description

A structure to use with json_object_object_foreachC() loops. Contains key, val and entry members.

Field Documentation

struct lh_entry* json_object_iter::entry
char* json_object_iter::key
struct json_object* json_object_iter::val
The documentation for this struct was generated from the following file:
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/structjson__object__iterator.html000066400000000000000000000066071446575330000253120ustar00rootroot00000000000000 json-c: json_object_iterator Struct Reference
Data Fields
json_object_iterator Struct Reference

Data Fields

const void * opaque_
 

Detailed Description

The opaque iterator that references a name/value pair within a JSON Object instance or the "end" iterator value.

Field Documentation

const void* json_object_iterator::opaque_
The documentation for this struct was generated from the following file:
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/structjson__patch__error.html000066400000000000000000000125671446575330000244450ustar00rootroot00000000000000 json-c: json_patch_error Struct Reference
Data Fields
json_patch_error Struct Reference

Data Fields

int errno_code
 
size_t patch_failure_idx
 
const char * errmsg
 

Detailed Description

Details of an error that occurred during json_patch_apply()

Field Documentation

const char* json_patch_error::errmsg

A human readable error message. Allocated from static storage, does not need to be freed.

int json_patch_error::errno_code

An errno value indicating what kind of error occurred. Possible values include:

  • ENOENT - A path referenced in the operation does not exist.
  • EINVAL - An invalid operation or with invalid path was attempted
  • ENOMEM - Unable to allocate memory
  • EFAULT - Invalid arguments were passed to json_patch_apply() (i.e. a C API error, vs. a data error like EINVAL)
size_t json_patch_error::patch_failure_idx

The index into the patch array of the operation that failed, or SIZE_T_MAX for overall errors.

The documentation for this struct was generated from the following file:
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/structjson__pointer__get__result.html000066400000000000000000000133311446575330000261770ustar00rootroot00000000000000 json-c: json_pointer_get_result Struct Reference
Data Fields
json_pointer_get_result Struct Reference

Data Fields

struct json_object * parent
 
struct json_object * obj
 
const char * key_in_parent
 
uint32_t index_in_parent
 

Field Documentation

uint32_t json_pointer_get_result::index_in_parent
const char* json_pointer_get_result::key_in_parent
struct json_object* json_pointer_get_result::obj
struct json_object* json_pointer_get_result::parent
The documentation for this struct was generated from the following file:
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/structjson__tokener.html000066400000000000000000000304051446575330000234340ustar00rootroot00000000000000 json-c: json_tokener Struct Reference
Data Fields
json_tokener Struct Reference

Data Fields

char * str
 
struct printbuf * pb
 
int max_depth
 
int depth
 
int is_double
 
int st_pos
 
int char_offset
 
enum json_tokener_error err
 
unsigned int ucs_char
 
unsigned int high_surrogate
 
char quote_char
 
struct json_tokener_srec * stack
 
int flags
 

Detailed Description

Internal state of the json parser. Do not access any fields of this structure directly. Its definition is published due to historical limitations in the json tokener API, and will be changed to be an opaque type in the future.

Field Documentation

int json_tokener::char_offset
Deprecated:
See json_tokener_get_parse_end() instead.
int json_tokener::depth
enum json_tokener_error json_tokener::err
Deprecated:
See json_tokener_get_error() instead.
int json_tokener::flags
unsigned int json_tokener::high_surrogate
int json_tokener::is_double
int json_tokener::max_depth
struct printbuf* json_tokener::pb
char json_tokener::quote_char
int json_tokener::st_pos
struct json_tokener_srec* json_tokener::stack
char* json_tokener::str
Deprecated:
Do not access any of these fields outside of json_tokener.c
unsigned int json_tokener::ucs_char
The documentation for this struct was generated from the following file:
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/structjson__tokener__srec.html000066400000000000000000000137451446575330000246170ustar00rootroot00000000000000 json-c: json_tokener_srec Struct Reference
Data Fields
json_tokener_srec Struct Reference

Data Fields

enum json_tokener_state state saved_state
 
struct json_object * obj
 
struct json_object * current
 
char * obj_field_name
 

Detailed Description

Deprecated:
Don't use this outside of json_tokener.c, it will be made private in a future release.

Field Documentation

struct json_object* json_tokener_srec::current
struct json_object* json_tokener_srec::obj
char* json_tokener_srec::obj_field_name
enum json_tokener_state state json_tokener_srec::saved_state
The documentation for this struct was generated from the following file:
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/structlh__entry.html000066400000000000000000000201121446575330000225520ustar00rootroot00000000000000 json-c: lh_entry Struct Reference
Data Fields
lh_entry Struct Reference

Data Fields

const void * k
 
int k_is_constant
 
const void * v
 
struct lh_entry * next
 
struct lh_entry * prev
 

Detailed Description

An entry in the hash table. Outside of linkhash.c, treat this as opaque.

Field Documentation

const void* lh_entry::k

The key.

Deprecated:
Use lh_entry_k() instead of accessing this directly.

Referenced by lh_entry_k().

int lh_entry::k_is_constant

A flag for users of linkhash to know whether or not they need to free k.

Deprecated:
use lh_entry_k_is_constant() instead.

Referenced by lh_entry_k_is_constant().

struct lh_entry* lh_entry::next

The next entry.

Deprecated:
Use lh_entry_next() instead of accessing this directly.

Referenced by lh_entry_next().

struct lh_entry* lh_entry::prev

The previous entry.

Deprecated:
Use lh_entry_prev() instead of accessing this directly.

Referenced by lh_entry_prev().

const void* lh_entry::v

The value.

Deprecated:
Use lh_entry_v() instead of accessing this directly.

Referenced by lh_entry_set_val(), and lh_entry_v().

The documentation for this struct was generated from the following file:
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/structlh__table.html000066400000000000000000000245221446575330000225110ustar00rootroot00000000000000 json-c: lh_table Struct Reference
Data Fields
lh_table Struct Reference

Data Fields

int size
 
int count
 
struct lh_entry * head
 
struct lh_entry * tail
 
struct lh_entry * table
 
lh_entry_free_fn * free_fn
 
lh_hash_fn * hash_fn
 
lh_equal_fn * equal_fn
 

Detailed Description

The hash table structure. Outside of linkhash.c, treat this as opaque.

Field Documentation

int lh_table::count

Numbers of entries.

Deprecated:
Use lh_table_length() instead.
lh_equal_fn* lh_table::equal_fn
Deprecated:
do not use outside of linkhash.c
lh_entry_free_fn* lh_table::free_fn

A pointer to the function responsible for freeing an entry.

Deprecated:
do not use outside of linkhash.c
lh_hash_fn* lh_table::hash_fn
Deprecated:
do not use outside of linkhash.c

Referenced by lh_get_hash().

struct lh_entry* lh_table::head

The first entry.

Deprecated:
Use lh_table_head() instead.

Referenced by lh_table_head().

int lh_table::size

Size of our hash.

Deprecated:
do not use outside of linkhash.c
struct lh_entry* lh_table::table

Internal storage of the actual table of entries.

Deprecated:
do not use outside of linkhash.c
struct lh_entry* lh_table::tail

The last entry.

Deprecated:
Do not use, may be removed in a future release.
The documentation for this struct was generated from the following file:
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/structprintbuf.html000066400000000000000000000104721446575330000224300ustar00rootroot00000000000000 json-c: printbuf Struct Reference
Data Fields
printbuf Struct Reference

Data Fields

char * buf
 
int bpos
 
int size
 

Field Documentation

int printbuf::bpos
char* printbuf::buf
int printbuf::size
The documentation for this struct was generated from the following file:
Generated on Sat Aug 12 2023 18:59:55 for json-c by   doxygen 1.8.2
json-c-json-c-0.17-20230812/doc/html/sync_off.png000066400000000000000000000015251446575330000207570ustar00rootroot00000000000000PNG  IHDRw=IDATxKhTW1I&38MII3b$c I1V1-(T.* t!K[čf`l(l"Y6gT}sgܹ d{8?̝;u`:!FB?Űm'y>ѝlU_?]Y(N8f1qn-etm 0}b%׌=0?1s08;_ W|%\Zð >舽lnp.a{ )t; b n652?>Oдunm`׭ZWjC~>־0+ {{fMŕټ` ݛ%uA6,]kWu]7ihu1 l Ҷ̺:\cxhRQt$ fd<4B[fd7=.M9//O a},j?.5ښm?X2#d p(?c!a1ޗةܾ7dK:)3],H+ku<|`LhC7e םt H$^2%l.aeÉ|s }D^hz~Rá]|#@חև[k<|(*ݹdtM:,]' X_n| /cfOIENDB`json-c-json-c-0.17-20230812/doc/html/sync_on.png000066400000000000000000000015151446575330000206200ustar00rootroot00000000000000PNG  IHDRw=IDATx_HTY8i4-g6&kQ)!0URKڅ/PE>K-+K.YdEPaAZSܝ;3wgfsWK.Da'q_k DQCg 0Y:qZ)~L0HV z-C%g68%wUϿ }? ?3 K@h aaUe s~2&&B*Alji*˨,oƣT,d[3-*> LɟfkҠw#*AEjKUy>&{8m5Ki jjD*Nigw7DmzK۾M!k?o_lX#~XӑR*EՂדE;6e"Q(=Ezæ5Kؼָ_ 1zBJ X96jL^7{J1i@%8'7M_\Q#Uy Wo x8sv|Sn q_m >b[JX,4[T{Ratjjzz'ȶiIws KC^Y%6ꈺ]vhiWvh'̂|[^YrD=|sIENDB`json-c-json-c-0.17-20230812/doc/html/tab_s.png000066400000000000000000000002701446575330000202350ustar00rootroot00000000000000PNG  IHDR$[IDATx݁ @@ѣ?Q"%If6[HQ<]dr s?O=w'F -~rÍ[芭m֬ݯнF)Y% `n,9B!ь\<#IENDB`json-c-json-c-0.17-20230812/doc/html/tabs.css000066400000000000000000000022131446575330000201010ustar00rootroot00000000000000.tabs, .tabs2, .tabs3 { background-image: url('tab_b.png'); width: 100%; z-index: 101; font-size: 13px; font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif; } .tabs2 { font-size: 10px; } .tabs3 { font-size: 9px; } .tablist { margin: 0; padding: 0; display: table; } .tablist li { float: left; display: table-cell; background-image: url('tab_b.png'); line-height: 36px; list-style: none; } .tablist a { display: block; padding: 0 20px; font-weight: bold; background-image:url('tab_s.png'); background-repeat:no-repeat; background-position:right; color: #283A5D; text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); text-decoration: none; outline: none; } .tabs3 .tablist a { padding: 0 10px; } .tablist a:hover { background-image: url('tab_h.png'); background-repeat:repeat-x; color: #fff; text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0); text-decoration: none; } .tablist li.current a { background-image: url('tab_a.png'); background-repeat:repeat-x; color: #fff; text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0); } json-c-json-c-0.17-20230812/fuzz/000077500000000000000000000000001446575330000157255ustar00rootroot00000000000000json-c-json-c-0.17-20230812/fuzz/README.md000066400000000000000000000003421446575330000172030ustar00rootroot00000000000000# Fuzzers This directory contains fuzzers that target [llvm's LibFuzzer](https://llvm.org/docs/LibFuzzer.html). They are built and run automatically by Google's [OSS-Fuzz](https://github.com/google/oss-fuzz/) infrastructure. json-c-json-c-0.17-20230812/fuzz/build.sh000077500000000000000000000031211446575330000173600ustar00rootroot00000000000000#!/bin/bash -eu # Copyright 2018 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ################################################################################ # This should be run from the top of the json-c source tree. mkdir build cd build cmake -DBUILD_SHARED_LIBS=OFF .. make -j$(nproc) LIB=$(pwd)/libjson-c.a cd .. # These seem to be set externally, but let's assign defaults to # make it possible to at least partially test this standalone. : ${SRC:=$(dirname "$0")} : ${OUT:=$SRC/out} : ${CXX:=gcc} : ${CXXFLAGS:=} [ -d "$OUT" ] || mkdir "$OUT" cp $SRC/*.dict $OUT/. # XXX this doesn't seem to make much sense, since $SRC is presumably # the "fuzz" directory, which is _inside_ the json-c repo, rather than # the other way around, but I'm just preserving existing behavior. -erh INCS=$SRC/json-c # Compat when testing standalone [ -e "${INCS}" ] || ln -s .. "${INCS}" set -x set -v for f in $SRC/*_fuzzer.cc; do fuzzer=$(basename "$f" _fuzzer.cc) $CXX $CXXFLAGS -std=c++11 -I$INCS \ $SRC/${fuzzer}_fuzzer.cc -o $OUT/${fuzzer}_fuzzer \ -lFuzzingEngine $LIB done json-c-json-c-0.17-20230812/fuzz/tokener_parse_ex_fuzzer.cc000066400000000000000000000010501446575330000231720ustar00rootroot00000000000000#include #include extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { const char *data1 = reinterpret_cast(data); json_tokener *tok = json_tokener_new(); json_object *obj = json_tokener_parse_ex(tok, data1, size); json_object_object_foreach(jobj, key, val) { (void)json_object_get_type(val); (void)json_object_get_string(val); } (void)json_object_to_json_string(obj, JSON_C_TO_STRING_PRETTY | JSON_C_TO_STRING_SPACED); json_object_put(obj); json_tokener_free(tok); return 0; } json-c-json-c-0.17-20230812/fuzz/tokener_parse_ex_fuzzer.dict000066400000000000000000000001261446575330000235330ustar00rootroot00000000000000"{" "}" "," "[" "]" "," ":" "e" "e+" "e-" "E" "E+" "E-" "\"" "null" "1" "1.234" "3e4" json-c-json-c-0.17-20230812/issues_closed_for_0.13.md000066400000000000000000000661751446575330000214430ustar00rootroot00000000000000 This list was created with: ``` curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2014-04-10+created%3A<2017-12-01&sort=created&order=asc&per_page=400&page=1" > issues1.out curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2014-04-10+created%3A<2017-12-01&sort=created&order=asc&per_page=400&page=2" > issues2.out curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2014-04-10+created%3A<2017-12-01&sort=created&order=asc&per_page=400&page=3" > issues3.out jq -r '.items[] | "[" + .title + "](" + .url + ")" | tostring' issues?.out > issues.md sed -e's,^\[ *\(.*\)\](https://api.github.com/.*/\([0-9].*\)),[Issue #\2](https://github.com/json-c/json-c/issues/\2) - \1,' -i issues.md #... manual editing ... ``` ---- Issues and Pull Requests closed for the 0.13 release (since commit f84d9c, the 0.12 branch point, 2014-04-10) * [Issue #61](https://github.com/json-c/json-c/issues/61) - Make json_object_object_add() indicate success or failure, test fix \ * [Issue #113](https://github.com/json-c/json-c/issues/113) - Build fixes (make dist and make distcheck) \ * [Issue #124](https://github.com/json-c/json-c/issues/124) - Fixing build \ * [Issue #125](https://github.com/json-c/json-c/issues/125) - Fix compile error(variable size set but not used) on g++4.6 \ * [Issue #126](https://github.com/json-c/json-c/issues/126) - Removed unused size variable. \ * [Issue #127](https://github.com/json-c/json-c/issues/127) - remove unused `size` variable \ * [Issue #128](https://github.com/json-c/json-c/issues/128) - Remove unused variable from json_tokenizer.c \ * [Issue #130](https://github.com/json-c/json-c/issues/130) - Failed to compile under Ubuntu 13.10 32bit \ * [Issue #131](https://github.com/json-c/json-c/issues/131) - undefined symbol: __sync_val_compare_and_swap_4 \ * [Issue #132](https://github.com/json-c/json-c/issues/132) - Remove unused variable 'size' \ * [Issue #133](https://github.com/json-c/json-c/issues/133) - Update and rename README to README.md \ * [Issue #134](https://github.com/json-c/json-c/issues/134) - Must remove variable size... \ * [Issue #135](https://github.com/json-c/json-c/issues/135) - bits.h uses removed json_tokener_errors\[error\] \ * [Issue #136](https://github.com/json-c/json-c/issues/136) - Error when running make check \ * [Issue #137](https://github.com/json-c/json-c/issues/137) - config.h.in should not be in git \ * [Issue #138](https://github.com/json-c/json-c/issues/138) - Can't build on RHEL 6.5 due to dependency on automake-1.14 \ * [Issue #140](https://github.com/json-c/json-c/issues/140) - Code bug in random_test.c evaluating same expression twice \ * [Issue #141](https://github.com/json-c/json-c/issues/141) - Removed duplicate check in random_seed test - bug #140 \ * [Issue #142](https://github.com/json-c/json-c/issues/142) - Please undeprecate json_object_object_get \ * [Issue #144](https://github.com/json-c/json-c/issues/144) - Introduce json_object_from_fd \ * [Issue #145](https://github.com/json-c/json-c/issues/145) - Handle % character properly \ * [Issue #146](https://github.com/json-c/json-c/issues/146) - TAGS rename \ * [Issue #148](https://github.com/json-c/json-c/issues/148) - Bump the soname \ * [Issue #149](https://github.com/json-c/json-c/issues/149) - SONAME bump \ * [Issue #150](https://github.com/json-c/json-c/issues/150) - Fix build using MinGW. \ * [Issue #151](https://github.com/json-c/json-c/issues/151) - Remove json_type enum trailing comma \ * [Issue #152](https://github.com/json-c/json-c/issues/152) - error while compiling json-c library version 0.11 \ * [Issue #153](https://github.com/json-c/json-c/issues/153) - improve doc for json_object_to_json_string() \ * [Issue #154](https://github.com/json-c/json-c/issues/154) - double precision \ * [Issue #155](https://github.com/json-c/json-c/issues/155) - add bsearch for arrays \ * [Issue #156](https://github.com/json-c/json-c/issues/156) - Remove trailing whitespaces \ * [Issue #157](https://github.com/json-c/json-c/issues/157) - JSON-C shall not exit on calloc fail. \ * [Issue #158](https://github.com/json-c/json-c/issues/158) - while using json-c 0.11, I am facing strange crash issue in json_object_put. \ * [Issue #159](https://github.com/json-c/json-c/issues/159) - json_tokener.c compile error \ * [Issue #160](https://github.com/json-c/json-c/issues/160) - missing header file on windows?? \ * [Issue #161](https://github.com/json-c/json-c/issues/161) - Is there a way to append to file? \ * [Issue #162](https://github.com/json-c/json-c/issues/162) - json_util: add directory check for POSIX distros \ * [Issue #163](https://github.com/json-c/json-c/issues/163) - Fix Win32 build problems \ * [Issue #164](https://github.com/json-c/json-c/issues/164) - made it compile and link on Widnows (as static library) \ * [Issue #165](https://github.com/json-c/json-c/issues/165) - json_object_to_json_string_ext length \ * [Issue #167](https://github.com/json-c/json-c/issues/167) - Can't build on Windows with Visual Studio 2010 \ * [Issue #168](https://github.com/json-c/json-c/issues/168) - Tightening the number parsing algorithm \ * [Issue #169](https://github.com/json-c/json-c/issues/169) - Doesn't compile on ubuntu 14.04, 64bit \ * [Issue #170](https://github.com/json-c/json-c/issues/170) - Generated files in repository \ * [Issue #171](https://github.com/json-c/json-c/issues/171) - Update configuration for VS2010 and win64 \ * [Issue #172](https://github.com/json-c/json-c/issues/172) - Adding support for parsing octal numbers \ * [Issue #173](https://github.com/json-c/json-c/issues/173) - json_parse_int64 doesn't work correctly at illumos \ * [Issue #174](https://github.com/json-c/json-c/issues/174) - Adding JSON_C_TO_STRING_PRETTY_TAB flag \ * [Issue #175](https://github.com/json-c/json-c/issues/175) - make check fails 4 tests with overflows when built with ASAN \ * [Issue #176](https://github.com/json-c/json-c/issues/176) - Possible to delete an array element at a given idx ? \ * [Issue #177](https://github.com/json-c/json-c/issues/177) - Fix compiler warnings \ * [Issue #178](https://github.com/json-c/json-c/issues/178) - Unable to compile on CentOS5 \ * [Issue #179](https://github.com/json-c/json-c/issues/179) - Added array_list_del_idx and json_object_array_del_idx \ * [Issue #180](https://github.com/json-c/json-c/issues/180) - Enable silent build by default \ * [Issue #181](https://github.com/json-c/json-c/issues/181) - json_tokener_parse_ex accepts invalid JSON \ * [Issue #182](https://github.com/json-c/json-c/issues/182) - Link against libm when needed \ * [Issue #183](https://github.com/json-c/json-c/issues/183) - Apply compile warning fix to master branch \ * [Issue #184](https://github.com/json-c/json-c/issues/184) - Use only GCC-specific flags when compiling with GCC \ * [Issue #185](https://github.com/json-c/json-c/issues/185) - compile error \ * [Issue #186](https://github.com/json-c/json-c/issues/186) - Syntax error \ * [Issue #187](https://github.com/json-c/json-c/issues/187) - array_list_get_idx and negative indexes. \ * [Issue #188](https://github.com/json-c/json-c/issues/188) - json_object_object_foreach warnings \ * [Issue #189](https://github.com/json-c/json-c/issues/189) - noisy json_object_from_file: error opening file \ * [Issue #190](https://github.com/json-c/json-c/issues/190) - warning: initialization discards const qualifier from pointer target type \[enabled by default\] \ * [Issue #192](https://github.com/json-c/json-c/issues/192) - json_tokener_parse accepts invalid JSON {"key": "value" , } \ * [Issue #193](https://github.com/json-c/json-c/issues/193) - Make serialization format of doubles configurable \ * [Issue #194](https://github.com/json-c/json-c/issues/194) - Add utility function for comparing json_objects \ * [Issue #195](https://github.com/json-c/json-c/issues/195) - Call uselocale instead of setlocale \ * [Issue #196](https://github.com/json-c/json-c/issues/196) - Performance improvements \ * [Issue #197](https://github.com/json-c/json-c/issues/197) - Time for a new release? \ * [Issue #198](https://github.com/json-c/json-c/issues/198) - Fix possible memory leak and remove superfluous NULL checks before free() \ * [Issue #199](https://github.com/json-c/json-c/issues/199) - Fix build in Visual Studio \ * [Issue #200](https://github.com/json-c/json-c/issues/200) - Add build scripts for CI platforms \ * [Issue #201](https://github.com/json-c/json-c/issues/201) - disable forward-slash escaping? \ * [Issue #202](https://github.com/json-c/json-c/issues/202) - Array with objects support \ * [Issue #203](https://github.com/json-c/json-c/issues/203) - Add source position/coordinates to API \ * [Issue #204](https://github.com/json-c/json-c/issues/204) - json-c/json.h not found \ * [Issue #205](https://github.com/json-c/json-c/issues/205) - json-c Compiled with Visual Studios \ * [Issue #206](https://github.com/json-c/json-c/issues/206) - what do i use in place of json_object_object_get? \ * [Issue #207](https://github.com/json-c/json-c/issues/207) - Add support for property pairs directly added to arrays \ * [Issue #208](https://github.com/json-c/json-c/issues/208) - Performance enhancements (mainly) to json_object_to_json_string() \ * [Issue #209](https://github.com/json-c/json-c/issues/209) - fix regression from 2d549662be832da838aa063da2efa78ee3b99668 \ * [Issue #210](https://github.com/json-c/json-c/issues/210) - Use size_t for arrays \ * [Issue #211](https://github.com/json-c/json-c/issues/211) - Atomic updates for the refcount \ * [Issue #212](https://github.com/json-c/json-c/issues/212) - Refcount doesn't work between threads \ * [Issue #213](https://github.com/json-c/json-c/issues/213) - fix to compile with microsoft visual c++ 2010 \ * [Issue #214](https://github.com/json-c/json-c/issues/214) - Some non-GNU systems support __sync_val_compare_and_swap \ * [Issue #215](https://github.com/json-c/json-c/issues/215) - Build json-c for window 64 bit. \ * [Issue #216](https://github.com/json-c/json-c/issues/216) - configure: check realloc with AC_CHECK_FUNCS() to fix cross-compilation. \ * [Issue #217](https://github.com/json-c/json-c/issues/217) - Checking for functions in float.h \ * [Issue #218](https://github.com/json-c/json-c/issues/218) - Use a macro to indicate C99 to the compiler \ * [Issue #219](https://github.com/json-c/json-c/issues/219) - Fix various potential null ptr deref and int32 overflows \ * [Issue #220](https://github.com/json-c/json-c/issues/220) - Add utility function for comparing json_objects \ * [Issue #221](https://github.com/json-c/json-c/issues/221) - JSON_C_TO_STRING_NOSLASHESCAPE works incorrectly \ * [Issue #222](https://github.com/json-c/json-c/issues/222) - Fix issue #221: JSON_C_TO_STRING_NOSLASHESCAPE works incorrectly \ * [Issue #223](https://github.com/json-c/json-c/issues/223) - Clarify json_object_get_string documentation of NULL handling & return \ * [Issue #224](https://github.com/json-c/json-c/issues/224) - json_tokener.c - all warnings being treated as errors \ * [Issue #225](https://github.com/json-c/json-c/issues/225) - Hi, will you support clib as a "registry"? \ * [Issue #227](https://github.com/json-c/json-c/issues/227) - Bump SOVERSION to 3 \ * [Issue #228](https://github.com/json-c/json-c/issues/228) - avoid double slashes from json \ * [Issue #229](https://github.com/json-c/json-c/issues/229) - configure fails: checking size of size_t... configure: error: cannot determine a size for size_t \ * [Issue #230](https://github.com/json-c/json-c/issues/230) - Use stdint.h to check for size_t size \ * [Issue #231](https://github.com/json-c/json-c/issues/231) - Fix size_t size check for first-time builds \ * [Issue #232](https://github.com/json-c/json-c/issues/232) - tests/tests1: fix printf format for size_t arguments \ * [Issue #233](https://github.com/json-c/json-c/issues/233) - Include stddef.h in json_object.h \ * [Issue #234](https://github.com/json-c/json-c/issues/234) - Add public API to use userdata independently of custom serializer \ * [Issue #235](https://github.com/json-c/json-c/issues/235) - Undefined symbols Error for architecture x86_64 on Mac \ * [Issue #236](https://github.com/json-c/json-c/issues/236) - Building a project which uses json-c with flag -Wcast-qual causes compilation errors \ * [Issue #237](https://github.com/json-c/json-c/issues/237) - handle escaped utf-8 \ * [Issue #238](https://github.com/json-c/json-c/issues/238) - linkhash.c: optimised the table_free path \ * [Issue #239](https://github.com/json-c/json-c/issues/239) - initialize null terminator of new printbuf \ * [Issue #240](https://github.com/json-c/json-c/issues/240) - Compile error: Variable set but not used \ * [Issue #241](https://github.com/json-c/json-c/issues/241) - getting error in date string 19\/07\/2016, fixed for error 19/07/2016 \ * [Issue #242](https://github.com/json-c/json-c/issues/242) - json_tokener_parse error \ * [Issue #243](https://github.com/json-c/json-c/issues/243) - Fix #165 \ * [Issue #244](https://github.com/json-c/json-c/issues/244) - Error while compiling source from RHEL5, could you please help me to fix this \ * [Issue #245](https://github.com/json-c/json-c/issues/245) - json-c compile in window xp \ * [Issue #246](https://github.com/json-c/json-c/issues/246) - Mac: uselocale failed to build \ * [Issue #247](https://github.com/json-c/json-c/issues/247) - json_object_array_del_idx function has segment fault error? \ * [Issue #248](https://github.com/json-c/json-c/issues/248) - Minor changes in C source code \ * [Issue #249](https://github.com/json-c/json-c/issues/249) - Improving README \ * [Issue #250](https://github.com/json-c/json-c/issues/250) - Improving .gitignore \ * [Issue #251](https://github.com/json-c/json-c/issues/251) - Adding a file for EditorConfig \ * [Issue #252](https://github.com/json-c/json-c/issues/252) - Very minor changes not related to C source code \ * [Issue #253](https://github.com/json-c/json-c/issues/253) - Adding a test with cppcheck for Travis CI \ * [Issue #254](https://github.com/json-c/json-c/issues/254) - Very minor changes to some tests \ * [Issue #255](https://github.com/json-c/json-c/issues/255) - Minor changes in C source code \ * [Issue #256](https://github.com/json-c/json-c/issues/256) - Mailing list dead? \ * [Issue #257](https://github.com/json-c/json-c/issues/257) - Defining a coding style \ * [Issue #258](https://github.com/json-c/json-c/issues/258) - Enable CI services \ * [Issue #259](https://github.com/json-c/json-c/issues/259) - Fails to parse valid json \ * [Issue #260](https://github.com/json-c/json-c/issues/260) - Adding an object to itself \ * [Issue #261](https://github.com/json-c/json-c/issues/261) - Lack of proper documentation \ * [Issue #262](https://github.com/json-c/json-c/issues/262) - Add Cmakefile and fix compiler warning. \ * [Issue #263](https://github.com/json-c/json-c/issues/263) - Compiler Warnings with VS2015 \ * [Issue #264](https://github.com/json-c/json-c/issues/264) - successed in simple test while failed in my project \ * [Issue #265](https://github.com/json-c/json-c/issues/265) - Conformance report for reference \ * [Issue #266](https://github.com/json-c/json-c/issues/266) - crash perhaps related to reference counting \ * [Issue #267](https://github.com/json-c/json-c/issues/267) - Removes me as Win32 maintainer, because I'm not. \ * [Issue #268](https://github.com/json-c/json-c/issues/268) - Documentation of json_object_to_json_string gives no information about memory management \ * [Issue #269](https://github.com/json-c/json-c/issues/269) - json_object__set(json_object *o, value) API for value setting in json object private structure \ * [Issue #270](https://github.com/json-c/json-c/issues/270) - new API json_object_new_double_f(doubel d,const char * fmt); \ * [Issue #271](https://github.com/json-c/json-c/issues/271) - Cannot compile using CMake on macOS \ * [Issue #273](https://github.com/json-c/json-c/issues/273) - fixed wrong object name in json_object_all_values_equal \ * [Issue #274](https://github.com/json-c/json-c/issues/274) - Support for 64 bit pointers on Windows \ * [Issue #275](https://github.com/json-c/json-c/issues/275) - Out-of-bounds read in json_tokener_parse_ex \ * [Issue #276](https://github.com/json-c/json-c/issues/276) - ./configure for centos release 6.7(final) failure \ * [Issue #277](https://github.com/json-c/json-c/issues/277) - Json object set xxx \ * [Issue #278](https://github.com/json-c/json-c/issues/278) - Serialization of double with no fractional component drops trailing zero \ * [Issue #279](https://github.com/json-c/json-c/issues/279) - Segmentation fault in array_list_length() \ * [Issue #280](https://github.com/json-c/json-c/issues/280) - Should json_object_array_get_idx check whether input obj is array? \ * [Issue #281](https://github.com/json-c/json-c/issues/281) - how to pretty print json-c? \ * [Issue #282](https://github.com/json-c/json-c/issues/282) - ignore temporary files \ * [Issue #283](https://github.com/json-c/json-c/issues/283) - json_pointer: add first revision based on RFC 6901 \ * [Issue #284](https://github.com/json-c/json-c/issues/284) - Resusing json_tokener object \ * [Issue #285](https://github.com/json-c/json-c/issues/285) - Revert "compat/strdup.h: move common compat check for strdup() to own \ * [Issue #286](https://github.com/json-c/json-c/issues/286) - json_tokener_parse_ex() returns json_tokener_continue on zero-length string \ * [Issue #287](https://github.com/json-c/json-c/issues/287) - json_pointer: extend setter & getter with printf() style arguments \ * [Issue #288](https://github.com/json-c/json-c/issues/288) - Fix _GNU_SOURCE define for vasprintf \ * [Issue #289](https://github.com/json-c/json-c/issues/289) - bugfix: floating point representaion without fractional part \ * [Issue #290](https://github.com/json-c/json-c/issues/290) - duplicate an json_object \ * [Issue #291](https://github.com/json-c/json-c/issues/291) - isspace assert error \ * [Issue #292](https://github.com/json-c/json-c/issues/292) - configure error "./configure: line 13121: syntax error near unexpected token `-Wall'" \ * [Issue #293](https://github.com/json-c/json-c/issues/293) - how to make with bitcode for ios \ * [Issue #294](https://github.com/json-c/json-c/issues/294) - Adding UTF-8 validation. Fixes #122 \ * [Issue #295](https://github.com/json-c/json-c/issues/295) - cross compile w/ mingw \ * [Issue #296](https://github.com/json-c/json-c/issues/296) - Missing functions header in json_object.h \ * [Issue #297](https://github.com/json-c/json-c/issues/297) - could not parse string to Json object? Like string str=\"helloworld;E\\test\\log\\;end\" \ * [Issue #298](https://github.com/json-c/json-c/issues/298) - Building using CMake doesn't work \ * [Issue #299](https://github.com/json-c/json-c/issues/299) - Improve json_object -> string performance \ * [Issue #300](https://github.com/json-c/json-c/issues/300) - Running tests with MinGW build \ * [Issue #301](https://github.com/json-c/json-c/issues/301) - How to deep copy json_object in C++ ? \ * [Issue #302](https://github.com/json-c/json-c/issues/302) - json_tokener_parse_ex doesn't parse JSON values \ * [Issue #303](https://github.com/json-c/json-c/issues/303) - fix doc in tokener header file \ * [Issue #304](https://github.com/json-c/json-c/issues/304) - (.text+0x72846): undefined reference to `is_error' \ * [Issue #305](https://github.com/json-c/json-c/issues/305) - Fix compilation without C-99 option \ * [Issue #306](https://github.com/json-c/json-c/issues/306) - ./configure: line 12748 -error=deprecated-declarations \ * [Issue #307](https://github.com/json-c/json-c/issues/307) - Memory leak in json_tokener_parse \ * [Issue #308](https://github.com/json-c/json-c/issues/308) - AM_PROG_LIBTOOL not found on Linux \ * [Issue #309](https://github.com/json-c/json-c/issues/309) - GCC 7 reports various -Wimplicit-fallthrough= errors \ * [Issue #310](https://github.com/json-c/json-c/issues/310) - Add FALLTHRU comment to handle GCC7 warnings. \ * [Issue #311](https://github.com/json-c/json-c/issues/311) - Fix error C3688 when compiling on Visual Studio 2015 \ * [Issue #312](https://github.com/json-c/json-c/issues/312) - Fix CMake Build process improved for MinGW and MSYS2 \ * [Issue #313](https://github.com/json-c/json-c/issues/313) - VERBOSE=1 make check; tests/test_util_file.test.c and tests/test_util_file.expected out of sync \ * [Issue #315](https://github.com/json-c/json-c/issues/315) - Passing -1 to json_tokener_parse_ex is possibly unsafe \ * [Issue #316](https://github.com/json-c/json-c/issues/316) - Memory Returned by json_object_to_json_string not freed \ * [Issue #317](https://github.com/json-c/json-c/issues/317) - json_object_get_string gives segmentation error \ * [Issue #318](https://github.com/json-c/json-c/issues/318) - PVS-Studio static analyzer analyze results \ * [Issue #319](https://github.com/json-c/json-c/issues/319) - Windows: Fix dynamic library build with Visual Studio \ * [Issue #320](https://github.com/json-c/json-c/issues/320) - Can't compile in Mac OS X El Capitan \ * [Issue #321](https://github.com/json-c/json-c/issues/321) - build,cmake: fix vasprintf implicit definition and generate both static & shared libs \ * [Issue #322](https://github.com/json-c/json-c/issues/322) - can not link with libjson-c.a \ * [Issue #323](https://github.com/json-c/json-c/issues/323) - implicit fallthrough detected by gcc 7.1 \ * [Issue #324](https://github.com/json-c/json-c/issues/324) - JsonPath like function? \ * [Issue #325](https://github.com/json-c/json-c/issues/325) - Fix stack buffer overflow in json_object_double_to_json_string_format() \ * [Issue #327](https://github.com/json-c/json-c/issues/327) - why json-c so hard to compile \ * [Issue #328](https://github.com/json-c/json-c/issues/328) - json_object: implement json_object_deep_copy() function \ * [Issue #329](https://github.com/json-c/json-c/issues/329) - build,cmake: build,cmake: rename libjson-c-static.a to libjson-c.a \ * [Issue #330](https://github.com/json-c/json-c/issues/330) - tests: symlink basic tests to a single file that has the common code \ * [Issue #331](https://github.com/json-c/json-c/issues/331) - Safe use of snprintf() / vsnprintf() for Visual studio, and thread-safety fix \ * [Issue #332](https://github.com/json-c/json-c/issues/332) - Valgrind: invalid read after json_object_array_del_idx. \ * [Issue #333](https://github.com/json-c/json-c/issues/333) - Replace obsolete AM_PROG_LIBTOOL \ * [Issue #335](https://github.com/json-c/json-c/issues/335) - README.md: show build status tag from travis-ci.org \ * [Issue #336](https://github.com/json-c/json-c/issues/336) - tests: fix tests in travis-ci.org \ * [Issue #337](https://github.com/json-c/json-c/issues/337) - Synchronize "potentially racy" random seed in lh_char_hash() \ * [Issue #338](https://github.com/json-c/json-c/issues/338) - implement json_object_int_inc(json_object *, int64_t) \ * [Issue #339](https://github.com/json-c/json-c/issues/339) - Json schema validation \ * [Issue #340](https://github.com/json-c/json-c/issues/340) - strerror_override: add extern "C" and JSON_EXPORT specifiers for Visual C++ compilers \ * [Issue #341](https://github.com/json-c/json-c/issues/341) - character "/" parse as "\/" \ * [Issue #342](https://github.com/json-c/json-c/issues/342) - No such file or directory "/usr/include/json.h" \ * [Issue #343](https://github.com/json-c/json-c/issues/343) - Can't parse json \ * [Issue #344](https://github.com/json-c/json-c/issues/344) - Fix Mingw build \ * [Issue #345](https://github.com/json-c/json-c/issues/345) - Fix make dist and make distcheck \ * [Issue #346](https://github.com/json-c/json-c/issues/346) - Clamp double to int32 when narrowing in json_object_get_int. \ * [Issue #347](https://github.com/json-c/json-c/issues/347) - MSVC linker error json_c_strerror \ * [Issue #348](https://github.com/json-c/json-c/issues/348) - why \ * [Issue #349](https://github.com/json-c/json-c/issues/349) - `missing` is missing? \ * [Issue #350](https://github.com/json-c/json-c/issues/350) - stderror-override and disable-shared \ * [Issue #351](https://github.com/json-c/json-c/issues/351) - SIZE_T_MAX redefined from limits.h \ * [Issue #352](https://github.com/json-c/json-c/issues/352) - `INSTALL` overrides an automake script. \ * [Issue #353](https://github.com/json-c/json-c/issues/353) - Documentation issues \ * [Issue #354](https://github.com/json-c/json-c/issues/354) - Fixes #351 #352 #353 \ * [Issue #355](https://github.com/json-c/json-c/issues/355) - 1.make it can been compiled with Visual Studio 2010 by modify the CMakeList.txt and others \ * [Issue #356](https://github.com/json-c/json-c/issues/356) - VS2008 test test_util_file.cpp err! \ * [Issue #357](https://github.com/json-c/json-c/issues/357) - __json_c_strerror incompatibility with link-time optimization \ * [Issue #358](https://github.com/json-c/json-c/issues/358) - make issue \ * [Issue #359](https://github.com/json-c/json-c/issues/359) - update CMakeLists.txt for compile with visual studio at least 2010 \ * [Issue #360](https://github.com/json-c/json-c/issues/360) - Use strtoll() to parse ints \ * [Issue #361](https://github.com/json-c/json-c/issues/361) - Fix double to int cast overflow in json_object_get_int64. \ * [Issue #362](https://github.com/json-c/json-c/issues/362) - CMake Package Config \ * [Issue #363](https://github.com/json-c/json-c/issues/363) - Issue #338, add json_object_add_int functions \ * [Issue #364](https://github.com/json-c/json-c/issues/364) - Cmake is Errir \ * [Issue #365](https://github.com/json-c/json-c/issues/365) - added fallthrough for gcc7 \ * [Issue #366](https://github.com/json-c/json-c/issues/366) - how to check the json string,crash! \ * [Issue #367](https://github.com/json-c/json-c/issues/367) - Is json-c support "redirect" semantic? \ * [Issue #368](https://github.com/json-c/json-c/issues/368) - Add examples \ * [Issue #369](https://github.com/json-c/json-c/issues/369) - How to build json-c library for android? \ * [Issue #370](https://github.com/json-c/json-c/issues/370) - Compiling using clang-cl \ * [Issue #371](https://github.com/json-c/json-c/issues/371) - Invalid parsing for Infinity with json-c 0.12 \ * [Issue #372](https://github.com/json-c/json-c/issues/372) - Json-c 0.12: Fixed Infinity bug \ * [Issue #373](https://github.com/json-c/json-c/issues/373) - build: fix build on appveyor CI \ * [Issue #374](https://github.com/json-c/json-c/issues/374) - Undefined symbols for architecture x86_64: \ * [Issue #375](https://github.com/json-c/json-c/issues/375) - what would happened when json_object_object_add add the same key \ * [Issue #376](https://github.com/json-c/json-c/issues/376) - Eclipse error \ * [Issue #377](https://github.com/json-c/json-c/issues/377) - on gcc 7.2.0 on my linux distribution with json-c 2013-04-02 source \ * [Issue #378](https://github.com/json-c/json-c/issues/378) - Eclipse: library (libjson-c) not found, but configured \ * [Issue #379](https://github.com/json-c/json-c/issues/379) - error: this statement may fall through \[-Werror=implicit-fallthrough=\] \ * [Issue #380](https://github.com/json-c/json-c/issues/380) - Build on Windows \ * [Issue #381](https://github.com/json-c/json-c/issues/381) - Fix makedist \ * [Issue #382](https://github.com/json-c/json-c/issues/382) - Memory leak for json_tokener_parse_ex for version 0.12.1 \ * [Issue #383](https://github.com/json-c/json-c/issues/383) - Fix a compiler warning. \ * [Issue #384](https://github.com/json-c/json-c/issues/384) - Fix a VS 2015 compiler warnings. \ json-c-json-c-0.17-20230812/issues_closed_for_0.14.md000066400000000000000000000476741446575330000214470ustar00rootroot00000000000000This list was created with: ``` curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2017-12-07+created%3A<2020-04-17&sort=created&order=asc&per_page=400&page=1" > issues1.out curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2017-12-07+created%3A<2020-04-17&sort=created&order=asc&per_page=400&page=2" > issues2.out curl https://api.github.com/search/issues?q="repo%3Ajson-c%2Fjson-c+closed%3A>2017-12-07+created%3A<2020-04-17&sort=created&order=asc&per_page=400&page=3" > issues3.out jq -r '.items[] | "[" + .title + "](" + .url + ")" | tostring' issues?.out > issues.md sed -e's,^\[ *\(.*\)\](https://api.github.com/.*/\([0-9].*\)),[Issue #\2](https://github.com/json-c/json-c/issues/\2) - \1,' -i issues.md #... manual editing ... ``` ---- Issues and Pull Requests closed for the 0.14 release (since commit d582d3a(2017-12-07) to a911439(2020-04-17)) * [Issue #122](https://github.com/json-c/json-c/issues/122) - Add utf-8 validation when parsing strings. \ * [Issue #139](https://github.com/json-c/json-c/issues/139) - json_object_from_file cannot accept max_depth \ * [Issue #143](https://github.com/json-c/json-c/issues/143) - RFE / enhancement for full 64-bit signed/unsigned support \ * [Issue #147](https://github.com/json-c/json-c/issues/147) - Please introduce soname bump if API changed \ * [Issue #166](https://github.com/json-c/json-c/issues/166) - Need a way to specify nesting depth when opening JSON file \ * [Issue #226](https://github.com/json-c/json-c/issues/226) - There is no json_object_new_null() \ * [Issue #314](https://github.com/json-c/json-c/issues/314) - new release ? \ * [Issue #326](https://github.com/json-c/json-c/issues/326) - Please extend api json_object_get_uint64 \ * [Issue #334](https://github.com/json-c/json-c/issues/334) - Switch json-c builds to use CMake \ * [Issue #386](https://github.com/json-c/json-c/issues/386) - Makefile: Add ACLOCAL_AMFLAGS \ * [Issue #387](https://github.com/json-c/json-c/issues/387) - doc: Use other doxygen feature to specify mainpage \ * [Issue #388](https://github.com/json-c/json-c/issues/388) - json_object: Add size_t json_object_sizeof() \ * [Issue #389](https://github.com/json-c/json-c/issues/389) - json_object: Avoid double free (and thus a segfault) when ref_count gets < 0 \ * [Issue #390](https://github.com/json-c/json-c/issues/390) - json_object: Add const size_t json_c_object_sizeof() \ * [Issue #391](https://github.com/json-c/json-c/issues/391) - Fix non-GNUC define for JSON_C_CONST_FUNCTION \ * [Issue #392](https://github.com/json-c/json-c/issues/392) - json_object: Avoid invalid free (and thus a segfault) when ref_count gets < 0 \ * [Issue #393](https://github.com/json-c/json-c/issues/393) - json_object_private: Use unsigned 32-bit integer type for refcount \ * [Issue #394](https://github.com/json-c/json-c/issues/394) - Problem serializing double \ * [Issue #395](https://github.com/json-c/json-c/issues/395) - Key gets modified if it contains "\" \ * [Issue #396](https://github.com/json-c/json-c/issues/396) - Build failure with no threads uClibc toolchain \ * [Issue #397](https://github.com/json-c/json-c/issues/397) - update json object with key. \ * [Issue #398](https://github.com/json-c/json-c/issues/398) - Build failed. \ * [Issue #399](https://github.com/json-c/json-c/issues/399) - Avoid uninitialized variable warnings \ * [Issue #400](https://github.com/json-c/json-c/issues/400) - How to generate static lib (.a) \ * [Issue #401](https://github.com/json-c/json-c/issues/401) - Warnings with Valgrind \ * [Issue #402](https://github.com/json-c/json-c/issues/402) - Add fuzzers from OSS-Fuzz \ * [Issue #403](https://github.com/json-c/json-c/issues/403) - Segmentation fault when double quotes is used \ * [Issue #404](https://github.com/json-c/json-c/issues/404) - valgrind: memory leak \ * [Issue #405](https://github.com/json-c/json-c/issues/405) - Missing API to determine an object is empty \ * [Issue #406](https://github.com/json-c/json-c/issues/406) - Undefine NDEBUG for tests \ * [Issue #407](https://github.com/json-c/json-c/issues/407) - json_tokener_parse is crash \ * [Issue #408](https://github.com/json-c/json-c/issues/408) - bug in array_list_del_idx when array_list_length()==1 \ * [Issue #410](https://github.com/json-c/json-c/issues/410) - Fixed typos \ * [Issue #411](https://github.com/json-c/json-c/issues/411) - Crash- signal SIGSEGV, Segmentation fault. ../sysdeps/x86_64/strlen.S: No such file or directory. \ * [Issue #412](https://github.com/json-c/json-c/issues/412) - json_type changes during inter process communication. \ * [Issue #413](https://github.com/json-c/json-c/issues/413) - how to read object of type `json_object *` in c++ \ * [Issue #414](https://github.com/json-c/json-c/issues/414) - [Question] How JSON-c stores the serialized data in memory? \ * [Issue #415](https://github.com/json-c/json-c/issues/415) - Resolve windows name conflict \ * [Issue #416](https://github.com/json-c/json-c/issues/416) - segmentation fault in json_tokener_parse \ * [Issue #417](https://github.com/json-c/json-c/issues/417) - json_tokener_parse json_object_object_get_ex with string value which is json string \ * [Issue #418](https://github.com/json-c/json-c/issues/418) - json_object_from_* return value documented incorrectly \ * [Issue #419](https://github.com/json-c/json-c/issues/419) - Suggestion: document (and define) that json_object_put() accepts NULL pointer to object \ * [Issue #420](https://github.com/json-c/json-c/issues/420) - arraylist: Fixed names of parameters for callback function \ * [Issue #421](https://github.com/json-c/json-c/issues/421) - install json_object_iterator.h header file \ * [Issue #422](https://github.com/json-c/json-c/issues/422) - json_object_get_double() does not set errno when there is no valid conversion \ * [Issue #423](https://github.com/json-c/json-c/issues/423) - memory leak \ * [Issue #424](https://github.com/json-c/json-c/issues/424) - Parse string contains "\" or "/" errors \ * [Issue #425](https://github.com/json-c/json-c/issues/425) - what this is? \ * [Issue #426](https://github.com/json-c/json-c/issues/426) - __deprecated not supported on clang. \ * [Issue #427](https://github.com/json-c/json-c/issues/427) - CMake: builds involving this target will not be correct \ * [Issue #430](https://github.com/json-c/json-c/issues/430) - json_object_object_del() and Segmentation fault \ * [Issue #431](https://github.com/json-c/json-c/issues/431) - cmake: Bump required version \ * [Issue #432](https://github.com/json-c/json-c/issues/432) - The real CMake support. \ * [Issue #433](https://github.com/json-c/json-c/issues/433) - The real CMake support. \ * [Issue #434](https://github.com/json-c/json-c/issues/434) - The real CMake support \ * [Issue #435](https://github.com/json-c/json-c/issues/435) - json_object_object_del() segmentation fault \ * [Issue #436](https://github.com/json-c/json-c/issues/436) - Improve pkgconfig setting \ * [Issue #437](https://github.com/json-c/json-c/issues/437) - Bad link in README.md \ * [Issue #438](https://github.com/json-c/json-c/issues/438) - Bad link in README.html \ * [Issue #439](https://github.com/json-c/json-c/issues/439) - reserved identifier violation \ * [Issue #440](https://github.com/json-c/json-c/issues/440) - Use of angle brackets around file names for include statements \ * [Issue #441](https://github.com/json-c/json-c/issues/441) - fix c flag loss during cmake building \ * [Issue #442](https://github.com/json-c/json-c/issues/442) - error in configure file \ * [Issue #443](https://github.com/json-c/json-c/issues/443) - remove pretty spaces when using pretty tabs \ * [Issue #444](https://github.com/json-c/json-c/issues/444) - Document refcount of json_tokener_parse_ex return \ * [Issue #445](https://github.com/json-c/json-c/issues/445) - Add missing "make check" target to cmake config \ * [Issue #446](https://github.com/json-c/json-c/issues/446) - Forward slashes get escaped \ * [Issue #448](https://github.com/json-c/json-c/issues/448) - Buffer overflow in json-c \ * [Issue #449](https://github.com/json-c/json-c/issues/449) - Need of json_type_int64 returned by json_object_get_type() \ * [Issue #450](https://github.com/json-c/json-c/issues/450) - Allow use json-c cmake as subproject \ * [Issue #452](https://github.com/json-c/json-c/issues/452) - Update README.md \ * [Issue #453](https://github.com/json-c/json-c/issues/453) - Fixed misalignment in JSON string due to space after \n being printed... \ * [Issue #454](https://github.com/json-c/json-c/issues/454) - json_object_private: save 8 bytes in struct json_object in 64-bit arc… \ * [Issue #455](https://github.com/json-c/json-c/issues/455) - index.html:fix dead link \ * [Issue #456](https://github.com/json-c/json-c/issues/456) - STYLE.txt:remove executable permissions \ * [Issue #457](https://github.com/json-c/json-c/issues/457) - .gitignore:add build directory \ * [Issue #458](https://github.com/json-c/json-c/issues/458) - README.md:fix dead "file.html" link \ * [Issue #459](https://github.com/json-c/json-c/issues/459) - README.html:fix link to Doxygen docs, remove WIN32 link \ * [Issue #460](https://github.com/json-c/json-c/issues/460) - No docs for json_object_new_string_len() \ * [Issue #461](https://github.com/json-c/json-c/issues/461) - json_object.c:set errno in json_object_get_double() \ * [Issue #462](https://github.com/json-c/json-c/issues/462) - json_object.h:document json_object_new_string_len() \ * [Issue #463](https://github.com/json-c/json-c/issues/463) - please check newlocale api first argument valuse. \ * [Issue #465](https://github.com/json-c/json-c/issues/465) - CMakeLists.txt doesn't contain json_object_iterator.h which json.h includes \ * [Issue #466](https://github.com/json-c/json-c/issues/466) - configure:3610: error: C compiler cannot create executables \ * [Issue #467](https://github.com/json-c/json-c/issues/467) - Fix compiler warnings \ * [Issue #468](https://github.com/json-c/json-c/issues/468) - Fix compiler warnings \ * [Issue #469](https://github.com/json-c/json-c/issues/469) - Build under alpine with pecl install & docker-php-ext-enable? \ * [Issue #470](https://github.com/json-c/json-c/issues/470) - cfuhash_foreach_remove doesn't upate cfuhash_num_entries \ * [Issue #472](https://github.com/json-c/json-c/issues/472) - Segmentation fault in json_object_iter_begin \ * [Issue #473](https://github.com/json-c/json-c/issues/473) - Convert ChangeLog to valid UTF-8 encoding. \ * [Issue #474](https://github.com/json-c/json-c/issues/474) - Installation directories empty with CMake in pkg-config. \ * [Issue #475](https://github.com/json-c/json-c/issues/475) - improvement proposal for json_object_object_foreach \ * [Issue #477](https://github.com/json-c/json-c/issues/477) - Hang/Crash with large strings \ * [Issue #478](https://github.com/json-c/json-c/issues/478) - json_object_get_string_len returns 0 when value is number \ * [Issue #479](https://github.com/json-c/json-c/issues/479) - I want to use it in iOS or Android but I can't compile \ * [Issue #480](https://github.com/json-c/json-c/issues/480) - json-c-0.12.1 failed making from source code \ * [Issue #481](https://github.com/json-c/json-c/issues/481) - error while loading shared libraries: libjson-c.so.4 \ * [Issue #482](https://github.com/json-c/json-c/issues/482) - Error "double free or corruption" after free() \ * [Issue #483](https://github.com/json-c/json-c/issues/483) - compatible with rarely-used Chinese characters in GBK charset \ * [Issue #485](https://github.com/json-c/json-c/issues/485) - Install CMake module files \ * [Issue #486](https://github.com/json-c/json-c/issues/486) - In the case of negative double value, it is formatted without including ".0" \ * [Issue #488](https://github.com/json-c/json-c/issues/488) - Some APIs are not exported when built as shared lib on Win32 \ * [Issue #489](https://github.com/json-c/json-c/issues/489) - Don't use -Werror by default \ * [Issue #490](https://github.com/json-c/json-c/issues/490) - do not compile with -Werror by default \ * [Issue #491](https://github.com/json-c/json-c/issues/491) - build: add option --disable-werror to configure \ * [Issue #492](https://github.com/json-c/json-c/issues/492) - lack some quick usage in readme \ * [Issue #494](https://github.com/json-c/json-c/issues/494) - Code generator? \ * [Issue #495](https://github.com/json-c/json-c/issues/495) - README.md:fix 2 typos \ * [Issue #496](https://github.com/json-c/json-c/issues/496) - json_pointer.h:suggest minor grammar improvement for pointer doc \ * [Issue #497](https://github.com/json-c/json-c/issues/497) - add common header for all tests \ * [Issue #498](https://github.com/json-c/json-c/issues/498) - double_serializer_test fails (with valgrind) \ * [Issue #499](https://github.com/json-c/json-c/issues/499) - .travis.yml:test on more recent clang and gcc versions \ * [Issue #500](https://github.com/json-c/json-c/issues/500) - test/Makefile.am:add missing deps for test1 and test2 \ * [Issue #501](https://github.com/json-c/json-c/issues/501) - undefine NDEBUG for tests \ * [Issue #502](https://github.com/json-c/json-c/issues/502) - configure error \ * [Issue #503](https://github.com/json-c/json-c/issues/503) - json-c retuns OK when Invalid json string is passed \ * [Issue #504](https://github.com/json-c/json-c/issues/504) - json_object_put coredump \ * [Issue #505](https://github.com/json-c/json-c/issues/505) - Add vcpkg installation instructions \ * [Issue #506](https://github.com/json-c/json-c/issues/506) - Cannot parse more than one object \ * [Issue #509](https://github.com/json-c/json-c/issues/509) - Sometimes a double value is not serialized \ * [Issue #510](https://github.com/json-c/json-c/issues/510) - Bump so-name and improve CMake \ * [Issue #511](https://github.com/json-c/json-c/issues/511) - Reduce lines for better optimization \ * [Issue #512](https://github.com/json-c/json-c/issues/512) - Properly append to CMAKE_C_FLAGS string \ * [Issue #513](https://github.com/json-c/json-c/issues/513) - What does `userdata` means?And what is the case we can use it? \ * [Issue #514](https://github.com/json-c/json-c/issues/514) - Json c 0.13 \ * [Issue #515](https://github.com/json-c/json-c/issues/515) - Mies suomesta fixes segfaults and logic errors \ * [Issue #516](https://github.com/json-c/json-c/issues/516) - Lja slight mods \ * [Issue #518](https://github.com/json-c/json-c/issues/518) - Escape character "\\003\", get unexpected value \ * [Issue #519](https://github.com/json-c/json-c/issues/519) - Add test case obj token \ * [Issue #520](https://github.com/json-c/json-c/issues/520) - Adding type uint64 \ * [Issue #521](https://github.com/json-c/json-c/issues/521) - build cmake windows 10 \ * [Issue #522](https://github.com/json-c/json-c/issues/522) - update json_visit testcase \ * [Issue #523](https://github.com/json-c/json-c/issues/523) - update tsetcase for tokener_c \ * [Issue #524](https://github.com/json-c/json-c/issues/524) - Increase coverage \ * [Issue #525](https://github.com/json-c/json-c/issues/525) - update pointer test case \ * [Issue #526](https://github.com/json-c/json-c/issues/526) - Increased the test coverage of printbuf.c 82% to 92%. \ * [Issue #527](https://github.com/json-c/json-c/issues/527) - Arraylist testcase \ * [Issue #528](https://github.com/json-c/json-c/issues/528) - Solve issue #108. Skip \u0000 while parsing. \ * [Issue #529](https://github.com/json-c/json-c/issues/529) - Increased the test coverage of json_c_version.c 0% to 100%. \ * [Issue #530](https://github.com/json-c/json-c/issues/530) - validate utf-8 string before parse \ * [Issue #531](https://github.com/json-c/json-c/issues/531) - validate utf-8 string \ * [Issue #532](https://github.com/json-c/json-c/issues/532) - json_object_object_get_ex returning the original object \ * [Issue #533](https://github.com/json-c/json-c/issues/533) - Fix "make check" \ * [Issue #535](https://github.com/json-c/json-c/issues/535) - short string optimization: excessive array length \ * [Issue #536](https://github.com/json-c/json-c/issues/536) - add json_object_new_null() \ * [Issue #538](https://github.com/json-c/json-c/issues/538) - update shortstring and arraylist parameters \ * [Issue #539](https://github.com/json-c/json-c/issues/539) - double serializes to the old value after set_double \ * [Issue #541](https://github.com/json-c/json-c/issues/541) - add coveralls auto tool to json-c \ * [Issue #542](https://github.com/json-c/json-c/issues/542) - add uint64 data to json-c \ * [Issue #543](https://github.com/json-c/json-c/issues/543) - Readme \ * [Issue #544](https://github.com/json-c/json-c/issues/544) - Increase distcheck target in cmake \ * [Issue #545](https://github.com/json-c/json-c/issues/545) - add doc target in cmake \ * [Issue #546](https://github.com/json-c/json-c/issues/546) - Add uninstall target in cmake \ * [Issue #547](https://github.com/json-c/json-c/issues/547) - modify json-c default build type, and fix up the assert() errors in t… \ * [Issue #548](https://github.com/json-c/json-c/issues/548) - Solve some problems about cmake build type (debug/release) \ * [Issue #549](https://github.com/json-c/json-c/issues/549) - lib installation issues \ * [Issue #550](https://github.com/json-c/json-c/issues/550) - Format codes with clang-format tool? \ * [Issue #551](https://github.com/json-c/json-c/issues/551) - Allow hexadecimal number format convention parsing \ * [Issue #553](https://github.com/json-c/json-c/issues/553) - Fix/clang ubsan \ * [Issue #554](https://github.com/json-c/json-c/issues/554) - RFC 8259 compatibility mode \ * [Issue #555](https://github.com/json-c/json-c/issues/555) - Format json-c with clang-format tool \ * [Issue #556](https://github.com/json-c/json-c/issues/556) - Fixes various Wreturn-type and Wimplicit-fallthrough errors on Mingw-w64 \ * [Issue #557](https://github.com/json-c/json-c/issues/557) - Add option in CMAKE to not build documentation \ * [Issue #558](https://github.com/json-c/json-c/issues/558) - modify the doc target message \ * [Issue #559](https://github.com/json-c/json-c/issues/559) - json_c_visit() not exported on Windows \ * [Issue #560](https://github.com/json-c/json-c/issues/560) - error: implicit declaration of function '_strtoi64' \ * [Issue #561](https://github.com/json-c/json-c/issues/561) - add the badge in README.md and test the coveralls \ * [Issue #562](https://github.com/json-c/json-c/issues/562) - Bugfix and testcases supplements \ * [Issue #563](https://github.com/json-c/json-c/issues/563) - Changed order of calloc args to match stdlib \ * [Issue #564](https://github.com/json-c/json-c/issues/564) - Remove autogenerated files \ * [Issue #565](https://github.com/json-c/json-c/issues/565) - test the CI and ignore this PR \ * [Issue #566](https://github.com/json-c/json-c/issues/566) - add the json_types.h to Makefile.am \ * [Issue #567](https://github.com/json-c/json-c/issues/567) - Install json_types.h with autotools build as well. \ * [Issue #568](https://github.com/json-c/json-c/issues/568) - Adding better support to MinGW \ * [Issue #569](https://github.com/json-c/json-c/issues/569) - Handling of -Bsymbolic-function in CMakeLists.txt is deficient \ * [Issue #571](https://github.com/json-c/json-c/issues/571) - CMake: Bump SONAME to 5. \ * [Issue #572](https://github.com/json-c/json-c/issues/572) - Small fixes to CMakeLists \ * [Issue #573](https://github.com/json-c/json-c/issues/573) - Fix coveralls submission. \ * [Issue #574](https://github.com/json-c/json-c/issues/574) - autogen.sh missing from repository \ * [Issue #575](https://github.com/json-c/json-c/issues/575) - Small cosmetics. \ * [Issue #576](https://github.com/json-c/json-c/issues/576) - Test coverage for json_c_version. \ * [Issue #577](https://github.com/json-c/json-c/issues/577) - Be verbose on failing json_c_version test. \ * [Issue #578](https://github.com/json-c/json-c/issues/578) - CMake: Install pkgconfig file in proper location by default \ * [Issue #579](https://github.com/json-c/json-c/issues/579) - Enforce strict prototypes. \ * [Issue #580](https://github.com/json-c/json-c/issues/580) - Fix CMake tests for enforced strict prototypes. \ * [Issue #581](https://github.com/json-c/json-c/issues/581) - CMakeLists: do not enforce strict prototypes on Windows. \ json-c-json-c-0.17-20230812/issues_closed_for_0.15.md000066400000000000000000000202611446575330000214270ustar00rootroot00000000000000This list was created with: ``` curl "https://api.github.com/search/issues?q=repo%3Ajson-c%2Fjson-c+closed%3A>2020-04-18+created%3A<2020-07-23&sort=created&order=asc&per_page=100&page=1" > issues1.out jq -r '.items[] | "[" + .title + "](" + .url + ")" | tostring' issues?.out > issues.md sed -e's,^\[ *\(.*\)\](https://api.github.com/.*/\([0-9].*\)),* [Issue #\2](https://github.com/json-c/json-c/issues/\2) - \1,' -i issues.md #... manual editing ... ``` ---- Issues and Pull Requests closed for the 0.15 release (since commit 31ab57ca, the 0.14 branch point, 2020-04-19) * [Issue #428](https://github.com/json-c/json-c/issues/428) - Added new_null() function * [Issue #429](https://github.com/json-c/json-c/issues/429) - Conflict of interest between JSON_C_TO_STRING_SPACED and JSON_C_TO_STRING_PRETTY * [Issue #451](https://github.com/json-c/json-c/issues/451) - Add option to disable HAVE___THREAD * [Issue #471](https://github.com/json-c/json-c/issues/471) - create folders with mode 0755 when building * [Issue #476](https://github.com/json-c/json-c/issues/476) - Add new function named json_object_new_string_noalloc * [Issue #484](https://github.com/json-c/json-c/issues/484) - Add support for uint64 * [Issue #487](https://github.com/json-c/json-c/issues/487) - Any plans to make new release? (0.14) * [Issue #493](https://github.com/json-c/json-c/issues/493) - Kdopen rename library * [Issue #507](https://github.com/json-c/json-c/issues/507) - Double value -1.0 converts to integer in json_object_to_json_string() * [Issue #508](https://github.com/json-c/json-c/issues/508) - Recommend enabling the `-fPIC` compiler flag by default * [Issue #517](https://github.com/json-c/json-c/issues/517) - Lja mods * [Issue #534](https://github.com/json-c/json-c/issues/534) - Both json-c and json-glib have json_object_get_type() * [Issue #584](https://github.com/json-c/json-c/issues/584) - CMake: SOVERSION and the major library VERSION need to be in lockstep. * [Issue #585](https://github.com/json-c/json-c/issues/585) - CMake: Do not install config.h, as it is not a public header file. * [Issue #586](https://github.com/json-c/json-c/issues/586) - 10796 Segmentation fault * [Issue #588](https://github.com/json-c/json-c/issues/588) - Broken RDRAND causes infinite looping * [Issue #589](https://github.com/json-c/json-c/issues/589) - Detect broken RDRAND during initialization * [Issue #590](https://github.com/json-c/json-c/issues/590) - Fix segmentation fault in CPUID check * [Issue #591](https://github.com/json-c/json-c/issues/591) - Update README.md * [Issue #592](https://github.com/json-c/json-c/issues/592) - Prevent out of boundary write on malicious input * [Issue #593](https://github.com/json-c/json-c/issues/593) - Building both static and shared libraries * [Issue #594](https://github.com/json-c/json-c/issues/594) - Some subsequent call of lh_get_hash not working * [Issue #595](https://github.com/json-c/json-c/issues/595) - Support to build both static and shared libraries * [Issue #596](https://github.com/json-c/json-c/issues/596) - QA Notice: Package triggers severe warnings * [Issue #597](https://github.com/json-c/json-c/issues/597) - json_parse demo: fix and use usage() function * [Issue #598](https://github.com/json-c/json-c/issues/598) - Turning off shared libs causes target duplication or build error * [Issue #599](https://github.com/json-c/json-c/issues/599) - cannot add more than 11 objects. Is this a known issue? * [Issue #600](https://github.com/json-c/json-c/issues/600) - Library name conflicts on Windows are back again * [Issue #601](https://github.com/json-c/json-c/issues/601) - json_tokener_parse() in master sets errno=1 "Operation not permitted" * [Issue #602](https://github.com/json-c/json-c/issues/602) - fix json_parse_uint64() internal error checking with errno * [Issue #603](https://github.com/json-c/json-c/issues/603) - Backport of fixes from master branch. * [Issue #604](https://github.com/json-c/json-c/issues/604) - commit f2e991a3419ee4078e8915e840b1a0d9003b349e breaks cross-compilation with mingw * [Issue #605](https://github.com/json-c/json-c/issues/605) - Update to 0.15 release * [Issue #606](https://github.com/json-c/json-c/issues/606) - Improved support for IBM operating systems * [Issue #607](https://github.com/json-c/json-c/issues/607) - json-c-0.13.x: Fix CVE-2020-12762 - json-c through 0.14 has an integer overflow and out-of-bounds write ... * [Issue #608](https://github.com/json-c/json-c/issues/608) - json-c-0.14: Fix CVE-2020-12762 - json-c through 0.14 has an integer overflow and out-of-bounds write ... * [Issue #609](https://github.com/json-c/json-c/issues/609) - use unsigned types for sizes in lh_table and entries * [Issue #610](https://github.com/json-c/json-c/issues/610) - let's not call lh_table_resize with INT_MAX * [Issue #611](https://github.com/json-c/json-c/issues/611) - json-c-0.12.x: Fix CVE-2020-12762 - json-c through 0.14 has an integer overflow and out-of-bounds write ... * [Issue #613](https://github.com/json-c/json-c/issues/613) - json-c-0.10: Fix CVE-2020-12762 - json-c through 0.14 has an integer overflow and out-of-bounds write ... * [Issue #614](https://github.com/json-c/json-c/issues/614) - Prevent truncation on custom double formatters. * [Issue #615](https://github.com/json-c/json-c/issues/615) - New release with security fix * [Issue #616](https://github.com/json-c/json-c/issues/616) - Parsing fails if UTF-16 low surrogate pair is not in same chunk is the high pair * [Issue #617](https://github.com/json-c/json-c/issues/617) - Add an option to disable the use of thread-local storage. * [Issue #618](https://github.com/json-c/json-c/issues/618) - test_deep_copy: Fix assertion value. * [Issue #619](https://github.com/json-c/json-c/issues/619) - CMake: Fix out-of-tree build for Doxygen documentation. * [Issue #621](https://github.com/json-c/json-c/issues/621) - json-c and jansson libraries have symbol conflicts * [Issue #622](https://github.com/json-c/json-c/issues/622) - doc: Move Doxyfile into doc subdir. * [Issue #623](https://github.com/json-c/json-c/issues/623) - json_tokener_parse : Segmentation fault * [Issue #626](https://github.com/json-c/json-c/issues/626) - Fixes for cmake 2.8.12 + link issue on AIX 6.1/cc 11.01 * [Issue #627](https://github.com/json-c/json-c/issues/627) - Compat fixes * [Issue #628](https://github.com/json-c/json-c/issues/628) - get_cryptgenrandom_seed: compat with old windows + fallback * [Issue #629](https://github.com/json-c/json-c/issues/629) - [0.12] Remove the Visual Studio project file * [Issue #630](https://github.com/json-c/json-c/issues/630) - Linking with Windows MINGW not working * [Issue #632](https://github.com/json-c/json-c/issues/632) - Json object split * [Issue #633](https://github.com/json-c/json-c/issues/633) - fix issue 616: support the surrogate pair in split file. * [Issue #634](https://github.com/json-c/json-c/issues/634) - Issue #508: `-fPIC` to link libjson-c.a with libs * [Issue #635](https://github.com/json-c/json-c/issues/635) - expression has no effect warning in json_tokener.c * [Issue #636](https://github.com/json-c/json-c/issues/636) - json_object_get_string free str memory * [Issue #637](https://github.com/json-c/json-c/issues/637) - json_object_put() has 'double free or corruption (out) ' * [Issue #638](https://github.com/json-c/json-c/issues/638) - json-c/json_object.c:50:2: error: #error Unable to determine size of ssize_t * [Issue #639](https://github.com/json-c/json-c/issues/639) - build: Add a symbol version to all exported symbols * [Issue #640](https://github.com/json-c/json-c/issues/640) - Fix build issues with SSIZE_MAX on 64bit Linux * [Issue #641](https://github.com/json-c/json-c/issues/641) - Formal verification of your test suite * [Issue #642](https://github.com/json-c/json-c/issues/642) - Please provide more precise informations about when to call json_object_put * [Issue #643](https://github.com/json-c/json-c/issues/643) - not able to compare with string * [Issue #644](https://github.com/json-c/json-c/issues/644) - Why src->_userdata not checked before calling strdup? * [Issue #645](https://github.com/json-c/json-c/issues/645) - Misuse of tolower() in json_tokener.c * [Issue #646](https://github.com/json-c/json-c/issues/646) - Cast to unsigned char instead of int when calling tolower (Fixes #645) json-c-json-c-0.17-20230812/issues_closed_for_0.16.md000066400000000000000000000241301446575330000214270ustar00rootroot00000000000000This list was created with: ``` PREV=2020-07-23 NOW=2022-04-13 curl "https://api.github.com/search/issues?q=repo%3Ajson-c%2Fjson-c+closed%3A>${PREV}+created%3A<${NOW}&sort=created&order=asc&per_page=100&page=1" > issues1.out jq -r '.items[] | "[" + .title + "](" + .url + ")" | tostring' issues?.out > issues.md sed -e's,^\[ *\(.*\)\](https://api.github.com/.*/\([0-9].*\)),* [Issue #\2](https://github.com/json-c/json-c/issues/\2) - \1,' -i issues.md cat issues.md >> issues_closed_for_0.16.md ``` * [Issue #464](https://github.com/json-c/json-c/issues/464) - Speed up parsing and object creation * [Issue #540](https://github.com/json-c/json-c/issues/540) - request: json_init_library * [Issue #631](https://github.com/json-c/json-c/issues/631) - New 0.14 release requests * [Issue #647](https://github.com/json-c/json-c/issues/647) - "cmake -DCMAKE_BUILD_TYPE=Release" fails with error: 'cint64' may be used uninitialized * [Issue #648](https://github.com/json-c/json-c/issues/648) - Fix "may be used uninitialized" Release build failure * [Issue #649](https://github.com/json-c/json-c/issues/649) - json-c tag 0.15 tarball contains a file doc/Doxyfile and generated doxygen files in doc/html * [Issue #650](https://github.com/json-c/json-c/issues/650) - README: fix spelling errors * [Issue #651](https://github.com/json-c/json-c/issues/651) - Getrandom * [Issue #652](https://github.com/json-c/json-c/issues/652) - Waste memory * [Issue #653](https://github.com/json-c/json-c/issues/653) - Make the documentation build reproducibly * [Issue #654](https://github.com/json-c/json-c/issues/654) - A stack-buffer-overflow in json_parse.c:89:44 * [Issue #655](https://github.com/json-c/json-c/issues/655) - json_parse: Fix read past end of buffer * [Issue #656](https://github.com/json-c/json-c/issues/656) - Fixed warnings * [Issue #657](https://github.com/json-c/json-c/issues/657) - Use GRND_NONBLOCK with getrandom. * [Issue #658](https://github.com/json-c/json-c/issues/658) - json_object_get_boolean() returns wrong result for objects and arrays * [Issue #659](https://github.com/json-c/json-c/issues/659) - fix json_object_get_boolean() to behave like documented * [Issue #660](https://github.com/json-c/json-c/issues/660) - Validate size arguments in arraylist functions. * [Issue #661](https://github.com/json-c/json-c/issues/661) - Cleanup of some code parts * [Issue #662](https://github.com/json-c/json-c/issues/662) - Prevent signed overflow in get_time_seed * [Issue #663](https://github.com/json-c/json-c/issues/663) - Properly format errnos in _json_c_strerror * [Issue #664](https://github.com/json-c/json-c/issues/664) - Limit strings at INT_MAX length * [Issue #665](https://github.com/json-c/json-c/issues/665) - Handle more allocation failures in json_tokener* functions * [Issue #666](https://github.com/json-c/json-c/issues/666) - test1 json_object_new_array_ext test is failing * [Issue #667](https://github.com/json-c/json-c/issues/667) - Fixed test1 regression. * [Issue #670](https://github.com/json-c/json-c/issues/670) - Created Stone-Paper-Scissor Game by C language * [Issue #672](https://github.com/json-c/json-c/issues/672) - Calling exit() after failure to generate random seed * [Issue #673](https://github.com/json-c/json-c/issues/673) - switchcasemenuproject * [Issue #674](https://github.com/json-c/json-c/issues/674) - random_seed: on error, continue to next method * [Issue #682](https://github.com/json-c/json-c/issues/682) - libjson-c-dev vs libjson-c3 * [Issue #683](https://github.com/json-c/json-c/issues/683) - [Question] Is it possible to clear a ptr of json_object? * [Issue #684](https://github.com/json-c/json-c/issues/684) - json_tokener_parse_verbose failed with core dump * [Issue #685](https://github.com/json-c/json-c/issues/685) - json_tokener_parse memory leak? * [Issue #689](https://github.com/json-c/json-c/issues/689) - fix compilation with clang * [Issue #690](https://github.com/json-c/json-c/issues/690) - "1," produces an object with int 1; "1" produces a null object * [Issue #691](https://github.com/json-c/json-c/issues/691) - failed tests * [Issue #692](https://github.com/json-c/json-c/issues/692) - patch to add arc4random * [Issue #693](https://github.com/json-c/json-c/issues/693) - Optional parameter for packing as array * [Issue #694](https://github.com/json-c/json-c/issues/694) - fix invalid unsigned arithmetic. * [Issue #695](https://github.com/json-c/json-c/issues/695) - /tmp/json-c/random_seed.c:327:6: error * [Issue #696](https://github.com/json-c/json-c/issues/696) - To avoid target exe file export JSON functions. * [Issue #697](https://github.com/json-c/json-c/issues/697) - json_object_get_string() return value truncated when assigning it to a pointer type in Win32 App * [Issue #698](https://github.com/json-c/json-c/issues/698) - Feature request: set allocator * [Issue #699](https://github.com/json-c/json-c/issues/699) - Linking to libjson-c Issue * [Issue #700](https://github.com/json-c/json-c/issues/700) - Fix unused variable for Win32 build in random_seed.c * [Issue #701](https://github.com/json-c/json-c/issues/701) - [RFC] json_pointer: allow the feature to be disabled * [Issue #703](https://github.com/json-c/json-c/issues/703) - Fix vasprintf fallback * [Issue #706](https://github.com/json-c/json-c/issues/706) - Check __STDC_VERSION__ is defined before checking its value * [Issue #707](https://github.com/json-c/json-c/issues/707) - How to build json-c-0.15 for arm arch * [Issue #708](https://github.com/json-c/json-c/issues/708) - direct access to elements * [Issue #709](https://github.com/json-c/json-c/issues/709) - Include guards not namespaced / build errors for debug.h with openNDS * [Issue #710](https://github.com/json-c/json-c/issues/710) - 'file system sandbox blocked mmap()' error on iOS * [Issue #711](https://github.com/json-c/json-c/issues/711) - creating a json object * [Issue #712](https://github.com/json-c/json-c/issues/712) - building json-c using cmake for ESP32 * [Issue #713](https://github.com/json-c/json-c/issues/713) - When value converted to char* can not compare it with another value * [Issue #714](https://github.com/json-c/json-c/issues/714) - Add AfterCaseLabel to .clang-format * [Issue #716](https://github.com/json-c/json-c/issues/716) - Fixed cmake command * [Issue #717](https://github.com/json-c/json-c/issues/717) - Cmake is able delete all files by "clean" target * [Issue #718](https://github.com/json-c/json-c/issues/718) - CMake create uninstall target if unix generator is used * [Issue #719](https://github.com/json-c/json-c/issues/719) - Parsing multiple JSON strings * [Issue #722](https://github.com/json-c/json-c/issues/722) - Fix use-after-free in json_tokener_new_ex() * [Issue #723](https://github.com/json-c/json-c/issues/723) - if set __stdcall (/Gz) * [Issue #724](https://github.com/json-c/json-c/issues/724) - #723 * [Issue #725](https://github.com/json-c/json-c/issues/725) - json_object_from_file() execution segment error * [Issue #726](https://github.com/json-c/json-c/issues/726) - fix cmake version for tests * [Issue #727](https://github.com/json-c/json-c/issues/727) - Really use prefix JSON_C_OBJECT_ADD_ * [Issue #728](https://github.com/json-c/json-c/issues/728) - DRAFT PROPOSAL - Add option JSON_C_OBJECT_ADD_IF_NOT_NULL * [Issue #729](https://github.com/json-c/json-c/issues/729) - * don't assume includedir * [Issue #731](https://github.com/json-c/json-c/issues/731) - Json-c Error * [Issue #732](https://github.com/json-c/json-c/issues/732) - Fix/static include dirs * [Issue #734](https://github.com/json-c/json-c/issues/734) - Newer appveyor config for VS2022 etc... * [Issue #735](https://github.com/json-c/json-c/issues/735) - Add policy_max to minimum required cmake version * [Issue #736](https://github.com/json-c/json-c/issues/736) - json_object.c:308: json_object_put: Assertion `jso->_ref_count > 0' failed * [Issue #737](https://github.com/json-c/json-c/issues/737) - Fix typo in README * [Issue #738](https://github.com/json-c/json-c/issues/738) - General question - Is there an SLA for handling newly detected security issues? * [Issue #739](https://github.com/json-c/json-c/issues/739) - json_escape_str(): avoid harmless unsigned integer overflow * [Issue #741](https://github.com/json-c/json-c/issues/741) - json_type_to_name(): use correct printf() formatter * [Issue #742](https://github.com/json-c/json-c/issues/742) - json_object_copy_serializer_data(): add assertion * [Issue #743](https://github.com/json-c/json-c/issues/743) - Cmd adb root * [Issue #744](https://github.com/json-c/json-c/issues/744) - Close file on error path. * [Issue #745](https://github.com/json-c/json-c/issues/745) - vasprintf(): avoid out of memory accesses * [Issue #746](https://github.com/json-c/json-c/issues/746) - Fix typos in code comments and ChangeLog * [Issue #747](https://github.com/json-c/json-c/issues/747) - json_object_put: Assertion `jso->_ref_count > 0' failed * [Issue #748](https://github.com/json-c/json-c/issues/748) - sprintbuf(): test for all vsnprintf error values * [Issue #749](https://github.com/json-c/json-c/issues/749) - sprintbuf(): handle printbuf_memappend errors * [Issue #750](https://github.com/json-c/json-c/issues/750) - printbuf_memset(): set gaps to zero * [Issue #751](https://github.com/json-c/json-c/issues/751) - printbuf: do not allow invalid arguments * [Issue #752](https://github.com/json-c/json-c/issues/752) - Fix typos * [Issue #753](https://github.com/json-c/json-c/issues/753) - CTest failed in MSVC build * [Issue #754](https://github.com/json-c/json-c/issues/754) - Minor improvements to documentation * [Issue #755](https://github.com/json-c/json-c/issues/755) - Fix error messages * [Issue #758](https://github.com/json-c/json-c/issues/758) - Preserve context if out of memory * [Issue #760](https://github.com/json-c/json-c/issues/760) - Code style: removed unneeded double-quotes * [Issue #761](https://github.com/json-c/json-c/issues/761) - Last commit merged to master breaks compilation * [Issue #762](https://github.com/json-c/json-c/issues/762) - how to merge two jsons by json-c * [Issue #763](https://github.com/json-c/json-c/issues/763) - Question: sort_fn arguments * [Issue #764](https://github.com/json-c/json-c/issues/764) - Make test fail on test case test_util_file json-c-json-c-0.17-20230812/issues_closed_for_0.17.md000066400000000000000000000217371446575330000214420ustar00rootroot00000000000000This list was created with: ``` PREV=2022-04-13 NOW=2023-08-12 curl "https://api.github.com/search/issues?q=repo%3Ajson-c%2Fjson-c+closed%3A>${PREV}+created%3A<${NOW}&sort=created&order=asc&per_page=100&page=1" > issues1.out jq -r '.items[] | "[" + .title + "](" + .url + ")" | tostring' issues?.out > issues.md sed -e's,^\[ *\(.*\)\](https://api.github.com/.*/\([0-9].*\)),* [Issue #\2](https://github.com/json-c/json-c/issues/\2) - \1,' -i issues.md cat issues.md >> issues_closed_for_0.17.md ``` * [Issue #191](https://github.com/json-c/json-c/issues/191) - Override int64 to only display uint64 strings * [Issue #537](https://github.com/json-c/json-c/issues/537) - Replace '\0' only when parsing key, not change data in value. * [Issue #570](https://github.com/json-c/json-c/issues/570) - Figure out what needs to be done with Android.configure.mk * [Issue #587](https://github.com/json-c/json-c/issues/587) - Store the hashValue to avoid repeating the hash calculation during the hash resize. * [Issue #612](https://github.com/json-c/json-c/issues/612) - json-c-0.11: Fix CVE-2020-12762 - json-c through 0.14 has an integer overflow and out-of-bounds write ... * [Issue #620](https://github.com/json-c/json-c/issues/620) - Introduce json_object_new_string_{ext,noalloc}(). * [Issue #624](https://github.com/json-c/json-c/issues/624) - json-c-0.14: Detect broken RDRAND during initialization. * [Issue #625](https://github.com/json-c/json-c/issues/625) - json-c-0.13.x: Detect broken RDRAND during initialization. * [Issue #668](https://github.com/json-c/json-c/issues/668) - Memory usage regression due to newlocal() on older FreeBSD releases * [Issue #676](https://github.com/json-c/json-c/issues/676) - dereferencing type-punned pointer might break strict-aliasing rules [-Werror=strict-aliasing] * [Issue #677](https://github.com/json-c/json-c/issues/677) - Naming conflict when using both json-c and jansson * [Issue #679](https://github.com/json-c/json-c/issues/679) - Let json-c be used with obsolete compilers * [Issue #681](https://github.com/json-c/json-c/issues/681) - json_tokener_parse_ex: `null` (4 bytes) only parses as valid JSON when passed with null terminator (5 bytes). Documentation issue? * [Issue #686](https://github.com/json-c/json-c/issues/686) - Remove dependency on libM::getrandom * [Issue #687](https://github.com/json-c/json-c/issues/687) - Does not build on Apple Silicon M1 * [Issue #688](https://github.com/json-c/json-c/issues/688) - json-c-0.15-nodoc.tar.gz build fails * [Issue #702](https://github.com/json-c/json-c/issues/702) - json_patch: add first implementation only with patch application * [Issue #704](https://github.com/json-c/json-c/issues/704) - add json_object_array_insert_idx() + test-cases + fix json_pointer doc-strings * [Issue #705](https://github.com/json-c/json-c/issues/705) - segmentation fault on json-c parsing methods in cross compiled target * [Issue #721](https://github.com/json-c/json-c/issues/721) - cmake test fails with building json-c with icc * [Issue #730](https://github.com/json-c/json-c/issues/730) - Need a comparison with other JSON libraries in C * [Issue #733](https://github.com/json-c/json-c/issues/733) - Official release? 1.0? * [Issue #756](https://github.com/json-c/json-c/issues/756) - Question: Is there any way to build this with Gnu Make? * [Issue #757](https://github.com/json-c/json-c/issues/757) - json_object_from_fd_ex: fail if file is too large * [Issue #759](https://github.com/json-c/json-c/issues/759) - json_tokener_parse_ex: handle out of memory errors * [Issue #766](https://github.com/json-c/json-c/issues/766) - Some people have trouble with undefined references to arc4random * [Issue #767](https://github.com/json-c/json-c/issues/767) - How to create a character array using json-c * [Issue #768](https://github.com/json-c/json-c/issues/768) - commits from May 30, 2022 killed my docker build process * [Issue #769](https://github.com/json-c/json-c/issues/769) - Issue #768 * [Issue #770](https://github.com/json-c/json-c/issues/770) - json_parse.c:170:13: error: this statement may fall through * [Issue #771](https://github.com/json-c/json-c/issues/771) - fix fallthough warning * [Issue #772](https://github.com/json-c/json-c/issues/772) - add JSON_C_TO_STRING_COLOR option * [Issue #773](https://github.com/json-c/json-c/issues/773) - problem with u_int64_t * [Issue #774](https://github.com/json-c/json-c/issues/774) - The function add_compile_options was added to CMake version 2.8.12 and later but your minimum is 2.8 which will not work * [Issue #775](https://github.com/json-c/json-c/issues/775) - list(TRANSFORM ...) is not available prior to CMake 3.12. * [Issue #776](https://github.com/json-c/json-c/issues/776) - Fix typo * [Issue #777](https://github.com/json-c/json-c/issues/777) - Don't try to change locale when libc only supports the C locale * [Issue #778](https://github.com/json-c/json-c/issues/778) - Do not insert newlines when converting empty arrays to json string and JSON_C_TO_STRING_PRETTY is used * [Issue #779](https://github.com/json-c/json-c/issues/779) - Fix compiling for Android * [Issue #780](https://github.com/json-c/json-c/issues/780) - Memory Leak when setting empty strings when c_string.pdata is used * [Issue #781](https://github.com/json-c/json-c/issues/781) - Fix memory leak with emtpy strings in json_object_set_string * [Issue #782](https://github.com/json-c/json-c/issues/782) - Fix typos found by codespell * [Issue #783](https://github.com/json-c/json-c/issues/783) - Fix build with clang-15+ * [Issue #784](https://github.com/json-c/json-c/issues/784) - get_time_seed(): silence warning emitted by Coverity Scan static analyzer * [Issue #786](https://github.com/json-c/json-c/issues/786) - ghpages update was not published for json-c-0.16 * [Issue #787](https://github.com/json-c/json-c/issues/787) - -static linker flag result in building failed * [Issue #788](https://github.com/json-c/json-c/issues/788) - Clear sensitive information. * [Issue #789](https://github.com/json-c/json-c/issues/789) - Unnecessary struct declaration and unsafe function usage * [Issue #790](https://github.com/json-c/json-c/issues/790) - Small update to README file * [Issue #791](https://github.com/json-c/json-c/issues/791) - json_object_object_foreach not ISO-C compliant * [Issue #792](https://github.com/json-c/json-c/issues/792) - ` json_object_get_int` does not set `EINVAL` on invalid string * [Issue #794](https://github.com/json-c/json-c/issues/794) - replaced * [Issue #796](https://github.com/json-c/json-c/issues/796) - Added Test for get int functions * [Issue #797](https://github.com/json-c/json-c/issues/797) - make uninstall * [Issue #798](https://github.com/json-c/json-c/issues/798) - API to deal with enums is missing * [Issue #799](https://github.com/json-c/json-c/issues/799) - json_object_put: Assertion `jso->_ref_count > 0' failed. * [Issue #800](https://github.com/json-c/json-c/issues/800) - String converted to scientific notation * [Issue #801](https://github.com/json-c/json-c/issues/801) - #error You do not have strncasecmp on your system. * [Issue #802](https://github.com/json-c/json-c/issues/802) - Problem: modern CMake warns about version 2.8 * [Issue #803](https://github.com/json-c/json-c/issues/803) - Problem: confusing error message in snprintf_compat.h * [Issue #804](https://github.com/json-c/json-c/issues/804) - Problem: cmake 3.25.1 warns about CMP0042 not being set * [Issue #806](https://github.com/json-c/json-c/issues/806) - The problem is libjson-c.dylib incompatible with OS version * [Issue #807](https://github.com/json-c/json-c/issues/807) - json simple parse syntax * [Issue #808](https://github.com/json-c/json-c/issues/808) - iOS Build using cmake fails due to 64 to 32bits conversion precision loss * [Issue #809](https://github.com/json-c/json-c/issues/809) - Feature request json_object_new_uint() * [Issue #810](https://github.com/json-c/json-c/issues/810) - docs: update to Internet Standard reference * [Issue #811](https://github.com/json-c/json-c/issues/811) - dependence on execution character set * [Issue #812](https://github.com/json-c/json-c/issues/812) - Duplicate symbol when compiling with clang-cl * [Issue #813](https://github.com/json-c/json-c/issues/813) - Build apps only in project itself. * [Issue #814](https://github.com/json-c/json-c/issues/814) - Code execution order * [Issue #816](https://github.com/json-c/json-c/issues/816) - Hi I need to generate libjson-c.so.3 and libjson-c.so.3.0.1, please help with steps * [Issue #818](https://github.com/json-c/json-c/issues/818) - error: a function declaration without a prototype is deprecated in all versions of C * [Issue #819](https://github.com/json-c/json-c/issues/819) - build with intel 2023 fails on vasprintf * [Issue #820](https://github.com/json-c/json-c/issues/820) - ISO C forbids in * [Issue #821](https://github.com/json-c/json-c/issues/821) - Any release planing for 0.17? * [Issue #822](https://github.com/json-c/json-c/issues/822) - Added option to disable app build * [Issue #823](https://github.com/json-c/json-c/issues/823) - Symbol not found during linking stage of libjson-c.so json-c-json-c-0.17-20230812/json-c.pc.in000066400000000000000000000004041446575330000170470ustar00rootroot00000000000000prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ Name: json-c Description: A JSON implementation in C Version: @VERSION@ Requires: Libs.private: @LIBS@ Libs: -L${libdir} -ljson-c Cflags: -I${includedir} -I${includedir}/json-c json-c-json-c-0.17-20230812/json-c.sym000066400000000000000000000102461446575330000166550ustar00rootroot00000000000000 /* * Symbol versioning for libjson-c. * All exported symbols must be listed here. * * See * https://software.intel.com/sites/default/files/m/a/1/e/dsohowto.pdf */ /* * Symbols in JSONC_PRIVATE are exported for historical * reasons, but should not be used outside of json-c. */ JSONC_PRIVATE { array_list_add; array_list_del_idx; array_list_free; array_list_new; array_list_put_idx; array_list_sort; json_hex_chars; json_parse_double; json_parse_int64; json_parse_uint64; lh_table_delete; lh_table_delete_entry; lh_table_free; lh_table_insert; lh_table_insert_w_hash; lh_table_new; lh_table_resize; mc_debug; mc_error; mc_get_debug; mc_info; mc_set_debug; mc_set_syslog; printbuf_free; printbuf_memappend; printbuf_memset; printbuf_new; printbuf_reset; sprintbuf; # Used by tests: _json_c_strerror; }; JSONC_0.14 { global: array_list_bsearch; array_list_get_idx; array_list_length; json_c_get_random_seed; json_c_object_sizeof; json_c_set_serialization_double_format; json_c_shallow_copy_default; json_c_version; json_c_version_num; json_c_visit; json_global_set_string_hash; json_number_chars; json_object_array_add; json_object_array_bsearch; json_object_array_del_idx; json_object_array_get_idx; json_object_array_length; json_object_array_put_idx; json_object_array_sort; json_object_deep_copy; json_object_double_to_json_string; json_object_equal; json_object_free_userdata; json_object_from_fd; json_object_from_fd_ex; json_object_from_file; json_object_get; json_object_get_array; json_object_get_boolean; json_object_get_double; json_object_get_int64; json_object_get_int; json_object_get_object; json_object_get_string; json_object_get_string_len; json_object_get_type; json_object_get_uint64; json_object_get_userdata; json_object_int_inc; json_object_is_type; json_object_iter_begin; json_object_iter_end; json_object_iter_equal; json_object_iter_init_default; json_object_iter_next; json_object_iter_peek_name; json_object_iter_peek_value; json_object_new_array; json_object_new_boolean; json_object_new_double; json_object_new_double_s; json_object_new_int64; json_object_new_int; json_object_new_null; json_object_new_object; json_object_new_string; json_object_new_string_len; json_object_new_uint64; json_object_object_add; json_object_object_add_ex; json_object_object_del; json_object_object_get; json_object_object_get_ex; json_object_object_length; json_object_put; json_object_set_boolean; json_object_set_double; json_object_set_int64; json_object_set_int; json_object_set_serializer; json_object_set_string; json_object_set_string_len; json_object_set_uint64; json_object_set_userdata; json_object_to_fd; json_object_to_file; json_object_to_file_ext; json_object_to_json_string; json_object_to_json_string_ext; json_object_to_json_string_length; json_object_userdata_to_json_string; json_pointer_get; json_pointer_getf; json_pointer_set; json_pointer_setf; json_tokener_error_desc; json_tokener_free; json_tokener_get_error; json_tokener_get_parse_end; json_tokener_new; json_tokener_new_ex; json_tokener_parse; json_tokener_parse_ex; json_tokener_parse_verbose; json_tokener_reset; json_tokener_set_flags; json_type_to_name; json_util_get_last_err; lh_char_equal; lh_kchar_table_new; lh_kptr_table_new; lh_ptr_equal; lh_table_length; lh_table_lookup_entry; lh_table_lookup_entry_w_hash; lh_table_lookup_ex; local: *; }; JSONC_0.15 { global: array_list_new2; array_list_shrink; json_object_array_shrink; json_object_new_array_ext; } JSONC_0.14; JSONC_0.16 { # No new symbols in 0.16 } JSONC_0.15; JSONC_0.17 { global: json_object_array_insert_idx; json_patch_apply; # array_list_insert_idx is intentionally not exported } JSONC_0.16; json-c-json-c-0.17-20230812/json.h.cmakein000066400000000000000000000014721446575330000174630ustar00rootroot00000000000000/* * $Id: json.h,v 1.6 2006/01/26 02:16:28 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * Copyright (c) 2009 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief A convenience header that may be included instead of other individual ones. */ #ifndef _json_h_ #define _json_h_ #ifdef __cplusplus extern "C" { #endif #include "arraylist.h" #include "debug.h" #include "json_c_version.h" #include "json_object.h" #include "json_object_iterator.h" @JSON_H_JSON_PATCH@ @JSON_H_JSON_POINTER@ #include "json_tokener.h" #include "json_util.h" #include "linkhash.h" #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/json_c_version.c000066400000000000000000000005531446575330000201160ustar00rootroot00000000000000/* * Copyright (c) 2012 Eric Haszlakiewicz * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. */ #include "config.h" #include "json_c_version.h" const char *json_c_version(void) { return JSON_C_VERSION; } int json_c_version_num(void) { return JSON_C_VERSION_NUM; } json-c-json-c-0.17-20230812/json_c_version.h000066400000000000000000000025301446575330000201200ustar00rootroot00000000000000/* * Copyright (c) 2012,2017 Eric Haszlakiewicz * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. */ /** * @file * @brief Methods for retrieving the json-c version. */ #ifndef _json_c_version_h_ #define _json_c_version_h_ #ifdef __cplusplus extern "C" { #endif #define JSON_C_MAJOR_VERSION 0 #define JSON_C_MINOR_VERSION 17 #define JSON_C_MICRO_VERSION 0 #define JSON_C_VERSION_NUM \ ((JSON_C_MAJOR_VERSION << 16) | (JSON_C_MINOR_VERSION << 8) | JSON_C_MICRO_VERSION) #define JSON_C_VERSION "0.17" #ifndef JSON_EXPORT #if defined(_MSC_VER) && defined(JSON_C_DLL) #define JSON_EXPORT __declspec(dllexport) #else #define JSON_EXPORT extern #endif #endif /** * @see JSON_C_VERSION * @return the version of the json-c library as a string */ JSON_EXPORT const char *json_c_version(void); /* Returns JSON_C_VERSION */ /** * The json-c version encoded into an int, with the low order 8 bits * being the micro version, the next higher 8 bits being the minor version * and the next higher 8 bits being the major version. * For example, 7.12.99 would be 0x00070B63. * * @see JSON_C_VERSION_NUM * @return the version of the json-c library as an int */ JSON_EXPORT int json_c_version_num(void); /* Returns JSON_C_VERSION_NUM */ #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/json_config.h.in000066400000000000000000000001331446575330000200000ustar00rootroot00000000000000 /* Define to 1 if you have the header file. */ #undef JSON_C_HAVE_INTTYPES_H json-c-json-c-0.17-20230812/json_config.h.win32000066400000000000000000000002171446575330000203370ustar00rootroot00000000000000 /* Define to 1 if you have the header file. */ #if defined(_MSC_VER) && _MSC_VER >= 1800 #define JSON_C_HAVE_INTTYPES_H 1 #endif json-c-json-c-0.17-20230812/json_inttypes.h000066400000000000000000000012431446575330000200100ustar00rootroot00000000000000 /** * @file * @brief Do not use, json-c internal, may be changed or removed at any time. */ #ifndef _json_inttypes_h_ #define _json_inttypes_h_ #include "json_config.h" #ifdef JSON_C_HAVE_INTTYPES_H /* inttypes.h includes stdint.h */ #include #else #ifdef JSON_C_HAVE_STDINT_H #include #else /* Really only valid for old MS compilers, VS2008 and earlier: */ typedef __int32 int32_t; typedef unsigned __int32 uint32_t; typedef __int64 int64_t; typedef unsigned __int64 uint64_t; #endif #define PRId64 "I64d" #define SCNd64 "I64d" #define PRIu64 "I64u" #endif #if defined(_MSC_VER) #include typedef SSIZE_T ssize_t; #endif #endif json-c-json-c-0.17-20230812/json_object.c000066400000000000000000001412131446575330000173740ustar00rootroot00000000000000/* * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * Copyright (c) 2009 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ #include "config.h" #include "strerror_override.h" #include #ifdef HAVE_LIMITS_H #include #endif #include #include #include #include #include #include "arraylist.h" #include "debug.h" #include "json_inttypes.h" #include "json_object.h" #include "json_object_private.h" #include "json_util.h" #include "linkhash.h" #include "math_compat.h" #include "printbuf.h" #include "snprintf_compat.h" #include "strdup_compat.h" /* Avoid ctype.h and locale overhead */ #define is_plain_digit(c) ((c) >= '0' && (c) <= '9') #if SIZEOF_LONG_LONG != SIZEOF_INT64_T #error The long long type is not 64-bits #endif #ifndef SSIZE_T_MAX #if SIZEOF_SSIZE_T == SIZEOF_INT #define SSIZE_T_MAX INT_MAX #elif SIZEOF_SSIZE_T == SIZEOF_LONG #define SSIZE_T_MAX LONG_MAX #elif SIZEOF_SSIZE_T == SIZEOF_LONG_LONG #define SSIZE_T_MAX LLONG_MAX #else #error Unable to determine size of ssize_t #endif #endif const char *json_number_chars = "0123456789.+-eE"; /* Unused, but part of public API, drop for 1.0 */ const char *json_hex_chars = "0123456789abcdefABCDEF"; static void json_object_generic_delete(struct json_object *jso); #if defined(_MSC_VER) && (_MSC_VER <= 1800) /* VS2013 doesn't know about "inline" */ #define inline __inline #elif defined(AIX_CC) #define inline #endif /* define colors */ #define ANSI_COLOR_RESET "\033[0m" #define ANSI_COLOR_FG_GREEN "\033[0;32m" #define ANSI_COLOR_FG_BLUE "\033[0;34m" #define ANSI_COLOR_FG_MAGENTA "\033[0;35m" /* * Helper functions to more safely cast to a particular type of json_object */ static inline struct json_object_object *JC_OBJECT(struct json_object *jso) { return (void *)jso; } static inline const struct json_object_object *JC_OBJECT_C(const struct json_object *jso) { return (const void *)jso; } static inline struct json_object_array *JC_ARRAY(struct json_object *jso) { return (void *)jso; } static inline const struct json_object_array *JC_ARRAY_C(const struct json_object *jso) { return (const void *)jso; } static inline struct json_object_boolean *JC_BOOL(struct json_object *jso) { return (void *)jso; } static inline const struct json_object_boolean *JC_BOOL_C(const struct json_object *jso) { return (const void *)jso; } static inline struct json_object_double *JC_DOUBLE(struct json_object *jso) { return (void *)jso; } static inline const struct json_object_double *JC_DOUBLE_C(const struct json_object *jso) { return (const void *)jso; } static inline struct json_object_int *JC_INT(struct json_object *jso) { return (void *)jso; } static inline const struct json_object_int *JC_INT_C(const struct json_object *jso) { return (const void *)jso; } static inline struct json_object_string *JC_STRING(struct json_object *jso) { return (void *)jso; } static inline const struct json_object_string *JC_STRING_C(const struct json_object *jso) { return (const void *)jso; } #define JC_CONCAT(a, b) a##b #define JC_CONCAT3(a, b, c) a##b##c #define JSON_OBJECT_NEW(jtype) \ (struct JC_CONCAT(json_object_, jtype) *)json_object_new( \ JC_CONCAT(json_type_, jtype), sizeof(struct JC_CONCAT(json_object_, jtype)), \ &JC_CONCAT3(json_object_, jtype, _to_json_string)) static inline struct json_object *json_object_new(enum json_type o_type, size_t alloc_size, json_object_to_json_string_fn *to_json_string); static void json_object_object_delete(struct json_object *jso_base); static void json_object_string_delete(struct json_object *jso); static void json_object_array_delete(struct json_object *jso); static json_object_to_json_string_fn json_object_object_to_json_string; static json_object_to_json_string_fn json_object_boolean_to_json_string; static json_object_to_json_string_fn json_object_double_to_json_string_default; static json_object_to_json_string_fn json_object_int_to_json_string; static json_object_to_json_string_fn json_object_string_to_json_string; static json_object_to_json_string_fn json_object_array_to_json_string; static json_object_to_json_string_fn _json_object_userdata_to_json_string; #ifndef JSON_NORETURN #if defined(_MSC_VER) #define JSON_NORETURN __declspec(noreturn) #elif defined(__OS400__) #define JSON_NORETURN #else /* 'cold' attribute is for optimization, telling the computer this code * path is unlikely. */ #define JSON_NORETURN __attribute__((noreturn, cold)) #endif #endif /** * Abort and optionally print a message on standard error. * This should be used rather than assert() for unconditional abortion * (in particular for code paths which are never supposed to be run). * */ JSON_NORETURN static void json_abort(const char *message); /* helper for accessing the optimized string data component in json_object */ static inline char *get_string_component_mutable(struct json_object *jso) { if (JC_STRING_C(jso)->len < 0) { /* Due to json_object_set_string(), we might have a pointer */ return JC_STRING(jso)->c_string.pdata; } return JC_STRING(jso)->c_string.idata; } static inline const char *get_string_component(const struct json_object *jso) { return get_string_component_mutable((void *)(uintptr_t)(const void *)jso); } /* string escaping */ static int json_escape_str(struct printbuf *pb, const char *str, size_t len, int flags) { size_t pos = 0, start_offset = 0; unsigned char c; while (len) { --len; c = str[pos]; switch (c) { case '\b': case '\n': case '\r': case '\t': case '\f': case '"': case '\\': case '/': if ((flags & JSON_C_TO_STRING_NOSLASHESCAPE) && c == '/') { pos++; break; } if (pos > start_offset) printbuf_memappend(pb, str + start_offset, pos - start_offset); if (c == '\b') printbuf_memappend(pb, "\\b", 2); else if (c == '\n') printbuf_memappend(pb, "\\n", 2); else if (c == '\r') printbuf_memappend(pb, "\\r", 2); else if (c == '\t') printbuf_memappend(pb, "\\t", 2); else if (c == '\f') printbuf_memappend(pb, "\\f", 2); else if (c == '"') printbuf_memappend(pb, "\\\"", 2); else if (c == '\\') printbuf_memappend(pb, "\\\\", 2); else if (c == '/') printbuf_memappend(pb, "\\/", 2); start_offset = ++pos; break; default: if (c < ' ') { char sbuf[7]; if (pos > start_offset) printbuf_memappend(pb, str + start_offset, pos - start_offset); snprintf(sbuf, sizeof(sbuf), "\\u00%c%c", json_hex_chars[c >> 4], json_hex_chars[c & 0xf]); printbuf_memappend_fast(pb, sbuf, (int)sizeof(sbuf) - 1); start_offset = ++pos; } else pos++; } } if (pos > start_offset) printbuf_memappend(pb, str + start_offset, pos - start_offset); return 0; } /* reference counting */ struct json_object *json_object_get(struct json_object *jso) { if (!jso) return jso; // Don't overflow the refcounter. assert(jso->_ref_count < UINT32_MAX); #if defined(HAVE_ATOMIC_BUILTINS) && defined(ENABLE_THREADING) __sync_add_and_fetch(&jso->_ref_count, 1); #else ++jso->_ref_count; #endif return jso; } int json_object_put(struct json_object *jso) { if (!jso) return 0; /* Avoid invalid free and crash explicitly instead of (silently) * segfaulting. */ assert(jso->_ref_count > 0); #if defined(HAVE_ATOMIC_BUILTINS) && defined(ENABLE_THREADING) /* Note: this only allow the refcount to remain correct * when multiple threads are adjusting it. It is still an error * for a thread to decrement the refcount if it doesn't "own" it, * as that can result in the thread that loses the race to 0 * operating on an already-freed object. */ if (__sync_sub_and_fetch(&jso->_ref_count, 1) > 0) return 0; #else if (--jso->_ref_count > 0) return 0; #endif if (jso->_user_delete) jso->_user_delete(jso, jso->_userdata); switch (jso->o_type) { case json_type_object: json_object_object_delete(jso); break; case json_type_array: json_object_array_delete(jso); break; case json_type_string: json_object_string_delete(jso); break; default: json_object_generic_delete(jso); break; } return 1; } /* generic object construction and destruction parts */ static void json_object_generic_delete(struct json_object *jso) { printbuf_free(jso->_pb); free(jso); } static inline struct json_object *json_object_new(enum json_type o_type, size_t alloc_size, json_object_to_json_string_fn *to_json_string) { struct json_object *jso; jso = (struct json_object *)malloc(alloc_size); if (!jso) return NULL; jso->o_type = o_type; jso->_ref_count = 1; jso->_to_json_string = to_json_string; jso->_pb = NULL; jso->_user_delete = NULL; jso->_userdata = NULL; //jso->... // Type-specific fields must be set by caller return jso; } /* type checking functions */ int json_object_is_type(const struct json_object *jso, enum json_type type) { if (!jso) return (type == json_type_null); return (jso->o_type == type); } enum json_type json_object_get_type(const struct json_object *jso) { if (!jso) return json_type_null; return jso->o_type; } void *json_object_get_userdata(json_object *jso) { return jso ? jso->_userdata : NULL; } void json_object_set_userdata(json_object *jso, void *userdata, json_object_delete_fn *user_delete) { // Can't return failure, so abort if we can't perform the operation. assert(jso != NULL); // First, clean up any previously existing user info if (jso->_user_delete) jso->_user_delete(jso, jso->_userdata); jso->_userdata = userdata; jso->_user_delete = user_delete; } /* set a custom conversion to string */ void json_object_set_serializer(json_object *jso, json_object_to_json_string_fn *to_string_func, void *userdata, json_object_delete_fn *user_delete) { json_object_set_userdata(jso, userdata, user_delete); if (to_string_func == NULL) { // Reset to the standard serialization function switch (jso->o_type) { case json_type_null: jso->_to_json_string = NULL; break; case json_type_boolean: jso->_to_json_string = &json_object_boolean_to_json_string; break; case json_type_double: jso->_to_json_string = &json_object_double_to_json_string_default; break; case json_type_int: jso->_to_json_string = &json_object_int_to_json_string; break; case json_type_object: jso->_to_json_string = &json_object_object_to_json_string; break; case json_type_array: jso->_to_json_string = &json_object_array_to_json_string; break; case json_type_string: jso->_to_json_string = &json_object_string_to_json_string; break; } return; } jso->_to_json_string = to_string_func; } /* extended conversion to string */ const char *json_object_to_json_string_length(struct json_object *jso, int flags, size_t *length) { const char *r = NULL; size_t s = 0; if (!jso) { s = 4; r = "null"; } else if ((jso->_pb) || (jso->_pb = printbuf_new())) { printbuf_reset(jso->_pb); if (jso->_to_json_string(jso, jso->_pb, 0, flags) >= 0) { s = (size_t)jso->_pb->bpos; r = jso->_pb->buf; } } if (length) *length = s; return r; } const char *json_object_to_json_string_ext(struct json_object *jso, int flags) { return json_object_to_json_string_length(jso, flags, NULL); } /* backwards-compatible conversion to string */ const char *json_object_to_json_string(struct json_object *jso) { return json_object_to_json_string_ext(jso, JSON_C_TO_STRING_SPACED); } static void indent(struct printbuf *pb, int level, int flags) { if (flags & JSON_C_TO_STRING_PRETTY) { if (flags & JSON_C_TO_STRING_PRETTY_TAB) { printbuf_memset(pb, -1, '\t', level); } else { printbuf_memset(pb, -1, ' ', level * 2); } } } /* json_object_object */ static int json_object_object_to_json_string(struct json_object *jso, struct printbuf *pb, int level, int flags) { int had_children = 0; struct json_object_iter iter; printbuf_strappend(pb, "{" /*}*/); json_object_object_foreachC(jso, iter) { if (had_children) { printbuf_strappend(pb, ","); } if (flags & JSON_C_TO_STRING_PRETTY) printbuf_strappend(pb, "\n"); had_children = 1; if (flags & JSON_C_TO_STRING_SPACED && !(flags & JSON_C_TO_STRING_PRETTY)) printbuf_strappend(pb, " "); indent(pb, level + 1, flags); if (flags & JSON_C_TO_STRING_COLOR) printbuf_strappend(pb, ANSI_COLOR_FG_BLUE); printbuf_strappend(pb, "\""); json_escape_str(pb, iter.key, strlen(iter.key), flags); printbuf_strappend(pb, "\""); if (flags & JSON_C_TO_STRING_COLOR) printbuf_strappend(pb, ANSI_COLOR_RESET); if (flags & JSON_C_TO_STRING_SPACED) printbuf_strappend(pb, ": "); else printbuf_strappend(pb, ":"); if (iter.val == NULL) { if (flags & JSON_C_TO_STRING_COLOR) printbuf_strappend(pb, ANSI_COLOR_FG_MAGENTA); printbuf_strappend(pb, "null"); if (flags & JSON_C_TO_STRING_COLOR) printbuf_strappend(pb, ANSI_COLOR_RESET); } else if (iter.val->_to_json_string(iter.val, pb, level + 1, flags) < 0) return -1; } if ((flags & JSON_C_TO_STRING_PRETTY) && had_children) { printbuf_strappend(pb, "\n"); indent(pb, level, flags); } if (flags & JSON_C_TO_STRING_SPACED && !(flags & JSON_C_TO_STRING_PRETTY)) return printbuf_strappend(pb, /*{*/ " }"); else return printbuf_strappend(pb, /*{*/ "}"); } static void json_object_lh_entry_free(struct lh_entry *ent) { if (!lh_entry_k_is_constant(ent)) free(lh_entry_k(ent)); json_object_put((struct json_object *)lh_entry_v(ent)); } static void json_object_object_delete(struct json_object *jso_base) { lh_table_free(JC_OBJECT(jso_base)->c_object); json_object_generic_delete(jso_base); } struct json_object *json_object_new_object(void) { struct json_object_object *jso = JSON_OBJECT_NEW(object); if (!jso) return NULL; jso->c_object = lh_kchar_table_new(JSON_OBJECT_DEF_HASH_ENTRIES, &json_object_lh_entry_free); if (!jso->c_object) { json_object_generic_delete(&jso->base); errno = ENOMEM; return NULL; } return &jso->base; } struct lh_table *json_object_get_object(const struct json_object *jso) { if (!jso) return NULL; switch (jso->o_type) { case json_type_object: return JC_OBJECT_C(jso)->c_object; default: return NULL; } } int json_object_object_add_ex(struct json_object *jso, const char *const key, struct json_object *const val, const unsigned opts) { struct json_object *existing_value = NULL; struct lh_entry *existing_entry; unsigned long hash; assert(json_object_get_type(jso) == json_type_object); // We lookup the entry and replace the value, rather than just deleting // and re-adding it, so the existing key remains valid. hash = lh_get_hash(JC_OBJECT(jso)->c_object, (const void *)key); existing_entry = (opts & JSON_C_OBJECT_ADD_KEY_IS_NEW) ? NULL : lh_table_lookup_entry_w_hash(JC_OBJECT(jso)->c_object, (const void *)key, hash); // The caller must avoid creating loops in the object tree, but do a // quick check anyway to make sure we're not creating a trivial loop. if (jso == val) return -1; if (!existing_entry) { const void *const k = (opts & JSON_C_OBJECT_ADD_CONSTANT_KEY) ? (const void *)key : strdup(key); if (k == NULL) return -1; return lh_table_insert_w_hash(JC_OBJECT(jso)->c_object, k, val, hash, opts); } existing_value = (json_object *)lh_entry_v(existing_entry); if (existing_value) json_object_put(existing_value); lh_entry_set_val(existing_entry, val); return 0; } int json_object_object_add(struct json_object *jso, const char *key, struct json_object *val) { return json_object_object_add_ex(jso, key, val, 0); } int json_object_object_length(const struct json_object *jso) { assert(json_object_get_type(jso) == json_type_object); return lh_table_length(JC_OBJECT_C(jso)->c_object); } size_t json_c_object_sizeof(void) { return sizeof(struct json_object); } struct json_object *json_object_object_get(const struct json_object *jso, const char *key) { struct json_object *result = NULL; json_object_object_get_ex(jso, key, &result); return result; } json_bool json_object_object_get_ex(const struct json_object *jso, const char *key, struct json_object **value) { if (value != NULL) *value = NULL; if (NULL == jso) return 0; switch (jso->o_type) { case json_type_object: return lh_table_lookup_ex(JC_OBJECT_C(jso)->c_object, (const void *)key, (void **)value); default: if (value != NULL) *value = NULL; return 0; } } void json_object_object_del(struct json_object *jso, const char *key) { assert(json_object_get_type(jso) == json_type_object); lh_table_delete(JC_OBJECT(jso)->c_object, key); } /* json_object_boolean */ static int json_object_boolean_to_json_string(struct json_object *jso, struct printbuf *pb, int level, int flags) { int ret; if (flags & JSON_C_TO_STRING_COLOR) printbuf_strappend(pb, ANSI_COLOR_FG_MAGENTA); if (JC_BOOL(jso)->c_boolean) ret = printbuf_strappend(pb, "true"); else ret = printbuf_strappend(pb, "false"); if (ret > -1 && flags & JSON_C_TO_STRING_COLOR) return printbuf_strappend(pb, ANSI_COLOR_RESET); return ret; } struct json_object *json_object_new_boolean(json_bool b) { struct json_object_boolean *jso = JSON_OBJECT_NEW(boolean); if (!jso) return NULL; jso->c_boolean = b; return &jso->base; } json_bool json_object_get_boolean(const struct json_object *jso) { if (!jso) return 0; switch (jso->o_type) { case json_type_boolean: return JC_BOOL_C(jso)->c_boolean; case json_type_int: switch (JC_INT_C(jso)->cint_type) { case json_object_int_type_int64: return (JC_INT_C(jso)->cint.c_int64 != 0); case json_object_int_type_uint64: return (JC_INT_C(jso)->cint.c_uint64 != 0); default: json_abort("invalid cint_type"); } case json_type_double: return (JC_DOUBLE_C(jso)->c_double != 0); case json_type_string: return (JC_STRING_C(jso)->len != 0); default: return 0; } } int json_object_set_boolean(struct json_object *jso, json_bool new_value) { if (!jso || jso->o_type != json_type_boolean) return 0; JC_BOOL(jso)->c_boolean = new_value; return 1; } /* json_object_int */ static int json_object_int_to_json_string(struct json_object *jso, struct printbuf *pb, int level, int flags) { /* room for 19 digits, the sign char, and a null term */ char sbuf[21]; if (JC_INT(jso)->cint_type == json_object_int_type_int64) snprintf(sbuf, sizeof(sbuf), "%" PRId64, JC_INT(jso)->cint.c_int64); else snprintf(sbuf, sizeof(sbuf), "%" PRIu64, JC_INT(jso)->cint.c_uint64); return printbuf_memappend(pb, sbuf, strlen(sbuf)); } struct json_object *json_object_new_int(int32_t i) { return json_object_new_int64(i); } int32_t json_object_get_int(const struct json_object *jso) { int64_t cint64 = 0; double cdouble; enum json_type o_type; if (!jso) return 0; o_type = jso->o_type; if (o_type == json_type_int) { const struct json_object_int *jsoint = JC_INT_C(jso); if (jsoint->cint_type == json_object_int_type_int64) { cint64 = jsoint->cint.c_int64; } else { if (jsoint->cint.c_uint64 >= INT64_MAX) cint64 = INT64_MAX; else cint64 = (int64_t)jsoint->cint.c_uint64; } } else if (o_type == json_type_string) { /* * Parse strings into 64-bit numbers, then use the * 64-to-32-bit number handling below. */ if (json_parse_int64(get_string_component(jso), &cint64) != 0) return 0; /* whoops, it didn't work. */ o_type = json_type_int; } switch (o_type) { case json_type_int: /* Make sure we return the correct values for out of range numbers. */ if (cint64 <= INT32_MIN) return INT32_MIN; if (cint64 >= INT32_MAX) return INT32_MAX; return (int32_t)cint64; case json_type_double: cdouble = JC_DOUBLE_C(jso)->c_double; if (cdouble <= INT32_MIN) return INT32_MIN; if (cdouble >= INT32_MAX) return INT32_MAX; return (int32_t)cdouble; case json_type_boolean: return JC_BOOL_C(jso)->c_boolean; default: return 0; } } int json_object_set_int(struct json_object *jso, int new_value) { return json_object_set_int64(jso, (int64_t)new_value); } struct json_object *json_object_new_int64(int64_t i) { struct json_object_int *jso = JSON_OBJECT_NEW(int); if (!jso) return NULL; jso->cint.c_int64 = i; jso->cint_type = json_object_int_type_int64; return &jso->base; } struct json_object *json_object_new_uint64(uint64_t i) { struct json_object_int *jso = JSON_OBJECT_NEW(int); if (!jso) return NULL; jso->cint.c_uint64 = i; jso->cint_type = json_object_int_type_uint64; return &jso->base; } int64_t json_object_get_int64(const struct json_object *jso) { int64_t cint; if (!jso) return 0; switch (jso->o_type) { case json_type_int: { const struct json_object_int *jsoint = JC_INT_C(jso); switch (jsoint->cint_type) { case json_object_int_type_int64: return jsoint->cint.c_int64; case json_object_int_type_uint64: if (jsoint->cint.c_uint64 >= INT64_MAX) return INT64_MAX; return (int64_t)jsoint->cint.c_uint64; default: json_abort("invalid cint_type"); } } case json_type_double: // INT64_MAX can't be exactly represented as a double // so cast to tell the compiler it's ok to round up. if (JC_DOUBLE_C(jso)->c_double >= (double)INT64_MAX) return INT64_MAX; if (JC_DOUBLE_C(jso)->c_double <= INT64_MIN) return INT64_MIN; return (int64_t)JC_DOUBLE_C(jso)->c_double; case json_type_boolean: return JC_BOOL_C(jso)->c_boolean; case json_type_string: if (json_parse_int64(get_string_component(jso), &cint) == 0) return cint; /* FALLTHRU */ default: return 0; } } uint64_t json_object_get_uint64(const struct json_object *jso) { uint64_t cuint; if (!jso) return 0; switch (jso->o_type) { case json_type_int: { const struct json_object_int *jsoint = JC_INT_C(jso); switch (jsoint->cint_type) { case json_object_int_type_int64: if (jsoint->cint.c_int64 < 0) return 0; return (uint64_t)jsoint->cint.c_int64; case json_object_int_type_uint64: return jsoint->cint.c_uint64; default: json_abort("invalid cint_type"); } } case json_type_double: // UINT64_MAX can't be exactly represented as a double // so cast to tell the compiler it's ok to round up. if (JC_DOUBLE_C(jso)->c_double >= (double)UINT64_MAX) return UINT64_MAX; if (JC_DOUBLE_C(jso)->c_double < 0) return 0; return (uint64_t)JC_DOUBLE_C(jso)->c_double; case json_type_boolean: return JC_BOOL_C(jso)->c_boolean; case json_type_string: if (json_parse_uint64(get_string_component(jso), &cuint) == 0) return cuint; /* FALLTHRU */ default: return 0; } } int json_object_set_int64(struct json_object *jso, int64_t new_value) { if (!jso || jso->o_type != json_type_int) return 0; JC_INT(jso)->cint.c_int64 = new_value; JC_INT(jso)->cint_type = json_object_int_type_int64; return 1; } int json_object_set_uint64(struct json_object *jso, uint64_t new_value) { if (!jso || jso->o_type != json_type_int) return 0; JC_INT(jso)->cint.c_uint64 = new_value; JC_INT(jso)->cint_type = json_object_int_type_uint64; return 1; } int json_object_int_inc(struct json_object *jso, int64_t val) { struct json_object_int *jsoint; if (!jso || jso->o_type != json_type_int) return 0; jsoint = JC_INT(jso); switch (jsoint->cint_type) { case json_object_int_type_int64: if (val > 0 && jsoint->cint.c_int64 > INT64_MAX - val) { jsoint->cint.c_uint64 = (uint64_t)jsoint->cint.c_int64 + (uint64_t)val; jsoint->cint_type = json_object_int_type_uint64; } else if (val < 0 && jsoint->cint.c_int64 < INT64_MIN - val) { jsoint->cint.c_int64 = INT64_MIN; } else { jsoint->cint.c_int64 += val; } return 1; case json_object_int_type_uint64: if (val > 0 && jsoint->cint.c_uint64 > UINT64_MAX - (uint64_t)val) { jsoint->cint.c_uint64 = UINT64_MAX; } else if (val < 0 && jsoint->cint.c_uint64 < (uint64_t)(-val)) { jsoint->cint.c_int64 = (int64_t)jsoint->cint.c_uint64 + val; jsoint->cint_type = json_object_int_type_int64; } else if (val < 0 && jsoint->cint.c_uint64 >= (uint64_t)(-val)) { jsoint->cint.c_uint64 -= (uint64_t)(-val); } else { jsoint->cint.c_uint64 += val; } return 1; default: json_abort("invalid cint_type"); } } /* json_object_double */ #if defined(HAVE___THREAD) // i.e. __thread or __declspec(thread) static SPEC___THREAD char *tls_serialization_float_format = NULL; #endif static char *global_serialization_float_format = NULL; int json_c_set_serialization_double_format(const char *double_format, int global_or_thread) { if (global_or_thread == JSON_C_OPTION_GLOBAL) { #if defined(HAVE___THREAD) if (tls_serialization_float_format) { free(tls_serialization_float_format); tls_serialization_float_format = NULL; } #endif if (global_serialization_float_format) free(global_serialization_float_format); if (double_format) { char *p = strdup(double_format); if (p == NULL) { _json_c_set_last_err("json_c_set_serialization_double_format: " "out of memory\n"); return -1; } global_serialization_float_format = p; } else { global_serialization_float_format = NULL; } } else if (global_or_thread == JSON_C_OPTION_THREAD) { #if defined(HAVE___THREAD) if (tls_serialization_float_format) { free(tls_serialization_float_format); tls_serialization_float_format = NULL; } if (double_format) { char *p = strdup(double_format); if (p == NULL) { _json_c_set_last_err("json_c_set_serialization_double_format: " "out of memory\n"); return -1; } tls_serialization_float_format = p; } else { tls_serialization_float_format = NULL; } #else _json_c_set_last_err("json_c_set_serialization_double_format: not compiled " "with __thread support\n"); return -1; #endif } else { _json_c_set_last_err("json_c_set_serialization_double_format: invalid " "global_or_thread value: %d\n", global_or_thread); return -1; } return 0; } static int json_object_double_to_json_string_format(struct json_object *jso, struct printbuf *pb, int level, int flags, const char *format) { struct json_object_double *jsodbl = JC_DOUBLE(jso); char buf[128], *p, *q; int size; /* Although JSON RFC does not support * NaN or Infinity as numeric values * ECMA 262 section 9.8.1 defines * how to handle these cases as strings */ if (isnan(jsodbl->c_double)) { size = snprintf(buf, sizeof(buf), "NaN"); } else if (isinf(jsodbl->c_double)) { if (jsodbl->c_double > 0) size = snprintf(buf, sizeof(buf), "Infinity"); else size = snprintf(buf, sizeof(buf), "-Infinity"); } else { const char *std_format = "%.17g"; int format_drops_decimals = 0; int looks_numeric = 0; if (!format) { #if defined(HAVE___THREAD) if (tls_serialization_float_format) format = tls_serialization_float_format; else #endif if (global_serialization_float_format) format = global_serialization_float_format; else format = std_format; } size = snprintf(buf, sizeof(buf), format, jsodbl->c_double); if (size < 0) return -1; p = strchr(buf, ','); if (p) *p = '.'; else p = strchr(buf, '.'); if (format == std_format || strstr(format, ".0f") == NULL) format_drops_decimals = 1; looks_numeric = /* Looks like *some* kind of number */ is_plain_digit(buf[0]) || (size > 1 && buf[0] == '-' && is_plain_digit(buf[1])); if (size < (int)sizeof(buf) - 2 && looks_numeric && !p && /* Has no decimal point */ strchr(buf, 'e') == NULL && /* Not scientific notation */ format_drops_decimals) { // Ensure it looks like a float, even if snprintf didn't, // unless a custom format is set to omit the decimal. strcat(buf, ".0"); size += 2; } if (p && (flags & JSON_C_TO_STRING_NOZERO)) { /* last useful digit, always keep 1 zero */ p++; for (q = p; *q; q++) { if (*q != '0') p = q; } /* drop trailing zeroes */ if (*p != 0) *(++p) = 0; size = p - buf; } } // although unlikely, snprintf can fail if (size < 0) return -1; if (size >= (int)sizeof(buf)) // The standard formats are guaranteed not to overrun the buffer, // but if a custom one happens to do so, just silently truncate. size = sizeof(buf) - 1; printbuf_memappend(pb, buf, size); return size; } static int json_object_double_to_json_string_default(struct json_object *jso, struct printbuf *pb, int level, int flags) { return json_object_double_to_json_string_format(jso, pb, level, flags, NULL); } int json_object_double_to_json_string(struct json_object *jso, struct printbuf *pb, int level, int flags) { return json_object_double_to_json_string_format(jso, pb, level, flags, (const char *)jso->_userdata); } struct json_object *json_object_new_double(double d) { struct json_object_double *jso = JSON_OBJECT_NEW(double); if (!jso) return NULL; jso->base._to_json_string = &json_object_double_to_json_string_default; jso->c_double = d; return &jso->base; } struct json_object *json_object_new_double_s(double d, const char *ds) { char *new_ds; struct json_object *jso = json_object_new_double(d); if (!jso) return NULL; new_ds = strdup(ds); if (!new_ds) { json_object_generic_delete(jso); errno = ENOMEM; return NULL; } json_object_set_serializer(jso, _json_object_userdata_to_json_string, new_ds, json_object_free_userdata); return jso; } /* * A wrapper around json_object_userdata_to_json_string() used only * by json_object_new_double_s() just so json_object_set_double() can * detect when it needs to reset the serializer to the default. */ static int _json_object_userdata_to_json_string(struct json_object *jso, struct printbuf *pb, int level, int flags) { return json_object_userdata_to_json_string(jso, pb, level, flags); } int json_object_userdata_to_json_string(struct json_object *jso, struct printbuf *pb, int level, int flags) { int userdata_len = strlen((const char *)jso->_userdata); printbuf_memappend(pb, (const char *)jso->_userdata, userdata_len); return userdata_len; } void json_object_free_userdata(struct json_object *jso, void *userdata) { free(userdata); } double json_object_get_double(const struct json_object *jso) { double cdouble; char *errPtr = NULL; if (!jso) return 0.0; switch (jso->o_type) { case json_type_double: return JC_DOUBLE_C(jso)->c_double; case json_type_int: switch (JC_INT_C(jso)->cint_type) { case json_object_int_type_int64: return JC_INT_C(jso)->cint.c_int64; case json_object_int_type_uint64: return JC_INT_C(jso)->cint.c_uint64; default: json_abort("invalid cint_type"); } case json_type_boolean: return JC_BOOL_C(jso)->c_boolean; case json_type_string: errno = 0; cdouble = strtod(get_string_component(jso), &errPtr); /* if conversion stopped at the first character, return 0.0 */ if (errPtr == get_string_component(jso)) { errno = EINVAL; return 0.0; } /* * Check that the conversion terminated on something sensible * * For example, { "pay" : 123AB } would parse as 123. */ if (*errPtr != '\0') { errno = EINVAL; return 0.0; } /* * If strtod encounters a string which would exceed the * capacity of a double, it returns +/- HUGE_VAL and sets * errno to ERANGE. But +/- HUGE_VAL is also a valid result * from a conversion, so we need to check errno. * * Underflow also sets errno to ERANGE, but it returns 0 in * that case, which is what we will return anyway. * * See CERT guideline ERR30-C */ if ((HUGE_VAL == cdouble || -HUGE_VAL == cdouble) && (ERANGE == errno)) cdouble = 0.0; return cdouble; default: errno = EINVAL; return 0.0; } } int json_object_set_double(struct json_object *jso, double new_value) { if (!jso || jso->o_type != json_type_double) return 0; JC_DOUBLE(jso)->c_double = new_value; if (jso->_to_json_string == &_json_object_userdata_to_json_string) json_object_set_serializer(jso, NULL, NULL, NULL); return 1; } /* json_object_string */ static int json_object_string_to_json_string(struct json_object *jso, struct printbuf *pb, int level, int flags) { ssize_t len = JC_STRING(jso)->len; if (flags & JSON_C_TO_STRING_COLOR) printbuf_strappend(pb, ANSI_COLOR_FG_GREEN); printbuf_strappend(pb, "\""); json_escape_str(pb, get_string_component(jso), len < 0 ? -(ssize_t)len : len, flags); printbuf_strappend(pb, "\""); if (flags & JSON_C_TO_STRING_COLOR) printbuf_strappend(pb, ANSI_COLOR_RESET); return 0; } static void json_object_string_delete(struct json_object *jso) { if (JC_STRING(jso)->len < 0) free(JC_STRING(jso)->c_string.pdata); json_object_generic_delete(jso); } static struct json_object *_json_object_new_string(const char *s, const size_t len) { size_t objsize; struct json_object_string *jso; /* * Structures Actual memory layout * ------------------- -------------------- * [json_object_string [json_object_string * [json_object] [json_object] * ...other fields... ...other fields... * c_string] len * bytes * of * string * data * \0] */ if (len > (SSIZE_T_MAX - (sizeof(*jso) - sizeof(jso->c_string)) - 1)) return NULL; objsize = (sizeof(*jso) - sizeof(jso->c_string)) + len + 1; if (len < sizeof(void *)) // We need a minimum size to support json_object_set_string() mutability // so we can stuff a pointer into pdata :( objsize += sizeof(void *) - len; jso = (struct json_object_string *)json_object_new(json_type_string, objsize, &json_object_string_to_json_string); if (!jso) return NULL; jso->len = len; memcpy(jso->c_string.idata, s, len); // Cast below needed for Clang UB sanitizer ((char *)jso->c_string.idata)[len] = '\0'; return &jso->base; } struct json_object *json_object_new_string(const char *s) { return _json_object_new_string(s, strlen(s)); } struct json_object *json_object_new_string_len(const char *s, const int len) { return _json_object_new_string(s, len); } const char *json_object_get_string(struct json_object *jso) { if (!jso) return NULL; switch (jso->o_type) { case json_type_string: return get_string_component(jso); default: return json_object_to_json_string(jso); } } static inline ssize_t _json_object_get_string_len(const struct json_object_string *jso) { ssize_t len; len = jso->len; return (len < 0) ? -(ssize_t)len : len; } int json_object_get_string_len(const struct json_object *jso) { if (!jso) return 0; switch (jso->o_type) { case json_type_string: return _json_object_get_string_len(JC_STRING_C(jso)); default: return 0; } } static int _json_object_set_string_len(json_object *jso, const char *s, size_t len) { char *dstbuf; ssize_t curlen; ssize_t newlen; if (jso == NULL || jso->o_type != json_type_string) return 0; if (len >= INT_MAX - 1) // jso->len is a signed ssize_t, so it can't hold the // full size_t range. json_object_get_string_len returns // length as int, cap length at INT_MAX. return 0; curlen = JC_STRING(jso)->len; if (curlen < 0) { if (len == 0) { free(JC_STRING(jso)->c_string.pdata); JC_STRING(jso)->len = curlen = 0; } else { curlen = -curlen; } } newlen = len; dstbuf = get_string_component_mutable(jso); if ((ssize_t)len > curlen) { // We have no way to return the new ptr from realloc(jso, newlen) // and we have no way of knowing whether there's extra room available // so we need to stuff a pointer in to pdata :( dstbuf = (char *)malloc(len + 1); if (dstbuf == NULL) return 0; if (JC_STRING(jso)->len < 0) free(JC_STRING(jso)->c_string.pdata); JC_STRING(jso)->c_string.pdata = dstbuf; newlen = -(ssize_t)len; } else if (JC_STRING(jso)->len < 0) { // We've got enough room in the separate allocated buffer, // so use it as-is and continue to indicate that pdata is used. newlen = -(ssize_t)len; } memcpy(dstbuf, (const void *)s, len); dstbuf[len] = '\0'; JC_STRING(jso)->len = newlen; return 1; } int json_object_set_string(json_object *jso, const char *s) { return _json_object_set_string_len(jso, s, strlen(s)); } int json_object_set_string_len(json_object *jso, const char *s, int len) { return _json_object_set_string_len(jso, s, len); } /* json_object_array */ static int json_object_array_to_json_string(struct json_object *jso, struct printbuf *pb, int level, int flags) { int had_children = 0; size_t ii; printbuf_strappend(pb, "["); for (ii = 0; ii < json_object_array_length(jso); ii++) { struct json_object *val; if (had_children) { printbuf_strappend(pb, ","); } if (flags & JSON_C_TO_STRING_PRETTY) printbuf_strappend(pb, "\n"); had_children = 1; if (flags & JSON_C_TO_STRING_SPACED && !(flags & JSON_C_TO_STRING_PRETTY)) printbuf_strappend(pb, " "); indent(pb, level + 1, flags); val = json_object_array_get_idx(jso, ii); if (val == NULL) { if (flags & JSON_C_TO_STRING_COLOR) printbuf_strappend(pb, ANSI_COLOR_FG_MAGENTA); printbuf_strappend(pb, "null"); if (flags & JSON_C_TO_STRING_COLOR) printbuf_strappend(pb, ANSI_COLOR_RESET); } else if (val->_to_json_string(val, pb, level + 1, flags) < 0) return -1; } if ((flags & JSON_C_TO_STRING_PRETTY) && had_children) { printbuf_strappend(pb, "\n"); indent(pb, level, flags); } if (flags & JSON_C_TO_STRING_SPACED && !(flags & JSON_C_TO_STRING_PRETTY)) return printbuf_strappend(pb, " ]"); return printbuf_strappend(pb, "]"); } static void json_object_array_entry_free(void *data) { json_object_put((struct json_object *)data); } static void json_object_array_delete(struct json_object *jso) { array_list_free(JC_ARRAY(jso)->c_array); json_object_generic_delete(jso); } struct json_object *json_object_new_array(void) { return json_object_new_array_ext(ARRAY_LIST_DEFAULT_SIZE); } struct json_object *json_object_new_array_ext(int initial_size) { struct json_object_array *jso = JSON_OBJECT_NEW(array); if (!jso) return NULL; jso->c_array = array_list_new2(&json_object_array_entry_free, initial_size); if (jso->c_array == NULL) { free(jso); return NULL; } return &jso->base; } struct array_list *json_object_get_array(const struct json_object *jso) { if (!jso) return NULL; switch (jso->o_type) { case json_type_array: return JC_ARRAY_C(jso)->c_array; default: return NULL; } } void json_object_array_sort(struct json_object *jso, int (*sort_fn)(const void *, const void *)) { assert(json_object_get_type(jso) == json_type_array); array_list_sort(JC_ARRAY(jso)->c_array, sort_fn); } struct json_object *json_object_array_bsearch(const struct json_object *key, const struct json_object *jso, int (*sort_fn)(const void *, const void *)) { struct json_object **result; assert(json_object_get_type(jso) == json_type_array); result = (struct json_object **)array_list_bsearch((const void **)(void *)&key, JC_ARRAY_C(jso)->c_array, sort_fn); if (!result) return NULL; return *result; } size_t json_object_array_length(const struct json_object *jso) { assert(json_object_get_type(jso) == json_type_array); return array_list_length(JC_ARRAY_C(jso)->c_array); } int json_object_array_add(struct json_object *jso, struct json_object *val) { assert(json_object_get_type(jso) == json_type_array); return array_list_add(JC_ARRAY(jso)->c_array, val); } int json_object_array_insert_idx(struct json_object *jso, size_t idx, struct json_object *val) { assert(json_object_get_type(jso) == json_type_array); return array_list_insert_idx(JC_ARRAY(jso)->c_array, idx, val); } int json_object_array_put_idx(struct json_object *jso, size_t idx, struct json_object *val) { assert(json_object_get_type(jso) == json_type_array); return array_list_put_idx(JC_ARRAY(jso)->c_array, idx, val); } int json_object_array_del_idx(struct json_object *jso, size_t idx, size_t count) { assert(json_object_get_type(jso) == json_type_array); return array_list_del_idx(JC_ARRAY(jso)->c_array, idx, count); } struct json_object *json_object_array_get_idx(const struct json_object *jso, size_t idx) { assert(json_object_get_type(jso) == json_type_array); return (struct json_object *)array_list_get_idx(JC_ARRAY_C(jso)->c_array, idx); } static int json_array_equal(struct json_object *jso1, struct json_object *jso2) { size_t len, i; len = json_object_array_length(jso1); if (len != json_object_array_length(jso2)) return 0; for (i = 0; i < len; i++) { if (!json_object_equal(json_object_array_get_idx(jso1, i), json_object_array_get_idx(jso2, i))) return 0; } return 1; } int json_object_array_shrink(struct json_object *jso, int empty_slots) { if (empty_slots < 0) json_abort("json_object_array_shrink called with negative empty_slots"); return array_list_shrink(JC_ARRAY(jso)->c_array, empty_slots); } struct json_object *json_object_new_null(void) { return NULL; } static int json_object_all_values_equal(struct json_object *jso1, struct json_object *jso2) { struct json_object_iter iter; struct json_object *sub; assert(json_object_get_type(jso1) == json_type_object); assert(json_object_get_type(jso2) == json_type_object); /* Iterate over jso1 keys and see if they exist and are equal in jso2 */ json_object_object_foreachC(jso1, iter) { if (!lh_table_lookup_ex(JC_OBJECT(jso2)->c_object, (void *)iter.key, (void **)(void *)&sub)) return 0; if (!json_object_equal(iter.val, sub)) return 0; } /* Iterate over jso2 keys to see if any exist that are not in jso1 */ json_object_object_foreachC(jso2, iter) { if (!lh_table_lookup_ex(JC_OBJECT(jso1)->c_object, (void *)iter.key, (void **)(void *)&sub)) return 0; } return 1; } int json_object_equal(struct json_object *jso1, struct json_object *jso2) { if (jso1 == jso2) return 1; if (!jso1 || !jso2) return 0; if (jso1->o_type != jso2->o_type) return 0; switch (jso1->o_type) { case json_type_boolean: return (JC_BOOL(jso1)->c_boolean == JC_BOOL(jso2)->c_boolean); case json_type_double: return (JC_DOUBLE(jso1)->c_double == JC_DOUBLE(jso2)->c_double); case json_type_int: { struct json_object_int *int1 = JC_INT(jso1); struct json_object_int *int2 = JC_INT(jso2); if (int1->cint_type == json_object_int_type_int64) { if (int2->cint_type == json_object_int_type_int64) return (int1->cint.c_int64 == int2->cint.c_int64); if (int1->cint.c_int64 < 0) return 0; return ((uint64_t)int1->cint.c_int64 == int2->cint.c_uint64); } // else jso1 is a uint64 if (int2->cint_type == json_object_int_type_uint64) return (int1->cint.c_uint64 == int2->cint.c_uint64); if (int2->cint.c_int64 < 0) return 0; return (int1->cint.c_uint64 == (uint64_t)int2->cint.c_int64); } case json_type_string: { return (_json_object_get_string_len(JC_STRING(jso1)) == _json_object_get_string_len(JC_STRING(jso2)) && memcmp(get_string_component(jso1), get_string_component(jso2), _json_object_get_string_len(JC_STRING(jso1))) == 0); } case json_type_object: return json_object_all_values_equal(jso1, jso2); case json_type_array: return json_array_equal(jso1, jso2); case json_type_null: return 1; }; return 0; } static int json_object_copy_serializer_data(struct json_object *src, struct json_object *dst) { if (!src->_userdata && !src->_user_delete) return 0; if (dst->_to_json_string == json_object_userdata_to_json_string || dst->_to_json_string == _json_object_userdata_to_json_string) { char *p; assert(src->_userdata); p = strdup(src->_userdata); if (p == NULL) { _json_c_set_last_err("json_object_copy_serializer_data: out of memory\n"); return -1; } dst->_userdata = p; } // else if ... other supported serializers ... else { _json_c_set_last_err( "json_object_copy_serializer_data: unable to copy unknown serializer data: " "%p\n", (void *)dst->_to_json_string); return -1; } dst->_user_delete = src->_user_delete; return 0; } /** * The default shallow copy implementation. Simply creates a new object of the same * type but does *not* copy over _userdata nor retain any custom serializer. * If custom serializers are in use, json_object_deep_copy() must be passed a shallow copy * implementation that is aware of how to copy them. * * This always returns -1 or 1. It will never return 2 since it does not copy the serializer. */ int json_c_shallow_copy_default(json_object *src, json_object *parent, const char *key, size_t index, json_object **dst) { switch (src->o_type) { case json_type_boolean: *dst = json_object_new_boolean(JC_BOOL(src)->c_boolean); break; case json_type_double: *dst = json_object_new_double(JC_DOUBLE(src)->c_double); break; case json_type_int: switch (JC_INT(src)->cint_type) { case json_object_int_type_int64: *dst = json_object_new_int64(JC_INT(src)->cint.c_int64); break; case json_object_int_type_uint64: *dst = json_object_new_uint64(JC_INT(src)->cint.c_uint64); break; default: json_abort("invalid cint_type"); } break; case json_type_string: *dst = json_object_new_string_len(get_string_component(src), _json_object_get_string_len(JC_STRING(src))); break; case json_type_object: *dst = json_object_new_object(); break; case json_type_array: *dst = json_object_new_array(); break; default: errno = EINVAL; return -1; } if (!*dst) { errno = ENOMEM; return -1; } (*dst)->_to_json_string = src->_to_json_string; // _userdata and _user_delete are copied later return 1; } /* * The actual guts of json_object_deep_copy(), with a few additional args * needed so we can keep track of where we are within the object tree. * * Note: caller is responsible for freeing *dst if this fails and returns -1. */ static int json_object_deep_copy_recursive(struct json_object *src, struct json_object *parent, const char *key_in_parent, size_t index_in_parent, struct json_object **dst, json_c_shallow_copy_fn *shallow_copy) { struct json_object_iter iter; size_t src_array_len, ii; int shallow_copy_rc = 0; shallow_copy_rc = shallow_copy(src, parent, key_in_parent, index_in_parent, dst); /* -1=error, 1=object created ok, 2=userdata set */ if (shallow_copy_rc < 1) { errno = EINVAL; return -1; } assert(*dst != NULL); switch (src->o_type) { case json_type_object: json_object_object_foreachC(src, iter) { struct json_object *jso = NULL; /* This handles the `json_type_null` case */ if (!iter.val) jso = NULL; else if (json_object_deep_copy_recursive(iter.val, src, iter.key, UINT_MAX, &jso, shallow_copy) < 0) { json_object_put(jso); return -1; } if (json_object_object_add(*dst, iter.key, jso) < 0) { json_object_put(jso); return -1; } } break; case json_type_array: src_array_len = json_object_array_length(src); for (ii = 0; ii < src_array_len; ii++) { struct json_object *jso = NULL; struct json_object *jso1 = json_object_array_get_idx(src, ii); /* This handles the `json_type_null` case */ if (!jso1) jso = NULL; else if (json_object_deep_copy_recursive(jso1, src, NULL, ii, &jso, shallow_copy) < 0) { json_object_put(jso); return -1; } if (json_object_array_add(*dst, jso) < 0) { json_object_put(jso); return -1; } } break; default: break; /* else, nothing to do, shallow_copy already did. */ } if (shallow_copy_rc != 2) return json_object_copy_serializer_data(src, *dst); return 0; } int json_object_deep_copy(struct json_object *src, struct json_object **dst, json_c_shallow_copy_fn *shallow_copy) { int rc; /* Check if arguments are sane ; *dst must not point to a non-NULL object */ if (!src || !dst || *dst) { errno = EINVAL; return -1; } if (shallow_copy == NULL) shallow_copy = json_c_shallow_copy_default; rc = json_object_deep_copy_recursive(src, NULL, NULL, UINT_MAX, dst, shallow_copy); if (rc < 0) { json_object_put(*dst); *dst = NULL; } return rc; } static void json_abort(const char *message) { if (message != NULL) fprintf(stderr, "json-c aborts with error: %s\n", message); abort(); } json-c-json-c-0.17-20230812/json_object.h000066400000000000000000001267441446575330000174150ustar00rootroot00000000000000/* * $Id: json_object.h,v 1.12 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * Copyright (c) 2009 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Core json-c API. Start here, or with json_tokener.h */ #ifndef _json_object_h_ #define _json_object_h_ #ifdef __GNUC__ #define JSON_C_CONST_FUNCTION(func) func __attribute__((const)) #else #define JSON_C_CONST_FUNCTION(func) func #endif #include "json_inttypes.h" #include "json_types.h" #include "printbuf.h" #include #ifdef __cplusplus extern "C" { #endif #define JSON_OBJECT_DEF_HASH_ENTRIES 16 /** * A flag for the json_object_to_json_string_ext() and * json_object_to_file_ext() functions which causes the output * to have no extra whitespace or formatting applied. */ #define JSON_C_TO_STRING_PLAIN 0 /** * A flag for the json_object_to_json_string_ext() and * json_object_to_file_ext() functions which causes the output to have * minimal whitespace inserted to make things slightly more readable. */ #define JSON_C_TO_STRING_SPACED (1 << 0) /** * A flag for the json_object_to_json_string_ext() and * json_object_to_file_ext() functions which causes * the output to be formatted. * * See the "Two Space Tab" option at https://jsonformatter.curiousconcept.com/ * for an example of the format. */ #define JSON_C_TO_STRING_PRETTY (1 << 1) /** * A flag for the json_object_to_json_string_ext() and * json_object_to_file_ext() functions which causes * the output to be formatted. * * Instead of a "Two Space Tab" this gives a single tab character. */ #define JSON_C_TO_STRING_PRETTY_TAB (1 << 3) /** * A flag to drop trailing zero for float values */ #define JSON_C_TO_STRING_NOZERO (1 << 2) /** * Don't escape forward slashes. */ #define JSON_C_TO_STRING_NOSLASHESCAPE (1 << 4) /** * A flag for the json_object_to_json_string_ext() and * json_object_to_file_ext() functions which causes * the output to be formatted. * * Use color for printing json. */ #define JSON_C_TO_STRING_COLOR (1 << 5) /** * A flag for the json_object_object_add_ex function which * causes the value to be added without a check if it already exists. * Note: it is the responsibility of the caller to ensure that no * key is added multiple times. If this is done, results are * unpredictable. While this option is somewhat dangerous, it * permits potentially large performance savings in code that * knows for sure the key values are unique (e.g. because the * code adds a well-known set of constant key values). */ #define JSON_C_OBJECT_ADD_KEY_IS_NEW (1 << 1) /** * A flag for the json_object_object_add_ex function which * flags the key as being constant memory. This means that * the key will NOT be copied via strdup(), resulting in a * potentially huge performance win (malloc, strdup and * free are usually performance hogs). It is acceptable to * use this flag for keys in non-constant memory blocks if * the caller ensure that the memory holding the key lives * longer than the corresponding json object. However, this * is somewhat dangerous and should only be done if really * justified. * The general use-case for this flag is cases where the * key is given as a real constant value in the function * call, e.g. as in * json_object_object_add_ex(obj, "ip", json, * JSON_C_OBJECT_ADD_CONSTANT_KEY); */ #define JSON_C_OBJECT_ADD_CONSTANT_KEY (1 << 2) /** * This flag is an alias to JSON_C_OBJECT_ADD_CONSTANT_KEY. * Historically, this flag was used first and the new name * JSON_C_OBJECT_ADD_CONSTANT_KEY was introduced for version * 0.16.00 in order to have regular naming. * Use of this flag is now legacy. */ #define JSON_C_OBJECT_KEY_IS_CONSTANT JSON_C_OBJECT_ADD_CONSTANT_KEY /** * Set the global value of an option, which will apply to all * current and future threads that have not set a thread-local value. * * @see json_c_set_serialization_double_format */ #define JSON_C_OPTION_GLOBAL (0) /** * Set a thread-local value of an option, overriding the global value. * This will fail if json-c is not compiled with threading enabled, and * with the __thread specifier (or equivalent) available. * * @see json_c_set_serialization_double_format */ #define JSON_C_OPTION_THREAD (1) /* reference counting functions */ /** * Increment the reference count of json_object, thereby taking ownership of it. * * Cases where you might need to increase the refcount include: * - Using an object field or array index (retrieved through * `json_object_object_get()` or `json_object_array_get_idx()`) * beyond the lifetime of the parent object. * - Detaching an object field or array index from its parent object * (using `json_object_object_del()` or `json_object_array_del_idx()`) * - Sharing a json_object with multiple (not necessarily parallel) threads * of execution that all expect to free it (with `json_object_put()`) when * they're done. * * @param obj the json_object instance * @see json_object_put() * @see json_object_object_get() * @see json_object_array_get_idx() */ JSON_EXPORT struct json_object *json_object_get(struct json_object *obj); /** * Decrement the reference count of json_object and free if it reaches zero. * * You must have ownership of obj prior to doing this or you will cause an * imbalance in the reference count, leading to a classic use-after-free bug. * In particular, you normally do not need to call `json_object_put()` on the * json_object returned by `json_object_object_get()` or `json_object_array_get_idx()`. * * Just like after calling `free()` on a block of memory, you must not use * `obj` after calling `json_object_put()` on it or any object that it * is a member of (unless you know you've called `json_object_get(obj)` to * explicitly increment the refcount). * * NULL may be passed, which which case this is a no-op. * * @param obj the json_object instance * @returns 1 if the object was freed. * @see json_object_get() */ JSON_EXPORT int json_object_put(struct json_object *obj); /** * Check if the json_object is of a given type * @param obj the json_object instance * @param type one of: json_type_null (i.e. obj == NULL), json_type_boolean, json_type_double, json_type_int, json_type_object, json_type_array, json_type_string */ JSON_EXPORT int json_object_is_type(const struct json_object *obj, enum json_type type); /** * Get the type of the json_object. See also json_type_to_name() to turn this * into a string suitable, for instance, for logging. * * @param obj the json_object instance * @returns type being one of: json_type_null (i.e. obj == NULL), json_type_boolean, json_type_double, json_type_int, json_type_object, json_type_array, json_type_string */ JSON_EXPORT enum json_type json_object_get_type(const struct json_object *obj); /** Stringify object to json format. * Equivalent to json_object_to_json_string_ext(obj, JSON_C_TO_STRING_SPACED) * The pointer you get is an internal of your json object. You don't * have to free it, later use of json_object_put() should be sufficient. * If you can not ensure there's no concurrent access to *obj use * strdup(). * @param obj the json_object instance * @returns a string in JSON format */ JSON_EXPORT const char *json_object_to_json_string(struct json_object *obj); /** Stringify object to json format * @see json_object_to_json_string() for details on how to free string. * @param obj the json_object instance * @param flags formatting options, see JSON_C_TO_STRING_PRETTY and other constants * @returns a string in JSON format */ JSON_EXPORT const char *json_object_to_json_string_ext(struct json_object *obj, int flags); /** Stringify object to json format * @see json_object_to_json_string() for details on how to free string. * @param obj the json_object instance * @param flags formatting options, see JSON_C_TO_STRING_PRETTY and other constants * @param length a pointer where, if not NULL, the length (without null) is stored * @returns a string in JSON format and the length if not NULL */ JSON_EXPORT const char *json_object_to_json_string_length(struct json_object *obj, int flags, size_t *length); /** * Returns the userdata set by json_object_set_userdata() or * json_object_set_serializer() * * @param jso the object to return the userdata for */ JSON_EXPORT void *json_object_get_userdata(json_object *jso); /** * Set an opaque userdata value for an object * * The userdata can be retrieved using json_object_get_userdata(). * * If custom userdata is already set on this object, any existing user_delete * function is called before the new one is set. * * The user_delete parameter is optional and may be passed as NULL, even if * the userdata parameter is non-NULL. It will be called just before the * json_object is deleted, after it's reference count goes to zero * (see json_object_put()). * If this is not provided, it is up to the caller to free the userdata at * an appropriate time. (i.e. after the json_object is deleted) * * Note: Objects created by parsing strings may have custom serializers set * which expect the userdata to contain specific data (due to use of * json_object_new_double_s()). In this case, json_object_set_serialiser() with * NULL as to_string_func should be used instead to set the userdata and reset * the serializer to its default value. * * @param jso the object to set the userdata for * @param userdata an optional opaque cookie * @param user_delete an optional function from freeing userdata */ JSON_EXPORT void json_object_set_userdata(json_object *jso, void *userdata, json_object_delete_fn *user_delete); /** * Set a custom serialization function to be used when this particular object * is converted to a string by json_object_to_json_string. * * If custom userdata is already set on this object, any existing user_delete * function is called before the new one is set. * * If to_string_func is NULL the default behaviour is reset (but the userdata * and user_delete fields are still set). * * The userdata parameter is optional and may be passed as NULL. It can be used * to provide additional data for to_string_func to use. This parameter may * be NULL even if user_delete is non-NULL. * * The user_delete parameter is optional and may be passed as NULL, even if * the userdata parameter is non-NULL. It will be called just before the * json_object is deleted, after it's reference count goes to zero * (see json_object_put()). * If this is not provided, it is up to the caller to free the userdata at * an appropriate time. (i.e. after the json_object is deleted) * * Note that the userdata is the same as set by json_object_set_userdata(), so * care must be taken not to overwrite the value when both a custom serializer * and json_object_set_userdata() are used. * * @param jso the object to customize * @param to_string_func the custom serialization function * @param userdata an optional opaque cookie * @param user_delete an optional function from freeing userdata */ JSON_EXPORT void json_object_set_serializer(json_object *jso, json_object_to_json_string_fn *to_string_func, void *userdata, json_object_delete_fn *user_delete); #ifdef __clang__ /* * Clang doesn't pay attention to the parameters defined in the * function typedefs used here, so turn off spurious doc warnings. * { */ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdocumentation" #endif /** * Simply call free on the userdata pointer. * Can be used with json_object_set_serializer(). * * @param jso unused * @param userdata the pointer that is passed to free(). */ JSON_EXPORT json_object_delete_fn json_object_free_userdata; /** * Copy the jso->_userdata string over to pb as-is. * Can be used with json_object_set_serializer(). * * @param jso The object whose _userdata is used. * @param pb The destination buffer. * @param level Ignored. * @param flags Ignored. */ JSON_EXPORT json_object_to_json_string_fn json_object_userdata_to_json_string; #ifdef __clang__ /* } */ #pragma clang diagnostic pop #endif /* object type methods */ /** Create a new empty object with a reference count of 1. The caller of * this object initially has sole ownership. Remember, when using * json_object_object_add or json_object_array_put_idx, ownership will * transfer to the object/array. Call json_object_get if you want to maintain * shared ownership or also add this object as a child of multiple objects or * arrays. Any ownerships you acquired but did not transfer must be released * through json_object_put. * * @returns a json_object of type json_type_object */ JSON_EXPORT struct json_object *json_object_new_object(void); /** Get the hashtable of a json_object of type json_type_object * @param obj the json_object instance * @returns a linkhash */ JSON_EXPORT struct lh_table *json_object_get_object(const struct json_object *obj); /** Get the size of an object in terms of the number of fields it has. * @param obj the json_object whose length to return */ JSON_EXPORT int json_object_object_length(const struct json_object *obj); /** Get the sizeof (struct json_object). * @returns a size_t with the sizeof (struct json_object) */ JSON_C_CONST_FUNCTION(JSON_EXPORT size_t json_c_object_sizeof(void)); /** Add an object field to a json_object of type json_type_object * * The reference count of `val` will *not* be incremented, in effect * transferring ownership that object to `obj`, and thus `val` will be * freed when `obj` is. (i.e. through `json_object_put(obj)`) * * If you want to retain a reference to the added object, independent * of the lifetime of obj, you must increment the refcount with * `json_object_get(val)` (and later release it with json_object_put()). * * Since ownership transfers to `obj`, you must make sure * that you do in fact have ownership over `val`. For instance, * json_object_new_object() will give you ownership until you transfer it, * whereas json_object_object_get() does not. * * Any previous object stored under `key` in `obj` will have its refcount * decremented, and be freed normally if that drops to zero. * * @param obj the json_object instance * @param key the object field name (a private copy will be duplicated) * @param val a json_object or NULL member to associate with the given field * * @return On success, 0 is returned. * On error, a negative value is returned. */ JSON_EXPORT int json_object_object_add(struct json_object *obj, const char *key, struct json_object *val); /** Add an object field to a json_object of type json_type_object * * The semantics are identical to json_object_object_add, except that an * additional flag fields gives you more control over some detail aspects * of processing. See the description of JSON_C_OBJECT_ADD_* flags for more * details. * * @param obj the json_object instance * @param key the object field name (a private copy will be duplicated) * @param val a json_object or NULL member to associate with the given field * @param opts process-modifying options. To specify multiple options, use * (OPT1|OPT2) */ JSON_EXPORT int json_object_object_add_ex(struct json_object *obj, const char *const key, struct json_object *const val, const unsigned opts); /** Get the json_object associate with a given object field. * Deprecated/discouraged: used json_object_object_get_ex instead. * * This returns NULL if the field is found but its value is null, or if * the field is not found, or if obj is not a json_type_object. If you * need to distinguish between these cases, use json_object_object_get_ex(). * * *No* reference counts will be changed. There is no need to manually adjust * reference counts through the json_object_put/json_object_get methods unless * you need to have the child (value) reference maintain a different lifetime * than the owning parent (obj). Ownership of the returned value is retained * by obj (do not do json_object_put unless you have done a json_object_get). * If you delete the value from obj (json_object_object_del) and wish to access * the returned reference afterwards, make sure you have first gotten shared * ownership through json_object_get (& don't forget to do a json_object_put * or transfer ownership to prevent a memory leak). * * @param obj the json_object instance * @param key the object field name * @returns the json_object associated with the given field name */ JSON_EXPORT struct json_object *json_object_object_get(const struct json_object *obj, const char *key); /** Get the json_object associated with a given object field. * * This returns true if the key is found, false in all other cases (including * if obj isn't a json_type_object). * * *No* reference counts will be changed. There is no need to manually adjust * reference counts through the json_object_put/json_object_get methods unless * you need to have the child (value) reference maintain a different lifetime * than the owning parent (obj). Ownership of value is retained by obj. * * @param obj the json_object instance * @param key the object field name * @param value a pointer where to store a reference to the json_object * associated with the given field name. * * It is safe to pass a NULL value. * @returns whether or not the key exists */ JSON_EXPORT json_bool json_object_object_get_ex(const struct json_object *obj, const char *key, struct json_object **value); /** Delete the given json_object field * * The reference count will be decremented for the deleted object. If there * are no more owners of the value represented by this key, then the value is * freed. Otherwise, the reference to the value will remain in memory. * * @param obj the json_object instance * @param key the object field name */ JSON_EXPORT void json_object_object_del(struct json_object *obj, const char *key); /** * Iterate through all keys and values of an object. * * Adding keys to the object while iterating is NOT allowed. * * Deleting an existing key, or replacing an existing key with a * new value IS allowed. * * @param obj the json_object instance * @param key the local name for the char* key variable defined in the body * @param val the local name for the json_object* object variable defined in * the body */ #if defined(__GNUC__) && !defined(__STRICT_ANSI__) && (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) #define json_object_object_foreach(obj, key, val) \ char *key = NULL; \ struct json_object *val __attribute__((__unused__)) = NULL; \ for (struct lh_entry *entry##key = lh_table_head(json_object_get_object(obj)), \ *entry_next##key = NULL; \ ({ \ if (entry##key) \ { \ key = (char *)lh_entry_k(entry##key); \ val = (struct json_object *)lh_entry_v(entry##key); \ entry_next##key = lh_entry_next(entry##key); \ }; \ entry##key; \ }); \ entry##key = entry_next##key) #else /* ANSI C or MSC */ #define json_object_object_foreach(obj, key, val) \ char *key = NULL; \ struct json_object *val = NULL; \ struct lh_entry *entry##key; \ struct lh_entry *entry_next##key = NULL; \ for (entry##key = lh_table_head(json_object_get_object(obj)); \ (entry##key ? (key = (char *)lh_entry_k(entry##key), \ val = (struct json_object *)lh_entry_v(entry##key), \ entry_next##key = lh_entry_next(entry##key), entry##key) \ : 0); \ entry##key = entry_next##key) #endif /* defined(__GNUC__) && !defined(__STRICT_ANSI__) && (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) */ /** Iterate through all keys and values of an object (ANSI C Safe) * @param obj the json_object instance * @param iter the object iterator, use type json_object_iter */ #define json_object_object_foreachC(obj, iter) \ for (iter.entry = lh_table_head(json_object_get_object(obj)); \ (iter.entry ? (iter.key = (char *)lh_entry_k(iter.entry), \ iter.val = (struct json_object *)lh_entry_v(iter.entry), iter.entry) \ : 0); \ iter.entry = lh_entry_next(iter.entry)) /* Array type methods */ /** Create a new empty json_object of type json_type_array * with 32 slots allocated. * If you know the array size you'll need ahead of time, use * json_object_new_array_ext() instead. * @see json_object_new_array_ext() * @see json_object_array_shrink() * @returns a json_object of type json_type_array */ JSON_EXPORT struct json_object *json_object_new_array(void); /** Create a new empty json_object of type json_type_array * with the desired number of slots allocated. * @see json_object_array_shrink() * @param initial_size the number of slots to allocate * @returns a json_object of type json_type_array */ JSON_EXPORT struct json_object *json_object_new_array_ext(int initial_size); /** Get the arraylist of a json_object of type json_type_array * @param obj the json_object instance * @returns an arraylist */ JSON_EXPORT struct array_list *json_object_get_array(const struct json_object *obj); /** Get the length of a json_object of type json_type_array * @param obj the json_object instance * @returns an int */ JSON_EXPORT size_t json_object_array_length(const struct json_object *obj); /** Sorts the elements of jso of type json_type_array * * Pointers to the json_object pointers will be passed as the two arguments * to sort_fn * * @param jso the json_object instance * @param sort_fn a sorting function */ JSON_EXPORT void json_object_array_sort(struct json_object *jso, int (*sort_fn)(const void *, const void *)); /** Binary search a sorted array for a specified key object. * * It depends on your compare function what's sufficient as a key. * Usually you create some dummy object with the parameter compared in * it, to identify the right item you're actually looking for. * * @see json_object_array_sort() for hints on the compare function. * * @param key a dummy json_object with the right key * @param jso the array object we're searching * @param sort_fn the sort/compare function * * @return the wanted json_object instance */ JSON_EXPORT struct json_object * json_object_array_bsearch(const struct json_object *key, const struct json_object *jso, int (*sort_fn)(const void *, const void *)); /** Add an element to the end of a json_object of type json_type_array * * The reference count will *not* be incremented. This is to make adding * fields to objects in code more compact. If you want to retain a reference * to an added object you must wrap the passed object with json_object_get * * @param obj the json_object instance * @param val the json_object to be added */ JSON_EXPORT int json_object_array_add(struct json_object *obj, struct json_object *val); /** Insert or replace an element at a specified index in an array (a json_object of type json_type_array) * * The reference count will *not* be incremented. This is to make adding * fields to objects in code more compact. If you want to retain a reference * to an added object you must wrap the passed object with json_object_get * * The reference count of a replaced object will be decremented. * * The array size will be automatically be expanded to the size of the * index if the index is larger than the current size. * * @param obj the json_object instance * @param idx the index to insert the element at * @param val the json_object to be added */ JSON_EXPORT int json_object_array_put_idx(struct json_object *obj, size_t idx, struct json_object *val); /** Insert an element at a specified index in an array (a json_object of type json_type_array) * * The reference count will *not* be incremented. This is to make adding * fields to objects in code more compact. If you want to retain a reference * to an added object you must wrap the passed object with json_object_get * * The array size will be automatically be expanded to the size of the * index if the index is larger than the current size. * If the index is within the existing array limits, then the element will be * inserted and all elements will be shifted. This is the only difference between * this function and json_object_array_put_idx(). * * @param obj the json_object instance * @param idx the index to insert the element at * @param val the json_object to be added */ JSON_EXPORT int json_object_array_insert_idx(struct json_object *obj, size_t idx, struct json_object *val); /** Get the element at specified index of array `obj` (which must be a json_object of type json_type_array) * * *No* reference counts will be changed, and ownership of the returned * object remains with `obj`. See json_object_object_get() for additional * implications of this behavior. * * Calling this with anything other than a json_type_array will trigger * an assert. * * @param obj the json_object instance * @param idx the index to get the element at * @returns the json_object at the specified index (or NULL) */ JSON_EXPORT struct json_object *json_object_array_get_idx(const struct json_object *obj, size_t idx); /** Delete an elements from a specified index in an array (a json_object of type json_type_array) * * The reference count will be decremented for each of the deleted objects. If there * are no more owners of an element that is being deleted, then the value is * freed. Otherwise, the reference to the value will remain in memory. * * @param obj the json_object instance * @param idx the index to start deleting elements at * @param count the number of elements to delete * @returns 0 if the elements were successfully deleted */ JSON_EXPORT int json_object_array_del_idx(struct json_object *obj, size_t idx, size_t count); /** * Shrink the internal memory allocation of the array to just * enough to fit the number of elements in it, plus empty_slots. * * @param jso the json_object instance, must be json_type_array * @param empty_slots the number of empty slots to leave allocated */ JSON_EXPORT int json_object_array_shrink(struct json_object *jso, int empty_slots); /* json_bool type methods */ /** Create a new empty json_object of type json_type_boolean * @param b a json_bool 1 or 0 * @returns a json_object of type json_type_boolean */ JSON_EXPORT struct json_object *json_object_new_boolean(json_bool b); /** Get the json_bool value of a json_object * * The type is coerced to a json_bool if the passed object is not a json_bool. * integer and double objects will return 0 if there value is zero * or 1 otherwise. If the passed object is a string it will return * 1 if it has a non zero length. * If any other object type is passed 0 will be returned, even non-empty * json_type_array and json_type_object objects. * * @param obj the json_object instance * @returns a json_bool */ JSON_EXPORT json_bool json_object_get_boolean(const struct json_object *obj); /** Set the json_bool value of a json_object * * The type of obj is checked to be a json_type_boolean and 0 is returned * if it is not without any further actions. If type of obj is json_type_boolean * the object value is changed to new_value * * @param obj the json_object instance * @param new_value the value to be set * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_boolean(struct json_object *obj, json_bool new_value); /* int type methods */ /** Create a new empty json_object of type json_type_int * Note that values are stored as 64-bit values internally. * To ensure the full range is maintained, use json_object_new_int64 instead. * @param i the integer * @returns a json_object of type json_type_int */ JSON_EXPORT struct json_object *json_object_new_int(int32_t i); /** Create a new empty json_object of type json_type_int * @param i the integer * @returns a json_object of type json_type_int */ JSON_EXPORT struct json_object *json_object_new_int64(int64_t i); /** Create a new empty json_object of type json_type_uint * @param i the integer * @returns a json_object of type json_type_uint */ JSON_EXPORT struct json_object *json_object_new_uint64(uint64_t i); /** Get the int value of a json_object * * The type is coerced to a int if the passed object is not a int. * double objects will return their integer conversion. Strings will be * parsed as an integer. If no conversion exists then 0 is returned * and errno is set to EINVAL. null is equivalent to 0 (no error values set) * * Note that integers are stored internally as 64-bit values. * If the value of too big or too small to fit into 32-bit, INT32_MAX or * INT32_MIN are returned, respectively. * * @param obj the json_object instance * @returns an int */ JSON_EXPORT int32_t json_object_get_int(const struct json_object *obj); /** Set the int value of a json_object * * The type of obj is checked to be a json_type_int and 0 is returned * if it is not without any further actions. If type of obj is json_type_int * the object value is changed to new_value * * @param obj the json_object instance * @param new_value the value to be set * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_int(struct json_object *obj, int new_value); /** Increment a json_type_int object by the given amount, which may be negative. * * If the type of obj is not json_type_int then 0 is returned with no further * action taken. * If the addition would result in a overflow, the object value * is set to INT64_MAX. * If the addition would result in a underflow, the object value * is set to INT64_MIN. * Neither overflow nor underflow affect the return value. * * @param obj the json_object instance * @param val the value to add * @returns 1 if the increment succeeded, 0 otherwise */ JSON_EXPORT int json_object_int_inc(struct json_object *obj, int64_t val); /** Get the int value of a json_object * * The type is coerced to a int64 if the passed object is not a int64. * double objects will return their int64 conversion. Strings will be * parsed as an int64. If no conversion exists then 0 is returned. * * NOTE: Set errno to 0 directly before a call to this function to determine * whether or not conversion was successful (it does not clear the value for * you). * * @param obj the json_object instance * @returns an int64 */ JSON_EXPORT int64_t json_object_get_int64(const struct json_object *obj); /** Get the uint value of a json_object * * The type is coerced to a uint64 if the passed object is not a uint64. * double objects will return their uint64 conversion. Strings will be * parsed as an uint64. If no conversion exists then 0 is returned. * * NOTE: Set errno to 0 directly before a call to this function to determine * whether or not conversion was successful (it does not clear the value for * you). * * @param obj the json_object instance * @returns an uint64 */ JSON_EXPORT uint64_t json_object_get_uint64(const struct json_object *obj); /** Set the int64_t value of a json_object * * The type of obj is checked to be a json_type_int and 0 is returned * if it is not without any further actions. If type of obj is json_type_int * the object value is changed to new_value * * @param obj the json_object instance * @param new_value the value to be set * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_int64(struct json_object *obj, int64_t new_value); /** Set the uint64_t value of a json_object * * The type of obj is checked to be a json_type_uint and 0 is returned * if it is not without any further actions. If type of obj is json_type_uint * the object value is changed to new_value * * @param obj the json_object instance * @param new_value the value to be set * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_uint64(struct json_object *obj, uint64_t new_value); /* double type methods */ /** Create a new empty json_object of type json_type_double * * @see json_object_double_to_json_string() for how to set a custom format string. * * @param d the double * @returns a json_object of type json_type_double */ JSON_EXPORT struct json_object *json_object_new_double(double d); /** * Create a new json_object of type json_type_double, using * the exact serialized representation of the value. * * This allows for numbers that would otherwise get displayed * inefficiently (e.g. 12.3 => "12.300000000000001") to be * serialized with the more convenient form. * * Notes: * * This is used by json_tokener_parse_ex() to allow for * an exact re-serialization of a parsed object. * * The userdata field is used to store the string representation, so it * can't be used for other data if this function is used. * * A roughly equivalent sequence of calls, with the difference being that * the serialization function won't be reset by json_object_set_double(), is: * @code * jso = json_object_new_double(d); * json_object_set_serializer(jso, json_object_userdata_to_json_string, * strdup(ds), json_object_free_userdata); * @endcode * * @param d the numeric value of the double. * @param ds the string representation of the double. This will be copied. */ JSON_EXPORT struct json_object *json_object_new_double_s(double d, const char *ds); /** * Set a global or thread-local json-c option, depending on whether * JSON_C_OPTION_GLOBAL or JSON_C_OPTION_THREAD is passed. * Thread-local options default to undefined, and inherit from the global * value, even if the global value is changed after the thread is created. * Attempting to set thread-local options when threading is not compiled in * will result in an error. Be sure to check the return value. * * double_format is a "%g" printf format, such as "%.20g" * * @return -1 on errors, 0 on success. */ JSON_EXPORT int json_c_set_serialization_double_format(const char *double_format, int global_or_thread); /** Serialize a json_object of type json_type_double to a string. * * This function isn't meant to be called directly. Instead, you can set a * custom format string for the serialization of this double using the * following call (where "%.17g" actually is the default): * * @code * jso = json_object_new_double(d); * json_object_set_serializer(jso, json_object_double_to_json_string, * "%.17g", NULL); * @endcode * * @see printf(3) man page for format strings * * @param jso The json_type_double object that is serialized. * @param pb The destination buffer. * @param level Ignored. * @param flags Ignored. */ JSON_EXPORT int json_object_double_to_json_string(struct json_object *jso, struct printbuf *pb, int level, int flags); /** Get the double floating point value of a json_object * * The type is coerced to a double if the passed object is not a double. * integer objects will return their double conversion. Strings will be * parsed as a double. If no conversion exists then 0.0 is returned and * errno is set to EINVAL. null is equivalent to 0 (no error values set) * * If the value is too big to fit in a double, then the value is set to * the closest infinity with errno set to ERANGE. If strings cannot be * converted to their double value, then EINVAL is set & NaN is returned. * * Arrays of length 0 are interpreted as 0 (with no error flags set). * Arrays of length 1 are effectively cast to the equivalent object and * converted using the above rules. All other arrays set the error to * EINVAL & return NaN. * * NOTE: Set errno to 0 directly before a call to this function to * determine whether or not conversion was successful (it does not clear * the value for you). * * @param obj the json_object instance * @returns a double floating point number */ JSON_EXPORT double json_object_get_double(const struct json_object *obj); /** Set the double value of a json_object * * The type of obj is checked to be a json_type_double and 0 is returned * if it is not without any further actions. If type of obj is json_type_double * the object value is changed to new_value * * If the object was created with json_object_new_double_s(), the serialization * function is reset to the default and the cached serialized value is cleared. * * @param obj the json_object instance * @param new_value the value to be set * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_double(struct json_object *obj, double new_value); /* string type methods */ /** Create a new empty json_object of type json_type_string * * A copy of the string is made and the memory is managed by the json_object * * @param s the string * @returns a json_object of type json_type_string * @see json_object_new_string_len() */ JSON_EXPORT struct json_object *json_object_new_string(const char *s); /** Create a new empty json_object of type json_type_string and allocate * len characters for the new string. * * A copy of the string is made and the memory is managed by the json_object * * @param s the string * @param len max length of the new string * @returns a json_object of type json_type_string * @see json_object_new_string() */ JSON_EXPORT struct json_object *json_object_new_string_len(const char *s, const int len); /** Get the string value of a json_object * * If the passed object is of type json_type_null (i.e. obj == NULL), * NULL is returned. * * If the passed object of type json_type_string, the string contents * are returned. * * Otherwise the JSON representation of the object is returned. * * The returned string memory is managed by the json_object and will * be freed when the reference count of the json_object drops to zero. * * @param obj the json_object instance * @returns a string or NULL */ JSON_EXPORT const char *json_object_get_string(struct json_object *obj); /** Get the string length of a json_object * * If the passed object is not of type json_type_string then zero * will be returned. * * @param obj the json_object instance * @returns int */ JSON_EXPORT int json_object_get_string_len(const struct json_object *obj); /** Set the string value of a json_object with zero terminated strings * equivalent to json_object_set_string_len (obj, new_value, strlen(new_value)) * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_string(json_object *obj, const char *new_value); /** Set the string value of a json_object str * * The type of obj is checked to be a json_type_string and 0 is returned * if it is not without any further actions. If type of obj is json_type_string * the object value is changed to new_value * * @param obj the json_object instance * @param new_value the value to be set; Since string length is given in len this need not be zero terminated * @param len the length of new_value * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_string_len(json_object *obj, const char *new_value, int len); /** This method exists only to provide a complementary function * along the lines of the other json_object_new_* functions. * It always returns NULL, and it is entirely acceptable to simply use NULL directly. */ JSON_EXPORT struct json_object *json_object_new_null(void); /** Check if two json_object's are equal * * If the passed objects are equal 1 will be returned. * Equality is defined as follows: * - json_objects of different types are never equal * - json_objects of the same primitive type are equal if the * c-representation of their value is equal * - json-arrays are considered equal if all values at the same * indices are equal (same order) * - Complex json_objects are considered equal if all * contained objects referenced by their key are equal, * regardless their order. * * @param obj1 the first json_object instance * @param obj2 the second json_object instance * @returns whether both objects are equal or not */ JSON_EXPORT int json_object_equal(struct json_object *obj1, struct json_object *obj2); /** * Perform a shallow copy of src into *dst as part of an overall json_object_deep_copy(). * * If src is part of a containing object or array, parent will be non-NULL, * and key or index will be provided. * When shallow_copy is called *dst will be NULL, and must be non-NULL when it returns. * src will never be NULL. * * If shallow_copy sets the serializer on an object, return 2 to indicate to * json_object_deep_copy that it should not attempt to use the standard userdata * copy function. * * @return On success 1 or 2, -1 on errors */ typedef int(json_c_shallow_copy_fn)(json_object *src, json_object *parent, const char *key, size_t index, json_object **dst); /** * The default shallow copy implementation for use with json_object_deep_copy(). * This simply calls the appropriate json_object_new_() function and * copies over the serializer function (_to_json_string internal field of * the json_object structure) but not any _userdata or _user_delete values. * * If you're writing a custom shallow_copy function, perhaps because you're using * your own custom serializer, you can call this first to create the new object * before customizing it with json_object_set_serializer(). * * @return 1 on success, -1 on errors, but never 2. */ JSON_EXPORT json_c_shallow_copy_fn json_c_shallow_copy_default; /** * Copy the contents of the JSON object. * The destination object must be initialized to NULL, * to make sure this function won't overwrite an existing JSON object. * * This does roughly the same thing as * `json_tokener_parse(json_object_get_string(src))`. * * @param src source JSON object whose contents will be copied * @param dst pointer to the destination object where the contents of `src`; * make sure this pointer is initialized to NULL * @param shallow_copy an optional function to copy individual objects, needed * when custom serializers are in use. See also * json_object set_serializer. * * @returns 0 if the copy went well, -1 if an error occurred during copy * or if the destination pointer is non-NULL */ JSON_EXPORT int json_object_deep_copy(struct json_object *src, struct json_object **dst, json_c_shallow_copy_fn *shallow_copy); #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/json_object_iterator.c000066400000000000000000000107421446575330000213070ustar00rootroot00000000000000/** ******************************************************************************* * @file json_object_iterator.c * * Copyright (c) 2009-2012 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * ******************************************************************************* */ #include "config.h" #include #include "json.h" #include "json_object_private.h" #include "json_object_iterator.h" /** * How It Works * * For each JSON Object, json-c maintains a linked list of zero * or more lh_entry (link-hash entry) structures inside the * Object's link-hash table (lh_table). * * Each lh_entry structure on the JSON Object's linked list * represents a single name/value pair. The "next" field of the * last lh_entry in the list is set to NULL, which terminates * the list. * * We represent a valid iterator that refers to an actual * name/value pair via a pointer to the pair's lh_entry * structure set as the iterator's opaque_ field. * * We follow json-c's current pair list representation by * representing a valid "end" iterator (one that refers past the * last pair) with a NULL value in the iterator's opaque_ field. * * A JSON Object without any pairs in it will have the "head" * field of its lh_table structure set to NULL. For such an * object, json_object_iter_begin will return an iterator with * the opaque_ field set to NULL, which is equivalent to the * "end" iterator. * * When iterating, we simply update the iterator's opaque_ field * to point to the next lh_entry structure in the linked list. * opaque_ will become NULL once we iterate past the last pair * in the list, which makes the iterator equivalent to the "end" * iterator. */ /// Our current representation of the "end" iterator; /// /// @note May not always be NULL static const void *kObjectEndIterValue = NULL; /** * **************************************************************************** */ struct json_object_iterator json_object_iter_begin(struct json_object *obj) { struct json_object_iterator iter; struct lh_table *pTable; /// @note json_object_get_object will return NULL if passed NULL /// or a non-json_type_object instance pTable = json_object_get_object(obj); JASSERT(NULL != pTable); /// @note For a pair-less Object, head is NULL, which matches our /// definition of the "end" iterator iter.opaque_ = lh_table_head(pTable); return iter; } /** * **************************************************************************** */ struct json_object_iterator json_object_iter_end(const struct json_object *obj) { struct json_object_iterator iter; JASSERT(NULL != obj); JASSERT(json_object_is_type(obj, json_type_object)); iter.opaque_ = kObjectEndIterValue; return iter; } /** * **************************************************************************** */ void json_object_iter_next(struct json_object_iterator *iter) { JASSERT(NULL != iter); JASSERT(kObjectEndIterValue != iter->opaque_); iter->opaque_ = lh_entry_next(((const struct lh_entry *)iter->opaque_)); } /** * **************************************************************************** */ const char *json_object_iter_peek_name(const struct json_object_iterator *iter) { JASSERT(NULL != iter); JASSERT(kObjectEndIterValue != iter->opaque_); return (const char *)(((const struct lh_entry *)iter->opaque_)->k); } /** * **************************************************************************** */ struct json_object *json_object_iter_peek_value(const struct json_object_iterator *iter) { JASSERT(NULL != iter); JASSERT(kObjectEndIterValue != iter->opaque_); return (struct json_object *)lh_entry_v((const struct lh_entry *)iter->opaque_); } /** * **************************************************************************** */ json_bool json_object_iter_equal(const struct json_object_iterator *iter1, const struct json_object_iterator *iter2) { JASSERT(NULL != iter1); JASSERT(NULL != iter2); return (iter1->opaque_ == iter2->opaque_); } /** * **************************************************************************** */ struct json_object_iterator json_object_iter_init_default(void) { struct json_object_iterator iter; /** * @note Make this a negative, invalid value, such that * accidental access to it would likely be trapped by the * hardware as an invalid address. */ iter.opaque_ = NULL; return iter; } json-c-json-c-0.17-20230812/json_object_iterator.h000066400000000000000000000203121446575330000213060ustar00rootroot00000000000000/** ******************************************************************************* * @file json_object_iterator.h * * Copyright (c) 2009-2012 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * * @brief An API for iterating over json_type_object objects, * styled to be familiar to C++ programmers. * Unlike json_object_object_foreach() and * json_object_object_foreachC(), this avoids the need to expose * json-c internals like lh_entry. * * API attributes:
* * Thread-safe: NO
* * Reentrant: NO * ******************************************************************************* */ #ifndef JSON_OBJECT_ITERATOR_H #define JSON_OBJECT_ITERATOR_H #include "json_types.h" #include #ifdef __cplusplus extern "C" { #endif /** * Forward declaration for the opaque iterator information. */ struct json_object_iter_info_; /** * The opaque iterator that references a name/value pair within * a JSON Object instance or the "end" iterator value. */ struct json_object_iterator { const void *opaque_; }; /** * forward declaration of json-c's JSON value instance structure */ struct json_object; /** * Initializes an iterator structure to a "default" value that * is convenient for initializing an iterator variable to a * default state (e.g., initialization list in a class' * constructor). * * @code * struct json_object_iterator iter = json_object_iter_init_default(); * MyClass() : iter_(json_object_iter_init_default()) * @endcode * * @note The initialized value doesn't reference any specific * pair, is considered an invalid iterator, and MUST NOT * be passed to any json-c API that expects a valid * iterator. * * @note User and internal code MUST NOT make any assumptions * about and dependencies on the value of the "default" * iterator value. * * @return json_object_iterator */ JSON_EXPORT struct json_object_iterator json_object_iter_init_default(void); /** Retrieves an iterator to the first pair of the JSON Object. * * @warning Any modification of the underlying pair invalidates all * iterators to that pair. * * @param obj JSON Object instance (MUST be of type json_object) * * @return json_object_iterator If the JSON Object has at * least one pair, on return, the iterator refers * to the first pair. If the JSON Object doesn't * have any pairs, the returned iterator is * equivalent to the "end" iterator for the same * JSON Object instance. * * @code * struct json_object_iterator it; * struct json_object_iterator itEnd; * struct json_object* obj; * * obj = json_tokener_parse("{'first':'george', 'age':100}"); * it = json_object_iter_begin(obj); * itEnd = json_object_iter_end(obj); * * while (!json_object_iter_equal(&it, &itEnd)) { * printf("%s\n", * json_object_iter_peek_name(&it)); * json_object_iter_next(&it); * } * * @endcode */ JSON_EXPORT struct json_object_iterator json_object_iter_begin(struct json_object *obj); /** Retrieves the iterator that represents the position beyond the * last pair of the given JSON Object instance. * * @warning Do NOT write code that assumes that the "end" * iterator value is NULL, even if it is so in a * particular instance of the implementation. * * @note The reason we do not (and MUST NOT) provide * "json_object_iter_is_end(json_object_iterator* iter)" * type of API is because it would limit the underlying * representation of name/value containment (or force us * to add additional, otherwise unnecessary, fields to * the iterator structure). The "end" iterator and the * equality test method, on the other hand, permit us to * cleanly abstract pretty much any reasonable underlying * representation without burdening the iterator * structure with unnecessary data. * * @note For performance reasons, memorize the "end" iterator prior * to any loop. * * @param obj JSON Object instance (MUST be of type json_object) * * @return json_object_iterator On return, the iterator refers * to the "end" of the Object instance's pairs * (i.e., NOT the last pair, but "beyond the last * pair" value) */ JSON_EXPORT struct json_object_iterator json_object_iter_end(const struct json_object *obj); /** Returns an iterator to the next pair, if any * * @warning Any modification of the underlying pair * invalidates all iterators to that pair. * * @param iter [IN/OUT] Pointer to iterator that references a * name/value pair; MUST be a valid, non-end iterator. * WARNING: bad things will happen if invalid or "end" * iterator is passed. Upon return will contain the * reference to the next pair if there is one; if there * are no more pairs, will contain the "end" iterator * value, which may be compared against the return value * of json_object_iter_end() for the same JSON Object * instance. */ JSON_EXPORT void json_object_iter_next(struct json_object_iterator *iter); /** Returns a const pointer to the name of the pair referenced * by the given iterator. * * @param iter pointer to iterator that references a name/value * pair; MUST be a valid, non-end iterator. * * @warning bad things will happen if an invalid or * "end" iterator is passed. * * @return const char* Pointer to the name of the referenced * name/value pair. The name memory belongs to the * name/value pair, will be freed when the pair is * deleted or modified, and MUST NOT be modified or * freed by the user. */ JSON_EXPORT const char *json_object_iter_peek_name(const struct json_object_iterator *iter); /** Returns a pointer to the json-c instance representing the * value of the referenced name/value pair, without altering * the instance's reference count. * * @param iter pointer to iterator that references a name/value * pair; MUST be a valid, non-end iterator. * * @warning bad things will happen if invalid or * "end" iterator is passed. * * @return struct json_object* Pointer to the json-c value * instance of the referenced name/value pair; the * value's reference count is not changed by this * function: if you plan to hold on to this json-c node, * take a look at json_object_get() and * json_object_put(). IMPORTANT: json-c API represents * the JSON Null value as a NULL json_object instance * pointer. */ JSON_EXPORT struct json_object * json_object_iter_peek_value(const struct json_object_iterator *iter); /** Tests two iterators for equality. Typically used to test * for end of iteration by comparing an iterator to the * corresponding "end" iterator (that was derived from the same * JSON Object instance). * * @note The reason we do not (and MUST NOT) provide * "json_object_iter_is_end(json_object_iterator* iter)" * type of API is because it would limit the underlying * representation of name/value containment (or force us * to add additional, otherwise unnecessary, fields to * the iterator structure). The equality test method, on * the other hand, permits us to cleanly abstract pretty * much any reasonable underlying representation. * * @param iter1 Pointer to first valid, non-NULL iterator * @param iter2 POinter to second valid, non-NULL iterator * * @warning if a NULL iterator pointer or an uninitialized * or invalid iterator, or iterators derived from * different JSON Object instances are passed, bad things * will happen! * * @return json_bool non-zero if iterators are equal (i.e., both * reference the same name/value pair or are both at * "end"); zero if they are not equal. */ JSON_EXPORT json_bool json_object_iter_equal(const struct json_object_iterator *iter1, const struct json_object_iterator *iter2); #ifdef __cplusplus } #endif #endif /* JSON_OBJECT_ITERATOR_H */ json-c-json-c-0.17-20230812/json_object_private.h000066400000000000000000000042371446575330000211370ustar00rootroot00000000000000/* * $Id: json_object_private.h,v 1.4 2006/01/26 02:16:28 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Do not use, json-c internal, may be changed or removed at any time. */ #ifndef _json_object_private_h_ #define _json_object_private_h_ #ifdef __cplusplus extern "C" { #endif struct json_object; #include "json_inttypes.h" #include "json_types.h" #ifdef HAVE_UNISTD_H #include #endif /* HAVE_UNISTD_H */ #ifdef _MSC_VER #include typedef SSIZE_T ssize_t; #endif /* json object int type, support extension*/ typedef enum json_object_int_type { json_object_int_type_int64, json_object_int_type_uint64 } json_object_int_type; struct json_object { enum json_type o_type; uint32_t _ref_count; json_object_to_json_string_fn *_to_json_string; struct printbuf *_pb; json_object_delete_fn *_user_delete; void *_userdata; // Actually longer, always malloc'd as some more-specific type. // The rest of a struct json_object_${o_type} follows }; struct json_object_object { struct json_object base; struct lh_table *c_object; }; struct json_object_array { struct json_object base; struct array_list *c_array; }; struct json_object_boolean { struct json_object base; json_bool c_boolean; }; struct json_object_double { struct json_object base; double c_double; }; struct json_object_int { struct json_object base; enum json_object_int_type cint_type; union { int64_t c_int64; uint64_t c_uint64; } cint; }; struct json_object_string { struct json_object base; ssize_t len; // Signed b/c negative lengths indicate data is a pointer // Consider adding an "alloc" field here, if json_object_set_string calls // to expand the length of a string are common operations to perform. union { char idata[1]; // Immediate data. Actually longer char *pdata; // Only when len < 0 } c_string; }; void _json_c_set_last_err(const char *err_fmt, ...); extern const char *json_hex_chars; #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/json_patch.c000066400000000000000000000222461446575330000172310ustar00rootroot00000000000000/* * Copyright (c) 2021 Alexandru Ardelean. * Copyright (c) 2023 Eric Hawicz * * This is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. */ #include "config.h" #include #include #include #include "json_patch.h" #include "json_object_private.h" #include "json_pointer_private.h" #include #ifndef SIZE_T_MAX #if SIZEOF_SIZE_T == SIZEOF_INT #define SIZE_T_MAX UINT_MAX #elif SIZEOF_SIZE_T == SIZEOF_LONG #define SIZE_T_MAX ULONG_MAX #elif SIZEOF_SIZE_T == SIZEOF_LONG_LONG #define SIZE_T_MAX ULLONG_MAX #else #error Unable to determine size of size_t #endif #endif #define _set_err(_errval, _errmsg) do { \ patch_error->errno_code = (_errval); \ patch_error->errmsg = (_errmsg); \ errno = 0; /* To avoid confusion */ \ } while (0) #define _set_err_from_ptrget(_errval, _fieldname) do { \ patch_error->errno_code = (_errval); \ patch_error->errmsg = (_errval) == ENOENT ? \ "Did not find element referenced by " _fieldname " field" : \ "Invalid " _fieldname " field"; \ errno = 0; /* To avoid confusion */ \ } while(0) /** * JavaScript Object Notation (JSON) Patch * RFC 6902 - https://tools.ietf.org/html/rfc6902 */ static int json_patch_apply_test(struct json_object **res, struct json_object *patch_elem, const char *path, struct json_patch_error *patch_error) { struct json_object *value1, *value2; if (!json_object_object_get_ex(patch_elem, "value", &value1)) { _set_err(EINVAL, "Patch object does not contain a 'value' field"); return -1; } if (json_pointer_get(*res, path, &value2)) { _set_err_from_ptrget(errno, "path"); return -1; } if (!json_object_equal(value1, value2)) { _set_err(ENOENT, "Value of element referenced by 'path' field did not match 'value' field"); return -1; } return 0; } static int __json_patch_apply_remove(struct json_pointer_get_result *jpres) { if (json_object_is_type(jpres->parent, json_type_array)) { return json_object_array_del_idx(jpres->parent, jpres->index_in_parent, 1); } else if (jpres->parent && jpres->key_in_parent) { json_object_object_del(jpres->parent, jpres->key_in_parent); return 0; } else { // We're removing the root object (void)json_object_put(jpres->obj); jpres->obj = NULL; return 0; } } static int json_patch_apply_remove(struct json_object **res, const char *path, struct json_patch_error *patch_error) { struct json_pointer_get_result jpres; int rc; if (json_pointer_get_internal(*res, path, &jpres)) { _set_err_from_ptrget(errno, "path"); return -1; } rc = __json_patch_apply_remove(&jpres); if (rc < 0) _set_err(EINVAL, "Unable to remove path referenced by 'path' field"); // This means we removed and freed the root object, i.e. *res if (jpres.parent == NULL) *res = NULL; return rc; } // callback for json_pointer_set_with_array_cb() static int json_object_array_insert_idx_cb(struct json_object *parent, size_t idx, struct json_object *value, void *priv) { int rc; int *add = priv; if (idx > json_object_array_length(parent)) { // Note: will propagate back out through json_pointer_set_with_array_cb() errno = EINVAL; return -1; } if (*add) rc = json_object_array_insert_idx(parent, idx, value); else rc = json_object_array_put_idx(parent, idx, value); if (rc < 0) errno = EINVAL; return rc; } static int json_patch_apply_add_replace(struct json_object **res, struct json_object *patch_elem, const char *path, int add, struct json_patch_error *patch_error) { struct json_object *value; int rc; if (!json_object_object_get_ex(patch_elem, "value", &value)) { _set_err(EINVAL, "Patch object does not contain a 'value' field"); return -1; } /* if this is a replace op, then we need to make sure it exists before replacing */ if (!add && json_pointer_get(*res, path, NULL)) { _set_err_from_ptrget(errno, "path"); return -1; } rc = json_pointer_set_with_array_cb(res, path, json_object_get(value), json_object_array_insert_idx_cb, &add); if (rc) { _set_err(errno, "Failed to set value at path referenced by 'path' field"); json_object_put(value); } return rc; } // callback for json_pointer_set_with_array_cb() static int json_object_array_move_cb(struct json_object *parent, size_t idx, struct json_object *value, void *priv) { int rc; struct json_pointer_get_result *from = priv; size_t len = json_object_array_length(parent); /** * If it's the same array parent, it means that we removed * and element from it, so the length is temporarily reduced * by 1, which means that if we try to move an element to * the last position, we need to check the current length + 1 */ if (parent == from->parent) len++; if (idx > len) { // Note: will propagate back out through json_pointer_set_with_array_cb() errno = EINVAL; return -1; } rc = json_object_array_insert_idx(parent, idx, value); if (rc < 0) errno = EINVAL; return rc; } static int json_patch_apply_move_copy(struct json_object **res, struct json_object *patch_elem, const char *path, int move, struct json_patch_error *patch_error) { json_pointer_array_set_cb array_set_cb; struct json_pointer_get_result from; struct json_object *jfrom; const char *from_s; size_t from_s_len; int rc; if (!json_object_object_get_ex(patch_elem, "from", &jfrom)) { _set_err(EINVAL, "Patch does not contain a 'from' field"); return -1; } from_s = json_object_get_string(jfrom); from_s_len = strlen(from_s); if (strncmp(from_s, path, from_s_len) == 0) { /** * If lengths match, it's a noop, if they don't, * then we're trying to move a parent under a child * which is not allowed as per RFC 6902 section 4.4 * The "from" location MUST NOT be a proper prefix of the "path" * location; i.e., a location cannot be moved into one of its children. */ if (from_s_len == strlen(path)) return 0; _set_err(EINVAL, "Invalid attempt to move parent under a child"); return -1; } rc = json_pointer_get_internal(*res, from_s, &from); if (rc) { _set_err_from_ptrget(errno, "from"); return rc; } // Note: it's impossible for json_pointer to find the root obj, due // to the path check above, so from.parent is guaranteed non-NULL json_object_get(from.obj); if (!move) { array_set_cb = json_object_array_insert_idx_cb; } else { rc = __json_patch_apply_remove(&from); if (rc < 0) { json_object_put(from.obj); return rc; } array_set_cb = json_object_array_move_cb; } rc = json_pointer_set_with_array_cb(res, path, from.obj, array_set_cb, &from); if (rc) { _set_err(errno, "Failed to set value at path referenced by 'path' field"); json_object_put(from.obj); } return rc; } int json_patch_apply(struct json_object *copy_from, struct json_object *patch, struct json_object **base, struct json_patch_error *patch_error) { size_t ii; int rc = 0; struct json_patch_error placeholder; if (!patch_error) patch_error = &placeholder; patch_error->patch_failure_idx = SIZE_T_MAX; patch_error->errno_code = 0; if (base == NULL|| (*base == NULL && copy_from == NULL) || (*base != NULL && copy_from != NULL)) { _set_err(EFAULT, "Exactly one of *base or copy_from must be non-NULL"); return -1; } if (!json_object_is_type(patch, json_type_array)) { _set_err(EFAULT, "Patch object is not of type json_type_array"); return -1; } if (copy_from != NULL) { if (json_object_deep_copy(copy_from, base, NULL) < 0) { _set_err(ENOMEM, "Unable to copy copy_from using json_object_deep_copy()"); return -1; } } /* Go through all operations ; apply them on res */ for (ii = 0; ii < json_object_array_length(patch); ii++) { struct json_object *jop, *jpath; struct json_object *patch_elem = json_object_array_get_idx(patch, ii); const char *op, *path; patch_error->patch_failure_idx = ii; if (!json_object_object_get_ex(patch_elem, "op", &jop)) { _set_err(EINVAL, "Patch object does not contain 'op' field"); return -1; } op = json_object_get_string(jop); if (!json_object_object_get_ex(patch_elem, "path", &jpath)) { _set_err(EINVAL, "Patch object does not contain 'path' field"); return -1; } path = json_object_get_string(jpath); // Note: empty string is ok! if (!strcmp(op, "test")) rc = json_patch_apply_test(base, patch_elem, path, patch_error); else if (!strcmp(op, "remove")) rc = json_patch_apply_remove(base, path, patch_error); else if (!strcmp(op, "add")) rc = json_patch_apply_add_replace(base, patch_elem, path, 1, patch_error); else if (!strcmp(op, "replace")) rc = json_patch_apply_add_replace(base, patch_elem, path, 0, patch_error); else if (!strcmp(op, "move")) rc = json_patch_apply_move_copy(base, patch_elem, path, 1, patch_error); else if (!strcmp(op, "copy")) rc = json_patch_apply_move_copy(base, patch_elem, path, 0, patch_error); else { _set_err(EINVAL, "Patch object has invalid 'op' field"); return -1; } if (rc < 0) break; } return rc; } json-c-json-c-0.17-20230812/json_patch.h000066400000000000000000000046271446575330000172410ustar00rootroot00000000000000/* * Copyright (c) 2021 Alexadru Ardelean. * * This is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief JSON Patch (RFC 6902) implementation for manipulating JSON objects */ #ifndef _json_patch_h_ #define _json_patch_h_ #include "json_pointer.h" #ifdef __cplusplus extern "C" { #endif /** * Details of an error that occurred during json_patch_apply() */ struct json_patch_error { /** * An errno value indicating what kind of error occurred. * Possible values include: * - ENOENT - A path referenced in the operation does not exist. * - EINVAL - An invalid operation or with invalid path was attempted * - ENOMEM - Unable to allocate memory * - EFAULT - Invalid arguments were passed to json_patch_apply() * (i.e. a C API error, vs. a data error like EINVAL) */ int errno_code; /** * The index into the patch array of the operation that failed, * or SIZE_T_MAX for overall errors. */ size_t patch_failure_idx; /** * A human readable error message. * Allocated from static storage, does not need to be freed. */ const char *errmsg; }; /** * Apply the JSON patch to the base object. * The patch object must be formatted as per RFC 6902, i.e. * a json_type_array containing patch operations. * If the patch is not correctly formatted, an error will * be returned. * * The json_object at *base will be modified in place. * Exactly one of *base or copy_from must be non-NULL. * If *base is NULL, a new copy of copy_from will allocated and populated * using json_object_deep_copy(). In this case json_object_put() _must_ be * used to free *base even if the overall patching operation fails. * * If anything fails during patching a negative value will be returned, * and patch_error (if non-NULL) will be populated with error details. * * @param base a pointer to the JSON object which to patch * @param patch the JSON object that describes the patch to be applied * @param copy_from a JSON object to copy to *base * @param patch_error optional, details about errors * * @return negative if an error (or not found), or 0 if patch completely applied */ JSON_EXPORT int json_patch_apply(struct json_object *copy_from, struct json_object *patch, struct json_object **base, struct json_patch_error *patch_error); #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/json_pointer.c000066400000000000000000000212461446575330000176110ustar00rootroot00000000000000/* * Copyright (c) 2016 Alexandru Ardelean. * * This is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ #include "config.h" #include "strerror_override.h" #include #include #include #include #include "json_object_private.h" #include "json_pointer.h" #include "json_pointer_private.h" #include "strdup_compat.h" #include "vasprintf_compat.h" /* Avoid ctype.h and locale overhead */ #define is_plain_digit(c) ((c) >= '0' && (c) <= '9') /** * JavaScript Object Notation (JSON) Pointer * RFC 6901 - https://tools.ietf.org/html/rfc6901 */ static void string_replace_all_occurrences_with_char(char *s, const char *occur, char repl_char) { size_t slen = strlen(s); size_t skip = strlen(occur) - 1; /* length of the occurrence, minus the char we're replacing */ char *p = s; while ((p = strstr(p, occur))) { *p = repl_char; p++; slen -= skip; memmove(p, (p + skip), slen - (p - s) + 1); /* includes null char too */ } } static int is_valid_index(const char *path, size_t *idx) { size_t i, len = strlen(path); /* this code-path optimizes a bit, for when we reference the 0-9 index range * in a JSON array and because leading zeros not allowed */ if (len == 1) { if (is_plain_digit(path[0])) { *idx = (path[0] - '0'); return 1; } errno = EINVAL; return 0; } /* leading zeros not allowed per RFC */ if (path[0] == '0') { errno = EINVAL; return 0; } /* RFC states base-10 decimals */ for (i = 0; i < len; i++) { if (!is_plain_digit(path[i])) { errno = EINVAL; return 0; } } // We know it's all digits, so the only error case here is overflow, // but ULLONG_MAX will be longer than any array length so that's ok. *idx = strtoull(path, NULL, 10); return 1; } static int json_pointer_get_single_path(struct json_object *obj, char *path, struct json_object **value, size_t *idx) { if (json_object_is_type(obj, json_type_array)) { if (!is_valid_index(path, idx)) return -1; if (*idx >= json_object_array_length(obj)) { errno = ENOENT; return -1; } obj = json_object_array_get_idx(obj, *idx); if (obj) { if (value) *value = obj; return 0; } /* Entry not found */ errno = ENOENT; return -1; } /* RFC states that we first must eval all ~1 then all ~0 */ string_replace_all_occurrences_with_char(path, "~1", '/'); string_replace_all_occurrences_with_char(path, "~0", '~'); if (!json_object_object_get_ex(obj, path, value)) { errno = ENOENT; return -1; } return 0; } static int json_object_array_put_idx_cb(struct json_object *parent, size_t idx, struct json_object *value, void *priv) { return json_object_array_put_idx(parent, idx, value); } static int json_pointer_set_single_path(struct json_object *parent, const char *path, struct json_object *value, json_pointer_array_set_cb array_set_cb, void *priv) { if (json_object_is_type(parent, json_type_array)) { size_t idx; /* RFC (Chapter 4) states that '-' may be used to add new elements to an array */ if (path[0] == '-' && path[1] == '\0') return json_object_array_add(parent, value); if (!is_valid_index(path, &idx)) return -1; return array_set_cb(parent, idx, value, priv); } /* path replacements should have been done in json_pointer_get_single_path(), * and we should still be good here */ if (json_object_is_type(parent, json_type_object)) return json_object_object_add(parent, path, value); /* Getting here means that we tried to "dereference" a primitive JSON type * (like string, int, bool).i.e. add a sub-object to it */ errno = ENOENT; return -1; } static int json_pointer_result_get_recursive(struct json_object *obj, char *path, struct json_pointer_get_result *res) { struct json_object *parent_obj = obj; size_t idx; char *endp; int rc; /* All paths (on each recursion level must have a leading '/' */ if (path[0] != '/') { errno = EINVAL; return -1; } path++; endp = strchr(path, '/'); if (endp) *endp = '\0'; /* If we err-ed here, return here */ if ((rc = json_pointer_get_single_path(obj, path, &obj, &idx))) return rc; if (endp) { /* Put the slash back, so that the sanity check passes on next recursion level */ *endp = '/'; return json_pointer_result_get_recursive(obj, endp, res); } /* We should be at the end of the recursion here */ if (res) { res->parent = parent_obj; res->obj = obj; if (json_object_is_type(res->parent, json_type_array)) res->index_in_parent = idx; else res->key_in_parent = path; } return 0; } static int json_pointer_object_get_recursive(struct json_object *obj, char *path, struct json_object **value) { struct json_pointer_get_result res; int rc; rc = json_pointer_result_get_recursive(obj, path, &res); if (rc) return rc; if (value) *value = res.obj; return 0; } int json_pointer_get_internal(struct json_object *obj, const char *path, struct json_pointer_get_result *res) { char *path_copy = NULL; int rc; if (!obj || !path) { errno = EINVAL; return -1; } if (path[0] == '\0') { res->parent = NULL; res->obj = obj; res->key_in_parent = NULL; res->index_in_parent = -1; return 0; } /* pass a working copy to the recursive call */ if (!(path_copy = strdup(path))) { errno = ENOMEM; return -1; } rc = json_pointer_result_get_recursive(obj, path_copy, res); /* re-map the path string to the const-path string */ if (rc == 0 && json_object_is_type(res->parent, json_type_object) && res->key_in_parent) res->key_in_parent = path + (res->key_in_parent - path_copy); free(path_copy); return rc; } int json_pointer_get(struct json_object *obj, const char *path, struct json_object **res) { struct json_pointer_get_result jpres; int rc; rc = json_pointer_get_internal(obj, path, &jpres); if (rc) return rc; if (res) *res = jpres.obj; return 0; } int json_pointer_getf(struct json_object *obj, struct json_object **res, const char *path_fmt, ...) { char *path_copy = NULL; int rc = 0; va_list args; if (!obj || !path_fmt) { errno = EINVAL; return -1; } va_start(args, path_fmt); rc = vasprintf(&path_copy, path_fmt, args); va_end(args); if (rc < 0) return rc; if (path_copy[0] == '\0') { if (res) *res = obj; goto out; } rc = json_pointer_object_get_recursive(obj, path_copy, res); out: free(path_copy); return rc; } int json_pointer_set_with_array_cb(struct json_object **obj, const char *path, struct json_object *value, json_pointer_array_set_cb array_set_cb, void *priv) { const char *endp; char *path_copy = NULL; struct json_object *set = NULL; int rc; if (!obj || !path) { errno = EINVAL; return -1; } if (path[0] == '\0') { json_object_put(*obj); *obj = value; return 0; } if (path[0] != '/') { errno = EINVAL; return -1; } /* If there's only 1 level to set, stop here */ if ((endp = strrchr(path, '/')) == path) { path++; return json_pointer_set_single_path(*obj, path, value, array_set_cb, priv); } /* pass a working copy to the recursive call */ if (!(path_copy = strdup(path))) { errno = ENOMEM; return -1; } path_copy[endp - path] = '\0'; rc = json_pointer_object_get_recursive(*obj, path_copy, &set); free(path_copy); if (rc) return rc; endp++; return json_pointer_set_single_path(set, endp, value, array_set_cb, priv); } int json_pointer_set(struct json_object **obj, const char *path, struct json_object *value) { return json_pointer_set_with_array_cb(obj, path, value, json_object_array_put_idx_cb, NULL); } int json_pointer_setf(struct json_object **obj, struct json_object *value, const char *path_fmt, ...) { char *endp; char *path_copy = NULL; struct json_object *set = NULL; va_list args; int rc = 0; if (!obj || !path_fmt) { errno = EINVAL; return -1; } /* pass a working copy to the recursive call */ va_start(args, path_fmt); rc = vasprintf(&path_copy, path_fmt, args); va_end(args); if (rc < 0) return rc; if (path_copy[0] == '\0') { json_object_put(*obj); *obj = value; goto out; } if (path_copy[0] != '/') { errno = EINVAL; rc = -1; goto out; } /* If there's only 1 level to set, stop here */ if ((endp = strrchr(path_copy, '/')) == path_copy) { set = *obj; goto set_single_path; } *endp = '\0'; rc = json_pointer_object_get_recursive(*obj, path_copy, &set); if (rc) goto out; set_single_path: endp++; rc = json_pointer_set_single_path(set, endp, value, json_object_array_put_idx_cb, NULL); out: free(path_copy); return rc; } json-c-json-c-0.17-20230812/json_pointer.h000066400000000000000000000106641446575330000176200ustar00rootroot00000000000000/* * Copyright (c) 2016 Alexadru Ardelean. * * This is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief JSON Pointer (RFC 6901) implementation for retrieving * objects from a json-c object tree. */ #ifndef _json_pointer_h_ #define _json_pointer_h_ #include "json_object.h" #ifdef __cplusplus extern "C" { #endif /** * Retrieves a JSON sub-object from inside another JSON object * using the JSON pointer notation as defined in RFC 6901 * https://tools.ietf.org/html/rfc6901 * * The returned JSON sub-object is equivalent to parsing manually the * 'obj' JSON tree ; i.e. it's not a new object that is created, but rather * a pointer inside the JSON tree. * * Internally, this is equivalent to doing a series of 'json_object_object_get()' * and 'json_object_array_get_idx()' along the given 'path'. * * @param obj the json_object instance/tree from where to retrieve sub-objects * @param path a (RFC6901) string notation for the sub-object to retrieve * @param res a pointer that stores a reference to the json_object * associated with the given path * * @return negative if an error (or not found), or 0 if succeeded */ JSON_EXPORT int json_pointer_get(struct json_object *obj, const char *path, struct json_object **res); /** * This is a variant of 'json_pointer_get()' that supports printf() style arguments. * * Variable arguments go after the 'path_fmt' parameter. * * Example: json_pointer_getf(obj, res, "/foo/%d/%s", 0, "bar") * This also means that you need to escape '%' with '%%' (just like in printf()) * * Please take into consideration all recommended 'printf()' format security * aspects when using this function. * * @param obj the json_object instance/tree to which to add a sub-object * @param res a pointer that stores a reference to the json_object * associated with the given path * @param path_fmt a printf() style format for the path * * @return negative if an error (or not found), or 0 if succeeded */ JSON_EXPORT int json_pointer_getf(struct json_object *obj, struct json_object **res, const char *path_fmt, ...); /** * Sets JSON object 'value' in the 'obj' tree at the location specified * by the 'path'. 'path' is JSON pointer notation as defined in RFC 6901 * https://tools.ietf.org/html/rfc6901 * * Note that 'obj' is a double pointer, mostly for the "" (empty string) * case, where the entire JSON object would be replaced by 'value'. * In the case of the "" path, the object at '*obj' will have it's refcount * decremented with 'json_object_put()' and the 'value' object will be assigned to it. * * For other cases (JSON sub-objects) ownership of 'value' will be transferred into * '*obj' via 'json_object_object_add()' & 'json_object_array_put_idx()', so the * only time the refcount should be decremented for 'value' is when the return value of * 'json_pointer_set()' is negative (meaning the 'value' object did not get set into '*obj'). * * That also implies that 'json_pointer_set()' does not do any refcount incrementing. * (Just that single decrement that was mentioned above). * * @param obj the json_object instance/tree to which to add a sub-object * @param path a (RFC6901) string notation for the sub-object to set in the tree * @param value object to set at path * * @return negative if an error (or not found), or 0 if succeeded */ JSON_EXPORT int json_pointer_set(struct json_object **obj, const char *path, struct json_object *value); /** * This is a variant of 'json_pointer_set()' that supports printf() style arguments. * * Variable arguments go after the 'path_fmt' parameter. * * Example: json_pointer_setf(obj, value, "/foo/%d/%s", 0, "bar") * This also means that you need to escape '%' with '%%' (just like in printf()) * * Please take into consideration all recommended 'printf()' format security * aspects when using this function. * * @param obj the json_object instance/tree to which to add a sub-object * @param value object to set at path * @param path_fmt a printf() style format for the path * * @return negative if an error (or not found), or 0 if succeeded */ JSON_EXPORT int json_pointer_setf(struct json_object **obj, struct json_object *value, const char *path_fmt, ...); #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/json_pointer_private.h000066400000000000000000000024531446575330000213470ustar00rootroot00000000000000/* * Copyright (c) 2023 Eric Hawicz * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. */ /** * @file * @brief Do not use, json-c internal, may be changed or removed at any time. */ #ifndef _json_pointer_private_h_ #define _json_pointer_private_h_ #ifdef __cplusplus extern "C" { #endif struct json_pointer_get_result { struct json_object *parent; struct json_object *obj; // The key of the found object; only valid when parent is json_type_object // Caution: re-uses tail end of the `path` argument to json_pointer_get_internal const char *key_in_parent; // the index of the found object; only valid when parent is json_type_array uint32_t index_in_parent; }; int json_pointer_get_internal(struct json_object *obj, const char *path, struct json_pointer_get_result *res); typedef int(*json_pointer_array_set_cb)(json_object *parent, size_t idx, json_object *value, void *priv); int json_pointer_set_with_array_cb(struct json_object **obj, const char *path, struct json_object *value, json_pointer_array_set_cb array_set_cb, void *priv); #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/json_tokener.c000066400000000000000000001106041446575330000175750ustar00rootroot00000000000000/* * $Id: json_tokener.c,v 1.20 2006/07/25 03:24:50 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * * * Copyright (c) 2008-2009 Yahoo! Inc. All rights reserved. * The copyrights to the contents of this file are licensed under the MIT License * (https://www.opensource.org/licenses/mit-license.php) */ #include "config.h" #include "math_compat.h" #include #include #include #include #include #include #include #include #include "debug.h" #include "json_inttypes.h" #include "json_object.h" #include "json_object_private.h" #include "json_tokener.h" #include "json_util.h" #include "printbuf.h" #include "strdup_compat.h" #ifdef HAVE_LOCALE_H #include #endif /* HAVE_LOCALE_H */ #ifdef HAVE_XLOCALE_H #include #endif #ifdef HAVE_STRINGS_H #include #endif /* HAVE_STRINGS_H */ #define jt_hexdigit(x) (((x) <= '9') ? (x) - '0' : ((x)&7) + 9) #if !HAVE_STRNCASECMP && defined(_MSC_VER) /* MSC has the version as _strnicmp */ #define strncasecmp _strnicmp #elif !HAVE_STRNCASECMP #error You do not have strncasecmp on your system. #endif /* HAVE_STRNCASECMP */ #if defined(_MSC_VER) && (_MSC_VER <= 1800) /* VS2013 doesn't know about "inline" */ #define inline __inline #elif defined(AIX_CC) #define inline #endif /* The following helper functions are used to speed up parsing. They * are faster than their ctype counterparts because they assume that * the input is in ASCII and that the locale is set to "C". The * compiler will also inline these functions, providing an additional * speedup by saving on function calls. */ static inline int is_ws_char(char c) { return c == ' ' || c == '\t' || c == '\n' || c == '\r'; } static inline int is_hex_char(char c) { return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'); } /* Use C99 NAN by default; if not available, nan("") should work too. */ #ifndef NAN #define NAN nan("") #endif /* !NAN */ static const char json_null_str[] = "null"; static const int json_null_str_len = sizeof(json_null_str) - 1; static const char json_inf_str[] = "Infinity"; /* Swapped case "Infinity" to avoid need to call tolower() on input chars: */ static const char json_inf_str_invert[] = "iNFINITY"; static const unsigned int json_inf_str_len = sizeof(json_inf_str) - 1; static const char json_nan_str[] = "NaN"; static const int json_nan_str_len = sizeof(json_nan_str) - 1; static const char json_true_str[] = "true"; static const int json_true_str_len = sizeof(json_true_str) - 1; static const char json_false_str[] = "false"; static const int json_false_str_len = sizeof(json_false_str) - 1; /* clang-format off */ static const char *json_tokener_errors[] = { "success", "continue", "nesting too deep", "unexpected end of data", "unexpected character", "null expected", "boolean expected", "number expected", "array value separator ',' expected", "quoted object property name expected", "object property name separator ':' expected", "object value separator ',' expected", "invalid string sequence", "expected comment", "invalid utf-8 string", "buffer size overflow", "out of memory" }; /* clang-format on */ /** * validete the utf-8 string in strict model. * if not utf-8 format, return err. */ static json_bool json_tokener_validate_utf8(const char c, unsigned int *nBytes); static int json_tokener_parse_double(const char *buf, int len, double *retval); const char *json_tokener_error_desc(enum json_tokener_error jerr) { int jerr_int = (int)jerr; if (jerr_int < 0 || jerr_int >= (int)(sizeof(json_tokener_errors) / sizeof(json_tokener_errors[0]))) return "Unknown error, " "invalid json_tokener_error value passed to json_tokener_error_desc()"; return json_tokener_errors[jerr]; } enum json_tokener_error json_tokener_get_error(struct json_tokener *tok) { return tok->err; } /* Stuff for decoding unicode sequences */ #define IS_HIGH_SURROGATE(uc) (((uc)&0xFC00) == 0xD800) #define IS_LOW_SURROGATE(uc) (((uc)&0xFC00) == 0xDC00) #define DECODE_SURROGATE_PAIR(hi, lo) ((((hi)&0x3FF) << 10) + ((lo)&0x3FF) + 0x10000) static unsigned char utf8_replacement_char[3] = {0xEF, 0xBF, 0xBD}; struct json_tokener *json_tokener_new_ex(int depth) { struct json_tokener *tok; tok = (struct json_tokener *)calloc(1, sizeof(struct json_tokener)); if (!tok) return NULL; tok->stack = (struct json_tokener_srec *)calloc(depth, sizeof(struct json_tokener_srec)); if (!tok->stack) { free(tok); return NULL; } tok->pb = printbuf_new(); if (!tok->pb) { free(tok->stack); free(tok); return NULL; } tok->max_depth = depth; json_tokener_reset(tok); return tok; } struct json_tokener *json_tokener_new(void) { return json_tokener_new_ex(JSON_TOKENER_DEFAULT_DEPTH); } void json_tokener_free(struct json_tokener *tok) { json_tokener_reset(tok); if (tok->pb) printbuf_free(tok->pb); free(tok->stack); free(tok); } static void json_tokener_reset_level(struct json_tokener *tok, int depth) { tok->stack[depth].state = json_tokener_state_eatws; tok->stack[depth].saved_state = json_tokener_state_start; json_object_put(tok->stack[depth].current); tok->stack[depth].current = NULL; free(tok->stack[depth].obj_field_name); tok->stack[depth].obj_field_name = NULL; } void json_tokener_reset(struct json_tokener *tok) { int i; if (!tok) return; for (i = tok->depth; i >= 0; i--) json_tokener_reset_level(tok, i); tok->depth = 0; tok->err = json_tokener_success; } struct json_object *json_tokener_parse(const char *str) { enum json_tokener_error jerr_ignored; struct json_object *obj; obj = json_tokener_parse_verbose(str, &jerr_ignored); return obj; } struct json_object *json_tokener_parse_verbose(const char *str, enum json_tokener_error *error) { struct json_tokener *tok; struct json_object *obj; tok = json_tokener_new(); if (!tok) return NULL; obj = json_tokener_parse_ex(tok, str, -1); *error = tok->err; if (tok->err != json_tokener_success #if 0 /* This would be a more sensible default, and cause parsing * things like "null123" to fail when the caller can't know * where the parsing left off, but starting to fail would * be a notable behaviour change. Save for a 1.0 release. */ || json_tokener_get_parse_end(tok) != strlen(str) #endif ) { if (obj != NULL) json_object_put(obj); obj = NULL; } json_tokener_free(tok); return obj; } #define state tok->stack[tok->depth].state #define saved_state tok->stack[tok->depth].saved_state #define current tok->stack[tok->depth].current #define obj_field_name tok->stack[tok->depth].obj_field_name /* Optimization: * json_tokener_parse_ex() consumed a lot of CPU in its main loop, * iterating character-by character. A large performance boost is * achieved by using tighter loops to locally handle units such as * comments and strings. Loops that handle an entire token within * their scope also gather entire strings and pass them to * printbuf_memappend() in a single call, rather than calling * printbuf_memappend() one char at a time. * * PEEK_CHAR() and ADVANCE_CHAR() macros are used for code that is * common to both the main loop and the tighter loops. */ /* PEEK_CHAR(dest, tok) macro: * Peeks at the current char and stores it in dest. * Returns 1 on success, sets tok->err and returns 0 if no more chars. * Implicit inputs: str, len, nBytesp vars */ #define PEEK_CHAR(dest, tok) \ (((tok)->char_offset == len) \ ? (((tok)->depth == 0 && state == json_tokener_state_eatws && \ saved_state == json_tokener_state_finish) \ ? (((tok)->err = json_tokener_success), 0) \ : (((tok)->err = json_tokener_continue), 0)) \ : (((tok->flags & JSON_TOKENER_VALIDATE_UTF8) && \ (!json_tokener_validate_utf8(*str, nBytesp))) \ ? ((tok->err = json_tokener_error_parse_utf8_string), 0) \ : (((dest) = *str), 1))) /* ADVANCE_CHAR() macro: * Increments str & tok->char_offset. * For convenience of existing conditionals, returns the old value of c (0 on eof). * Implicit inputs: c var */ #define ADVANCE_CHAR(str, tok) (++(str), ((tok)->char_offset)++, c) /* printbuf_memappend_checked(p, s, l) macro: * Add string s of length l to printbuffer p. * If operation fails abort parse operation with memory error. */ #define printbuf_memappend_checked(p, s, l) \ do { \ if (printbuf_memappend((p), (s), (l)) < 0) \ { \ tok->err = json_tokener_error_memory; \ goto out; \ } \ } while (0) /* End optimization macro defs */ struct json_object *json_tokener_parse_ex(struct json_tokener *tok, const char *str, int len) { struct json_object *obj = NULL; char c = '\1'; unsigned int nBytes = 0; unsigned int *nBytesp = &nBytes; #ifdef HAVE_USELOCALE locale_t oldlocale = uselocale(NULL); locale_t newloc; #elif defined(HAVE_SETLOCALE) char *oldlocale = NULL; #endif tok->char_offset = 0; tok->err = json_tokener_success; /* this interface is presently not 64-bit clean due to the int len argument * and the internal printbuf interface that takes 32-bit int len arguments * so the function limits the maximum string size to INT32_MAX (2GB). * If the function is called with len == -1 then strlen is called to check * the string length is less than INT32_MAX (2GB) */ if ((len < -1) || (len == -1 && strlen(str) > INT32_MAX)) { tok->err = json_tokener_error_size; return NULL; } #ifdef HAVE_USELOCALE { locale_t duploc = duplocale(oldlocale); newloc = newlocale(LC_NUMERIC_MASK, "C", duploc); if (newloc == NULL) { freelocale(duploc); return NULL; } #ifdef NEWLOCALE_NEEDS_FREELOCALE // Older versions of FreeBSD (<12.4) don't free the locale // passed to newlocale(), so do it here freelocale(duploc); #endif uselocale(newloc); } #elif defined(HAVE_SETLOCALE) { char *tmplocale; tmplocale = setlocale(LC_NUMERIC, NULL); if (tmplocale) { oldlocale = strdup(tmplocale); if (oldlocale == NULL) return NULL; } setlocale(LC_NUMERIC, "C"); } #endif while (PEEK_CHAR(c, tok)) // Note: c might be '\0' ! { redo_char: switch (state) { case json_tokener_state_eatws: /* Advance until we change state */ while (is_ws_char(c)) { if ((!ADVANCE_CHAR(str, tok)) || (!PEEK_CHAR(c, tok))) goto out; } if (c == '/' && !(tok->flags & JSON_TOKENER_STRICT)) { printbuf_reset(tok->pb); printbuf_memappend_checked(tok->pb, &c, 1); state = json_tokener_state_comment_start; } else { state = saved_state; goto redo_char; } break; case json_tokener_state_start: switch (c) { case '{': state = json_tokener_state_eatws; saved_state = json_tokener_state_object_field_start; current = json_object_new_object(); if (current == NULL) { tok->err = json_tokener_error_memory; goto out; } break; case '[': state = json_tokener_state_eatws; saved_state = json_tokener_state_array; current = json_object_new_array(); if (current == NULL) { tok->err = json_tokener_error_memory; goto out; } break; case 'I': case 'i': state = json_tokener_state_inf; printbuf_reset(tok->pb); tok->st_pos = 0; goto redo_char; case 'N': case 'n': state = json_tokener_state_null; // or NaN printbuf_reset(tok->pb); tok->st_pos = 0; goto redo_char; case '\'': if (tok->flags & JSON_TOKENER_STRICT) { /* in STRICT mode only double-quote are allowed */ tok->err = json_tokener_error_parse_unexpected; goto out; } /* FALLTHRU */ case '"': state = json_tokener_state_string; printbuf_reset(tok->pb); tok->quote_char = c; break; case 'T': case 't': case 'F': case 'f': state = json_tokener_state_boolean; printbuf_reset(tok->pb); tok->st_pos = 0; goto redo_char; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '-': state = json_tokener_state_number; printbuf_reset(tok->pb); tok->is_double = 0; goto redo_char; default: tok->err = json_tokener_error_parse_unexpected; goto out; } break; case json_tokener_state_finish: if (tok->depth == 0) goto out; obj = json_object_get(current); json_tokener_reset_level(tok, tok->depth); tok->depth--; goto redo_char; case json_tokener_state_inf: /* aka starts with 'i' (or 'I', or "-i", or "-I") */ { /* If we were guaranteed to have len set, then we could (usually) handle * the entire "Infinity" check in a single strncmp (strncasecmp), but * since len might be -1 (i.e. "read until \0"), we need to check it * a character at a time. * Trying to handle it both ways would make this code considerably more * complicated with likely little performance benefit. */ int is_negative = 0; /* Note: tok->st_pos must be 0 when state is set to json_tokener_state_inf */ while (tok->st_pos < (int)json_inf_str_len) { char inf_char = *str; if (inf_char != json_inf_str[tok->st_pos] && ((tok->flags & JSON_TOKENER_STRICT) || inf_char != json_inf_str_invert[tok->st_pos]) ) { tok->err = json_tokener_error_parse_unexpected; goto out; } tok->st_pos++; (void)ADVANCE_CHAR(str, tok); if (!PEEK_CHAR(c, tok)) { /* out of input chars, for now at least */ goto out; } } /* We checked the full length of "Infinity", so create the object. * When handling -Infinity, the number parsing code will have dropped * the "-" into tok->pb for us, so check it now. */ if (printbuf_length(tok->pb) > 0 && *(tok->pb->buf) == '-') { is_negative = 1; } current = json_object_new_double(is_negative ? -INFINITY : INFINITY); if (current == NULL) { tok->err = json_tokener_error_memory; goto out; } saved_state = json_tokener_state_finish; state = json_tokener_state_eatws; goto redo_char; } break; case json_tokener_state_null: /* aka starts with 'n' */ { int size; int size_nan; printbuf_memappend_checked(tok->pb, &c, 1); size = json_min(tok->st_pos + 1, json_null_str_len); size_nan = json_min(tok->st_pos + 1, json_nan_str_len); if ((!(tok->flags & JSON_TOKENER_STRICT) && strncasecmp(json_null_str, tok->pb->buf, size) == 0) || (strncmp(json_null_str, tok->pb->buf, size) == 0)) { if (tok->st_pos == json_null_str_len) { current = NULL; saved_state = json_tokener_state_finish; state = json_tokener_state_eatws; goto redo_char; } } else if ((!(tok->flags & JSON_TOKENER_STRICT) && strncasecmp(json_nan_str, tok->pb->buf, size_nan) == 0) || (strncmp(json_nan_str, tok->pb->buf, size_nan) == 0)) { if (tok->st_pos == json_nan_str_len) { current = json_object_new_double(NAN); if (current == NULL) { tok->err = json_tokener_error_memory; goto out; } saved_state = json_tokener_state_finish; state = json_tokener_state_eatws; goto redo_char; } } else { tok->err = json_tokener_error_parse_null; goto out; } tok->st_pos++; } break; case json_tokener_state_comment_start: if (c == '*') { state = json_tokener_state_comment; } else if (c == '/') { state = json_tokener_state_comment_eol; } else { tok->err = json_tokener_error_parse_comment; goto out; } printbuf_memappend_checked(tok->pb, &c, 1); break; case json_tokener_state_comment: { /* Advance until we change state */ const char *case_start = str; while (c != '*') { if (!ADVANCE_CHAR(str, tok) || !PEEK_CHAR(c, tok)) { printbuf_memappend_checked(tok->pb, case_start, str - case_start); goto out; } } printbuf_memappend_checked(tok->pb, case_start, 1 + str - case_start); state = json_tokener_state_comment_end; } break; case json_tokener_state_comment_eol: { /* Advance until we change state */ const char *case_start = str; while (c != '\n') { if (!ADVANCE_CHAR(str, tok) || !PEEK_CHAR(c, tok)) { printbuf_memappend_checked(tok->pb, case_start, str - case_start); goto out; } } printbuf_memappend_checked(tok->pb, case_start, str - case_start); MC_DEBUG("json_tokener_comment: %s\n", tok->pb->buf); state = json_tokener_state_eatws; } break; case json_tokener_state_comment_end: printbuf_memappend_checked(tok->pb, &c, 1); if (c == '/') { MC_DEBUG("json_tokener_comment: %s\n", tok->pb->buf); state = json_tokener_state_eatws; } else { state = json_tokener_state_comment; } break; case json_tokener_state_string: { /* Advance until we change state */ const char *case_start = str; while (1) { if (c == tok->quote_char) { printbuf_memappend_checked(tok->pb, case_start, str - case_start); current = json_object_new_string_len(tok->pb->buf, tok->pb->bpos); if (current == NULL) { tok->err = json_tokener_error_memory; goto out; } saved_state = json_tokener_state_finish; state = json_tokener_state_eatws; break; } else if (c == '\\') { printbuf_memappend_checked(tok->pb, case_start, str - case_start); saved_state = json_tokener_state_string; state = json_tokener_state_string_escape; break; } if (!ADVANCE_CHAR(str, tok) || !PEEK_CHAR(c, tok)) { printbuf_memappend_checked(tok->pb, case_start, str - case_start); goto out; } } } break; case json_tokener_state_string_escape: switch (c) { case '"': case '\\': case '/': printbuf_memappend_checked(tok->pb, &c, 1); state = saved_state; break; case 'b': case 'n': case 'r': case 't': case 'f': if (c == 'b') printbuf_memappend_checked(tok->pb, "\b", 1); else if (c == 'n') printbuf_memappend_checked(tok->pb, "\n", 1); else if (c == 'r') printbuf_memappend_checked(tok->pb, "\r", 1); else if (c == 't') printbuf_memappend_checked(tok->pb, "\t", 1); else if (c == 'f') printbuf_memappend_checked(tok->pb, "\f", 1); state = saved_state; break; case 'u': tok->ucs_char = 0; tok->st_pos = 0; state = json_tokener_state_escape_unicode; break; default: tok->err = json_tokener_error_parse_string; goto out; } break; // =================================================== case json_tokener_state_escape_unicode: { /* Handle a 4-byte \uNNNN sequence, or two sequences if a surrogate pair */ while (1) { if (!c || !is_hex_char(c)) { tok->err = json_tokener_error_parse_string; goto out; } tok->ucs_char |= ((unsigned int)jt_hexdigit(c) << ((3 - tok->st_pos) * 4)); tok->st_pos++; if (tok->st_pos >= 4) break; (void)ADVANCE_CHAR(str, tok); if (!PEEK_CHAR(c, tok)) { /* * We're out of characters in the current call to * json_tokener_parse(), but a subsequent call might * provide us with more, so leave our current state * as-is (including tok->high_surrogate) and return. */ goto out; } } tok->st_pos = 0; /* Now, we have a full \uNNNN sequence in tok->ucs_char */ /* If the *previous* sequence was a high surrogate ... */ if (tok->high_surrogate) { if (IS_LOW_SURROGATE(tok->ucs_char)) { /* Recalculate the ucs_char, then fall thru to process normally */ tok->ucs_char = DECODE_SURROGATE_PAIR(tok->high_surrogate, tok->ucs_char); } else { /* High surrogate was not followed by a low surrogate * Replace the high and process the rest normally */ printbuf_memappend_checked(tok->pb, (char *)utf8_replacement_char, 3); } tok->high_surrogate = 0; } if (tok->ucs_char < 0x80) { unsigned char unescaped_utf[1]; unescaped_utf[0] = tok->ucs_char; printbuf_memappend_checked(tok->pb, (char *)unescaped_utf, 1); } else if (tok->ucs_char < 0x800) { unsigned char unescaped_utf[2]; unescaped_utf[0] = 0xc0 | (tok->ucs_char >> 6); unescaped_utf[1] = 0x80 | (tok->ucs_char & 0x3f); printbuf_memappend_checked(tok->pb, (char *)unescaped_utf, 2); } else if (IS_HIGH_SURROGATE(tok->ucs_char)) { /* * The next two characters should be \u, HOWEVER, * we can't simply peek ahead here, because the * characters we need might not be passed to us * until a subsequent call to json_tokener_parse. * Instead, transition through a couple of states. * (now): * _escape_unicode => _unicode_need_escape * (see a '\\' char): * _unicode_need_escape => _unicode_need_u * (see a 'u' char): * _unicode_need_u => _escape_unicode * ...and we'll end up back around here. */ tok->high_surrogate = tok->ucs_char; tok->ucs_char = 0; state = json_tokener_state_escape_unicode_need_escape; break; } else if (IS_LOW_SURROGATE(tok->ucs_char)) { /* Got a low surrogate not preceded by a high */ printbuf_memappend_checked(tok->pb, (char *)utf8_replacement_char, 3); } else if (tok->ucs_char < 0x10000) { unsigned char unescaped_utf[3]; unescaped_utf[0] = 0xe0 | (tok->ucs_char >> 12); unescaped_utf[1] = 0x80 | ((tok->ucs_char >> 6) & 0x3f); unescaped_utf[2] = 0x80 | (tok->ucs_char & 0x3f); printbuf_memappend_checked(tok->pb, (char *)unescaped_utf, 3); } else if (tok->ucs_char < 0x110000) { unsigned char unescaped_utf[4]; unescaped_utf[0] = 0xf0 | ((tok->ucs_char >> 18) & 0x07); unescaped_utf[1] = 0x80 | ((tok->ucs_char >> 12) & 0x3f); unescaped_utf[2] = 0x80 | ((tok->ucs_char >> 6) & 0x3f); unescaped_utf[3] = 0x80 | (tok->ucs_char & 0x3f); printbuf_memappend_checked(tok->pb, (char *)unescaped_utf, 4); } else { /* Don't know what we got--insert the replacement char */ printbuf_memappend_checked(tok->pb, (char *)utf8_replacement_char, 3); } state = saved_state; // i.e. _state_string or _state_object_field } break; case json_tokener_state_escape_unicode_need_escape: // We get here after processing a high_surrogate // require a '\\' char if (!c || c != '\\') { /* Got a high surrogate without another sequence following * it. Put a replacement char in for the high surrogate * and pop back up to _state_string or _state_object_field. */ printbuf_memappend_checked(tok->pb, (char *)utf8_replacement_char, 3); tok->high_surrogate = 0; tok->ucs_char = 0; tok->st_pos = 0; state = saved_state; goto redo_char; } state = json_tokener_state_escape_unicode_need_u; break; case json_tokener_state_escape_unicode_need_u: /* We already had a \ char, check that it's \u */ if (!c || c != 'u') { /* Got a high surrogate with some non-unicode escape * sequence following it. * Put a replacement char in for the high surrogate * and handle the escape sequence normally. */ printbuf_memappend_checked(tok->pb, (char *)utf8_replacement_char, 3); tok->high_surrogate = 0; tok->ucs_char = 0; tok->st_pos = 0; state = json_tokener_state_string_escape; goto redo_char; } state = json_tokener_state_escape_unicode; break; // =================================================== case json_tokener_state_boolean: { int size1, size2; printbuf_memappend_checked(tok->pb, &c, 1); size1 = json_min(tok->st_pos + 1, json_true_str_len); size2 = json_min(tok->st_pos + 1, json_false_str_len); if ((!(tok->flags & JSON_TOKENER_STRICT) && strncasecmp(json_true_str, tok->pb->buf, size1) == 0) || (strncmp(json_true_str, tok->pb->buf, size1) == 0)) { if (tok->st_pos == json_true_str_len) { current = json_object_new_boolean(1); if (current == NULL) { tok->err = json_tokener_error_memory; goto out; } saved_state = json_tokener_state_finish; state = json_tokener_state_eatws; goto redo_char; } } else if ((!(tok->flags & JSON_TOKENER_STRICT) && strncasecmp(json_false_str, tok->pb->buf, size2) == 0) || (strncmp(json_false_str, tok->pb->buf, size2) == 0)) { if (tok->st_pos == json_false_str_len) { current = json_object_new_boolean(0); if (current == NULL) { tok->err = json_tokener_error_memory; goto out; } saved_state = json_tokener_state_finish; state = json_tokener_state_eatws; goto redo_char; } } else { tok->err = json_tokener_error_parse_boolean; goto out; } tok->st_pos++; } break; case json_tokener_state_number: { /* Advance until we change state */ const char *case_start = str; int case_len = 0; int is_exponent = 0; int neg_sign_ok = 1; int pos_sign_ok = 0; if (printbuf_length(tok->pb) > 0) { /* We don't save all state from the previous incremental parse so we need to re-generate it based on the saved string so far. */ char *e_loc = strchr(tok->pb->buf, 'e'); if (!e_loc) e_loc = strchr(tok->pb->buf, 'E'); if (e_loc) { char *last_saved_char = &tok->pb->buf[printbuf_length(tok->pb) - 1]; is_exponent = 1; pos_sign_ok = neg_sign_ok = 1; /* If the "e" isn't at the end, we can't start with a '-' */ if (e_loc != last_saved_char) { neg_sign_ok = 0; pos_sign_ok = 0; } // else leave it set to 1, i.e. start of the new input } } while (c && ((c >= '0' && c <= '9') || (!is_exponent && (c == 'e' || c == 'E')) || (neg_sign_ok && c == '-') || (pos_sign_ok && c == '+') || (!tok->is_double && c == '.'))) { pos_sign_ok = neg_sign_ok = 0; ++case_len; /* non-digit characters checks */ /* note: since the main loop condition to get here was * an input starting with 0-9 or '-', we are * protected from input starting with '.' or * e/E. */ switch (c) { case '.': tok->is_double = 1; pos_sign_ok = 1; neg_sign_ok = 1; break; case 'e': /* FALLTHRU */ case 'E': is_exponent = 1; tok->is_double = 1; /* the exponent part can begin with a negative sign */ pos_sign_ok = neg_sign_ok = 1; break; default: break; } if (!ADVANCE_CHAR(str, tok) || !PEEK_CHAR(c, tok)) { printbuf_memappend_checked(tok->pb, case_start, case_len); goto out; } } /* Now we know c isn't a valid number char, but check whether it might have been intended to be, and return a potentially more understandable error right away. However, if we're at the top-level, use the number as-is because c can be part of a new object to parse on the next call to json_tokener_parse(). */ if (tok->depth > 0 && c != ',' && c != ']' && c != '}' && c != '/' && c != 'I' && c != 'i' && !is_ws_char(c)) { tok->err = json_tokener_error_parse_number; goto out; } if (case_len > 0) printbuf_memappend_checked(tok->pb, case_start, case_len); // Check for -Infinity if (tok->pb->buf[0] == '-' && case_len <= 1 && (c == 'i' || c == 'I')) { state = json_tokener_state_inf; tok->st_pos = 0; goto redo_char; } if (tok->is_double && !(tok->flags & JSON_TOKENER_STRICT)) { /* Trim some chars off the end, to allow things like "123e+" to parse ok. */ while (printbuf_length(tok->pb) > 1) { char last_char = tok->pb->buf[printbuf_length(tok->pb) - 1]; if (last_char != 'e' && last_char != 'E' && last_char != '-' && last_char != '+') { break; } tok->pb->buf[printbuf_length(tok->pb) - 1] = '\0'; printbuf_length(tok->pb)--; } } } { int64_t num64; uint64_t numuint64; double numd; if (!tok->is_double && tok->pb->buf[0] == '-' && json_parse_int64(tok->pb->buf, &num64) == 0) { if (errno == ERANGE && (tok->flags & JSON_TOKENER_STRICT)) { tok->err = json_tokener_error_parse_number; goto out; } current = json_object_new_int64(num64); if (current == NULL) { tok->err = json_tokener_error_memory; goto out; } } else if (!tok->is_double && tok->pb->buf[0] != '-' && json_parse_uint64(tok->pb->buf, &numuint64) == 0) { if (errno == ERANGE && (tok->flags & JSON_TOKENER_STRICT)) { tok->err = json_tokener_error_parse_number; goto out; } if (numuint64 && tok->pb->buf[0] == '0' && (tok->flags & JSON_TOKENER_STRICT)) { tok->err = json_tokener_error_parse_number; goto out; } if (numuint64 <= INT64_MAX) { num64 = (uint64_t)numuint64; current = json_object_new_int64(num64); if (current == NULL) { tok->err = json_tokener_error_memory; goto out; } } else { current = json_object_new_uint64(numuint64); if (current == NULL) { tok->err = json_tokener_error_memory; goto out; } } } else if (tok->is_double && json_tokener_parse_double( tok->pb->buf, printbuf_length(tok->pb), &numd) == 0) { current = json_object_new_double_s(numd, tok->pb->buf); if (current == NULL) { tok->err = json_tokener_error_memory; goto out; } } else { tok->err = json_tokener_error_parse_number; goto out; } saved_state = json_tokener_state_finish; state = json_tokener_state_eatws; goto redo_char; } break; case json_tokener_state_array_after_sep: case json_tokener_state_array: if (c == ']') { // Minimize memory usage; assume parsed objs are unlikely to be changed json_object_array_shrink(current, 0); if (state == json_tokener_state_array_after_sep && (tok->flags & JSON_TOKENER_STRICT)) { tok->err = json_tokener_error_parse_unexpected; goto out; } saved_state = json_tokener_state_finish; state = json_tokener_state_eatws; } else { if (tok->depth >= tok->max_depth - 1) { tok->err = json_tokener_error_depth; goto out; } state = json_tokener_state_array_add; tok->depth++; json_tokener_reset_level(tok, tok->depth); goto redo_char; } break; case json_tokener_state_array_add: if (json_object_array_add(current, obj) != 0) { tok->err = json_tokener_error_memory; goto out; } saved_state = json_tokener_state_array_sep; state = json_tokener_state_eatws; goto redo_char; case json_tokener_state_array_sep: if (c == ']') { // Minimize memory usage; assume parsed objs are unlikely to be changed json_object_array_shrink(current, 0); saved_state = json_tokener_state_finish; state = json_tokener_state_eatws; } else if (c == ',') { saved_state = json_tokener_state_array_after_sep; state = json_tokener_state_eatws; } else { tok->err = json_tokener_error_parse_array; goto out; } break; case json_tokener_state_object_field_start: case json_tokener_state_object_field_start_after_sep: if (c == '}') { if (state == json_tokener_state_object_field_start_after_sep && (tok->flags & JSON_TOKENER_STRICT)) { tok->err = json_tokener_error_parse_unexpected; goto out; } saved_state = json_tokener_state_finish; state = json_tokener_state_eatws; } else if (c == '"' || c == '\'') { tok->quote_char = c; printbuf_reset(tok->pb); state = json_tokener_state_object_field; } else { tok->err = json_tokener_error_parse_object_key_name; goto out; } break; case json_tokener_state_object_field: { /* Advance until we change state */ const char *case_start = str; while (1) { if (c == tok->quote_char) { printbuf_memappend_checked(tok->pb, case_start, str - case_start); obj_field_name = strdup(tok->pb->buf); if (obj_field_name == NULL) { tok->err = json_tokener_error_memory; goto out; } saved_state = json_tokener_state_object_field_end; state = json_tokener_state_eatws; break; } else if (c == '\\') { printbuf_memappend_checked(tok->pb, case_start, str - case_start); saved_state = json_tokener_state_object_field; state = json_tokener_state_string_escape; break; } if (!ADVANCE_CHAR(str, tok) || !PEEK_CHAR(c, tok)) { printbuf_memappend_checked(tok->pb, case_start, str - case_start); goto out; } } } break; case json_tokener_state_object_field_end: if (c == ':') { saved_state = json_tokener_state_object_value; state = json_tokener_state_eatws; } else { tok->err = json_tokener_error_parse_object_key_sep; goto out; } break; case json_tokener_state_object_value: if (tok->depth >= tok->max_depth - 1) { tok->err = json_tokener_error_depth; goto out; } state = json_tokener_state_object_value_add; tok->depth++; json_tokener_reset_level(tok, tok->depth); goto redo_char; case json_tokener_state_object_value_add: json_object_object_add(current, obj_field_name, obj); free(obj_field_name); obj_field_name = NULL; saved_state = json_tokener_state_object_sep; state = json_tokener_state_eatws; goto redo_char; case json_tokener_state_object_sep: /* { */ if (c == '}') { saved_state = json_tokener_state_finish; state = json_tokener_state_eatws; } else if (c == ',') { saved_state = json_tokener_state_object_field_start_after_sep; state = json_tokener_state_eatws; } else { tok->err = json_tokener_error_parse_object_value_sep; goto out; } break; } (void)ADVANCE_CHAR(str, tok); if (!c) // This is the char *before* advancing break; } /* while(PEEK_CHAR) */ out: if ((tok->flags & JSON_TOKENER_VALIDATE_UTF8) && (nBytes != 0)) { tok->err = json_tokener_error_parse_utf8_string; } if (c && (state == json_tokener_state_finish) && (tok->depth == 0) && (tok->flags & (JSON_TOKENER_STRICT | JSON_TOKENER_ALLOW_TRAILING_CHARS)) == JSON_TOKENER_STRICT) { /* unexpected char after JSON data */ tok->err = json_tokener_error_parse_unexpected; } if (!c) { /* We hit an eof char (0) */ if (state != json_tokener_state_finish && saved_state != json_tokener_state_finish) tok->err = json_tokener_error_parse_eof; } #ifdef HAVE_USELOCALE uselocale(oldlocale); freelocale(newloc); #elif defined(HAVE_SETLOCALE) setlocale(LC_NUMERIC, oldlocale); free(oldlocale); #endif if (tok->err == json_tokener_success) { json_object *ret = json_object_get(current); int ii; /* Partially reset, so we parse additional objects on subsequent calls. */ for (ii = tok->depth; ii >= 0; ii--) json_tokener_reset_level(tok, ii); return ret; } MC_DEBUG("json_tokener_parse_ex: error %s at offset %d\n", json_tokener_errors[tok->err], tok->char_offset); return NULL; } static json_bool json_tokener_validate_utf8(const char c, unsigned int *nBytes) { unsigned char chr = c; if (*nBytes == 0) { if (chr >= 0x80) { if ((chr & 0xe0) == 0xc0) *nBytes = 1; else if ((chr & 0xf0) == 0xe0) *nBytes = 2; else if ((chr & 0xf8) == 0xf0) *nBytes = 3; else return 0; } } else { if ((chr & 0xC0) != 0x80) return 0; (*nBytes)--; } return 1; } void json_tokener_set_flags(struct json_tokener *tok, int flags) { tok->flags = flags; } size_t json_tokener_get_parse_end(struct json_tokener *tok) { assert(tok->char_offset >= 0); /* Drop this line when char_offset becomes a size_t */ return (size_t)tok->char_offset; } static int json_tokener_parse_double(const char *buf, int len, double *retval) { char *end; *retval = strtod(buf, &end); if (buf + len == end) return 0; // It worked return 1; } json-c-json-c-0.17-20230812/json_tokener.h000066400000000000000000000244321446575330000176050ustar00rootroot00000000000000/* * $Id: json_tokener.h,v 1.10 2006/07/25 03:24:50 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Methods to parse an input string into a tree of json_object objects. */ #ifndef _json_tokener_h_ #define _json_tokener_h_ #include "json_object.h" #include #ifdef __cplusplus extern "C" { #endif enum json_tokener_error { json_tokener_success, json_tokener_continue, json_tokener_error_depth, json_tokener_error_parse_eof, json_tokener_error_parse_unexpected, json_tokener_error_parse_null, json_tokener_error_parse_boolean, json_tokener_error_parse_number, json_tokener_error_parse_array, json_tokener_error_parse_object_key_name, json_tokener_error_parse_object_key_sep, json_tokener_error_parse_object_value_sep, json_tokener_error_parse_string, json_tokener_error_parse_comment, json_tokener_error_parse_utf8_string, json_tokener_error_memory, json_tokener_error_size }; /** * @deprecated Don't use this outside of json_tokener.c, it will be made private in a future release. */ enum json_tokener_state { json_tokener_state_eatws, json_tokener_state_start, json_tokener_state_finish, json_tokener_state_null, json_tokener_state_comment_start, json_tokener_state_comment, json_tokener_state_comment_eol, json_tokener_state_comment_end, json_tokener_state_string, json_tokener_state_string_escape, json_tokener_state_escape_unicode, json_tokener_state_escape_unicode_need_escape, json_tokener_state_escape_unicode_need_u, json_tokener_state_boolean, json_tokener_state_number, json_tokener_state_array, json_tokener_state_array_add, json_tokener_state_array_sep, json_tokener_state_object_field_start, json_tokener_state_object_field, json_tokener_state_object_field_end, json_tokener_state_object_value, json_tokener_state_object_value_add, json_tokener_state_object_sep, json_tokener_state_array_after_sep, json_tokener_state_object_field_start_after_sep, json_tokener_state_inf }; /** * @deprecated Don't use this outside of json_tokener.c, it will be made private in a future release. */ struct json_tokener_srec { enum json_tokener_state state, saved_state; struct json_object *obj; struct json_object *current; char *obj_field_name; }; #define JSON_TOKENER_DEFAULT_DEPTH 32 /** * Internal state of the json parser. * Do not access any fields of this structure directly. * Its definition is published due to historical limitations * in the json tokener API, and will be changed to be an opaque * type in the future. */ struct json_tokener { /** * @deprecated Do not access any of these fields outside of json_tokener.c */ char *str; struct printbuf *pb; int max_depth, depth, is_double, st_pos; /** * @deprecated See json_tokener_get_parse_end() instead. */ int char_offset; /** * @deprecated See json_tokener_get_error() instead. */ enum json_tokener_error err; unsigned int ucs_char, high_surrogate; char quote_char; struct json_tokener_srec *stack; int flags; }; /** * Return the offset of the byte after the last byte parsed * relative to the start of the most recent string passed in * to json_tokener_parse_ex(). i.e. this is where parsing * would start again if the input contains another JSON object * after the currently parsed one. * * Note that when multiple parse calls are issued, this is *not* the * total number of characters parsed. * * In the past this would have been accessed as tok->char_offset. * * See json_tokener_parse_ex() for an example of how to use this. */ JSON_EXPORT size_t json_tokener_get_parse_end(struct json_tokener *tok); /** * @deprecated Unused in json-c code */ typedef struct json_tokener json_tokener; /** * Be strict when parsing JSON input. Use caution with * this flag as what is considered valid may become more * restrictive from one release to the next, causing your * code to fail on previously working input. * * Note that setting this will also effectively disable parsing * of multiple json objects in a single character stream * (e.g. {"foo":123}{"bar":234}); if you want to allow that * also set JSON_TOKENER_ALLOW_TRAILING_CHARS * * This flag is not set by default. * * @see json_tokener_set_flags() */ #define JSON_TOKENER_STRICT 0x01 /** * Use with JSON_TOKENER_STRICT to allow trailing characters after the * first parsed object. * * @see json_tokener_set_flags() */ #define JSON_TOKENER_ALLOW_TRAILING_CHARS 0x02 /** * Cause json_tokener_parse_ex() to validate that input is UTF8. * If this flag is specified and validation fails, then * json_tokener_get_error(tok) will return * json_tokener_error_parse_utf8_string * * This flag is not set by default. * * @see json_tokener_set_flags() */ #define JSON_TOKENER_VALIDATE_UTF8 0x10 /** * Given an error previously returned by json_tokener_get_error(), * return a human readable description of the error. * * @return a generic error message is returned if an invalid error value is provided. */ JSON_EXPORT const char *json_tokener_error_desc(enum json_tokener_error jerr); /** * Retrieve the error caused by the last call to json_tokener_parse_ex(), * or json_tokener_success if there is no error. * * When parsing a JSON string in pieces, if the tokener is in the middle * of parsing this will return json_tokener_continue. * * @see json_tokener_error_desc(). */ JSON_EXPORT enum json_tokener_error json_tokener_get_error(struct json_tokener *tok); /** * Allocate a new json_tokener. * When done using that to parse objects, free it with json_tokener_free(). * See json_tokener_parse_ex() for usage details. */ JSON_EXPORT struct json_tokener *json_tokener_new(void); /** * Allocate a new json_tokener with a custom max nesting depth. * @see JSON_TOKENER_DEFAULT_DEPTH */ JSON_EXPORT struct json_tokener *json_tokener_new_ex(int depth); /** * Free a json_tokener previously allocated with json_tokener_new(). */ JSON_EXPORT void json_tokener_free(struct json_tokener *tok); /** * Reset the state of a json_tokener, to prepare to parse a * brand new JSON object. */ JSON_EXPORT void json_tokener_reset(struct json_tokener *tok); /** * Parse a json_object out of the string `str`. * * If you need more control over how the parsing occurs, * see json_tokener_parse_ex(). */ JSON_EXPORT struct json_object *json_tokener_parse(const char *str); /** * Parser a json_object out of the string `str`, but if it fails * return the error in `*error`. * @see json_tokener_parse() * @see json_tokener_parse_ex() */ JSON_EXPORT struct json_object *json_tokener_parse_verbose(const char *str, enum json_tokener_error *error); /** * Set flags that control how parsing will be done. */ JSON_EXPORT void json_tokener_set_flags(struct json_tokener *tok, int flags); /** * Parse a string and return a non-NULL json_object if a valid JSON value * is found. The string does not need to be a JSON object or array; * it can also be a string, number or boolean value. * * A partial JSON string can be parsed. If the parsing is incomplete, * NULL will be returned and json_tokener_get_error() will return * json_tokener_continue. * json_tokener_parse_ex() can then be called with additional bytes in str * to continue the parsing. * * If json_tokener_parse_ex() returns NULL and the error is anything other than * json_tokener_continue, a fatal error has occurred and parsing must be * halted. Then, the tok object must not be reused until json_tokener_reset() * is called. * * When a valid JSON value is parsed, a non-NULL json_object will be * returned, with a reference count of one which belongs to the caller. Also, * json_tokener_get_error() will return json_tokener_success. Be sure to check * the type with json_object_is_type() or json_object_get_type() before using * the object. * * Trailing characters after the parsed value do not automatically cause an * error. It is up to the caller to decide whether to treat this as an * error or to handle the additional characters, perhaps by parsing another * json value starting from that point. * * If the caller knows that they are at the end of their input, the length * passed MUST include the final '\0' character, so values with no inherent * end (i.e. numbers) can be properly parsed, rather than just returning * json_tokener_continue. * * Extra characters can be detected by comparing the value returned by * json_tokener_get_parse_end() against * the length of the last len parameter passed in. * * The tokener does \b not maintain an internal buffer so the caller is * responsible for a subsequent call to json_tokener_parse_ex with an * appropriate str parameter starting with the extra characters. * * This interface is presently not 64-bit clean due to the int len argument * so the function limits the maximum string size to INT32_MAX (2GB). * If the function is called with len == -1 then strlen is called to check * the string length is less than INT32_MAX (2GB) * * Example: * @code json_object *jobj = NULL; const char *mystring = NULL; int stringlen = 0; enum json_tokener_error jerr; do { mystring = ... // get JSON string, e.g. read from file, etc... stringlen = strlen(mystring); if (end_of_input) stringlen++; // Include the '\0' if we know we're at the end of input jobj = json_tokener_parse_ex(tok, mystring, stringlen); } while ((jerr = json_tokener_get_error(tok)) == json_tokener_continue); if (jerr != json_tokener_success) { fprintf(stderr, "Error: %s\n", json_tokener_error_desc(jerr)); // Handle errors, as appropriate for your application. } if (json_tokener_get_parse_end(tok) < stringlen) { // Handle extra characters after parsed object as desired. // e.g. issue an error, parse another object from that point, etc... } // Success, use jobj here. @endcode * * @param tok a json_tokener previously allocated with json_tokener_new() * @param str an string with any valid JSON expression, or portion of. This does not need to be null terminated. * @param len the length of str */ JSON_EXPORT struct json_object *json_tokener_parse_ex(struct json_tokener *tok, const char *str, int len); #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/json_types.h000066400000000000000000000032021446575330000172720ustar00rootroot00000000000000/* * Copyright (c) 2020 Eric Hawicz * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. */ #ifndef _json_types_h_ #define _json_types_h_ /** * @file * @brief Basic types used in a few places in json-c, but you should include "json_object.h" instead. */ #ifdef __cplusplus extern "C" { #endif #ifndef JSON_EXPORT #if defined(_MSC_VER) && defined(JSON_C_DLL) #define JSON_EXPORT __declspec(dllexport) #else #define JSON_EXPORT extern #endif #endif struct printbuf; /** * A structure to use with json_object_object_foreachC() loops. * Contains key, val and entry members. */ struct json_object_iter { char *key; struct json_object *val; struct lh_entry *entry; }; typedef struct json_object_iter json_object_iter; typedef int json_bool; /** * @brief The core type for all type of JSON objects handled by json-c */ typedef struct json_object json_object; /** * Type of custom user delete functions. See json_object_set_serializer. */ typedef void(json_object_delete_fn)(struct json_object *jso, void *userdata); /** * Type of a custom serialization function. See json_object_set_serializer. */ typedef int(json_object_to_json_string_fn)(struct json_object *jso, struct printbuf *pb, int level, int flags); /* supported object types */ typedef enum json_type { /* If you change this, be sure to update json_type_to_name() too */ json_type_null, json_type_boolean, json_type_double, json_type_int, json_type_object, json_type_array, json_type_string } json_type; #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/json_util.c000066400000000000000000000153651446575330000171130ustar00rootroot00000000000000/* * $Id: json_util.c,v 1.4 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ #include "config.h" #undef realloc #include "strerror_override.h" #include #include #include #include #include #include #ifdef HAVE_SYS_TYPES_H #include #endif /* HAVE_SYS_TYPES_H */ #ifdef HAVE_SYS_STAT_H #include #endif /* HAVE_SYS_STAT_H */ #ifdef HAVE_FCNTL_H #include #endif /* HAVE_FCNTL_H */ #ifdef HAVE_UNISTD_H #include #endif /* HAVE_UNISTD_H */ #ifdef WIN32 #define WIN32_LEAN_AND_MEAN #include #include #endif /* defined(WIN32) */ #if !defined(HAVE_OPEN) && defined(WIN32) #define open _open #endif #include "snprintf_compat.h" #include "debug.h" #include "json_inttypes.h" #include "json_object.h" #include "json_tokener.h" #include "json_util.h" #include "printbuf.h" static int _json_object_to_fd(int fd, struct json_object *obj, int flags, const char *filename); static char _last_err[256] = ""; const char *json_util_get_last_err(void) { if (_last_err[0] == '\0') return NULL; return _last_err; } void _json_c_set_last_err(const char *err_fmt, ...) { va_list ap; va_start(ap, err_fmt); // Ignore (attempted) overruns from snprintf (void)vsnprintf(_last_err, sizeof(_last_err), err_fmt, ap); va_end(ap); } struct json_object *json_object_from_fd(int fd) { return json_object_from_fd_ex(fd, -1); } struct json_object *json_object_from_fd_ex(int fd, int in_depth) { struct printbuf *pb; struct json_object *obj; char buf[JSON_FILE_BUF_SIZE]; ssize_t ret; int depth = JSON_TOKENER_DEFAULT_DEPTH; json_tokener *tok; if (!(pb = printbuf_new())) { _json_c_set_last_err("json_object_from_fd_ex: printbuf_new failed\n"); return NULL; } if (in_depth != -1) depth = in_depth; tok = json_tokener_new_ex(depth); if (!tok) { _json_c_set_last_err( "json_object_from_fd_ex: unable to allocate json_tokener(depth=%d): %s\n", depth, strerror(errno)); printbuf_free(pb); return NULL; } while ((ret = read(fd, buf, sizeof(buf))) > 0) { if (printbuf_memappend(pb, buf, ret) < 0) { #if JSON_FILE_BUF_SIZE > INT_MAX #error "Can't append more than INT_MAX bytes at a time" #endif _json_c_set_last_err( "json_object_from_fd_ex: failed to printbuf_memappend after reading %d+%d bytes: %s", printbuf_length(pb), (int)ret, strerror(errno)); json_tokener_free(tok); printbuf_free(pb); return NULL; } } if (ret < 0) { _json_c_set_last_err("json_object_from_fd_ex: error reading fd %d: %s\n", fd, strerror(errno)); json_tokener_free(tok); printbuf_free(pb); return NULL; } obj = json_tokener_parse_ex(tok, pb->buf, printbuf_length(pb)); if (obj == NULL) _json_c_set_last_err("json_tokener_parse_ex failed: %s\n", json_tokener_error_desc(json_tokener_get_error(tok))); json_tokener_free(tok); printbuf_free(pb); return obj; } struct json_object *json_object_from_file(const char *filename) { struct json_object *obj; int fd; if ((fd = open(filename, O_RDONLY)) < 0) { _json_c_set_last_err("json_object_from_file: error opening file %s: %s\n", filename, strerror(errno)); return NULL; } obj = json_object_from_fd(fd); close(fd); return obj; } /* extended "format and write to file" function */ int json_object_to_file_ext(const char *filename, struct json_object *obj, int flags) { int fd, ret; int saved_errno; if (!obj) { _json_c_set_last_err("json_object_to_file_ext: object is null\n"); return -1; } if ((fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT, 0644)) < 0) { _json_c_set_last_err("json_object_to_file_ext: error opening file %s: %s\n", filename, strerror(errno)); return -1; } ret = _json_object_to_fd(fd, obj, flags, filename); saved_errno = errno; close(fd); errno = saved_errno; return ret; } int json_object_to_fd(int fd, struct json_object *obj, int flags) { if (!obj) { _json_c_set_last_err("json_object_to_fd: object is null\n"); return -1; } return _json_object_to_fd(fd, obj, flags, NULL); } static int _json_object_to_fd(int fd, struct json_object *obj, int flags, const char *filename) { ssize_t ret; const char *json_str; size_t wpos, wsize; filename = filename ? filename : "(fd)"; if (!(json_str = json_object_to_json_string_ext(obj, flags))) { return -1; } wsize = strlen(json_str); wpos = 0; while (wpos < wsize) { if ((ret = write(fd, json_str + wpos, wsize - wpos)) < 0) { _json_c_set_last_err("json_object_to_fd: error writing file %s: %s\n", filename, strerror(errno)); return -1; } /* because of the above check for ret < 0, we can safely cast and add */ wpos += (size_t)ret; } return 0; } // backwards compatible "format and write to file" function int json_object_to_file(const char *filename, struct json_object *obj) { return json_object_to_file_ext(filename, obj, JSON_C_TO_STRING_PLAIN); } // Deprecated json_parse_double function. See json_tokener_parse_double instead. int json_parse_double(const char *buf, double *retval) { char *end; *retval = strtod(buf, &end); return end == buf ? 1 : 0; } int json_parse_int64(const char *buf, int64_t *retval) { char *end = NULL; int64_t val; errno = 0; val = strtoll(buf, &end, 10); if (end != buf) *retval = val; if ((val == 0 && errno != 0) || (end == buf)) { errno = EINVAL; return 1; } return 0; } int json_parse_uint64(const char *buf, uint64_t *retval) { char *end = NULL; uint64_t val; errno = 0; while (*buf == ' ') buf++; if (*buf == '-') return 1; /* error: uint cannot be negative */ val = strtoull(buf, &end, 10); if (end != buf) *retval = val; if ((val == 0 && errno != 0) || (end == buf)) { errno = EINVAL; return 1; } return 0; } #ifndef HAVE_REALLOC void *rpl_realloc(void *p, size_t n) { if (n == 0) n = 1; if (p == 0) return malloc(n); return realloc(p, n); } #endif #define NELEM(a) (sizeof(a) / sizeof(a[0])) /* clang-format off */ static const char *json_type_name[] = { /* If you change this, be sure to update the enum json_type definition too */ "null", "boolean", "double", "int", "object", "array", "string", }; /* clang-format on */ const char *json_type_to_name(enum json_type o_type) { int o_type_int = (int)o_type; if (o_type_int < 0 || o_type_int >= (int)NELEM(json_type_name)) { _json_c_set_last_err("json_type_to_name: type %d is out of range [0,%u]\n", o_type, (unsigned)NELEM(json_type_name)); return NULL; } return json_type_name[o_type]; } json-c-json-c-0.17-20230812/json_util.h000066400000000000000000000075201446575330000171120ustar00rootroot00000000000000/* * $Id: json_util.h,v 1.4 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Miscllaneous utility functions and macros. */ #ifndef _json_util_h_ #define _json_util_h_ #include "json_object.h" #ifndef json_min #define json_min(a, b) ((a) < (b) ? (a) : (b)) #endif #ifndef json_max #define json_max(a, b) ((a) > (b) ? (a) : (b)) #endif #ifdef __cplusplus extern "C" { #endif #define JSON_FILE_BUF_SIZE 4096 /* utility functions */ /** * Read the full contents of the given file, then convert it to a * json_object using json_tokener_parse(). * * Returns NULL on failure. See json_util_get_last_err() for details. */ JSON_EXPORT struct json_object *json_object_from_file(const char *filename); /** * Create a JSON object from already opened file descriptor. * * This function can be helpful, when you opened the file already, * e.g. when you have a temp file. * Note, that the fd must be readable at the actual position, i.e. * use lseek(fd, 0, SEEK_SET) before. * * The depth argument specifies the maximum object depth to pass to * json_tokener_new_ex(). When depth == -1, JSON_TOKENER_DEFAULT_DEPTH * is used instead. * * Returns NULL on failure. See json_util_get_last_err() for details. */ JSON_EXPORT struct json_object *json_object_from_fd_ex(int fd, int depth); /** * Create a JSON object from an already opened file descriptor, using * the default maximum object depth. (JSON_TOKENER_DEFAULT_DEPTH) * * See json_object_from_fd_ex() for details. */ JSON_EXPORT struct json_object *json_object_from_fd(int fd); /** * Equivalent to: * json_object_to_file_ext(filename, obj, JSON_C_TO_STRING_PLAIN); * * Returns -1 if something fails. See json_util_get_last_err() for details. */ JSON_EXPORT int json_object_to_file(const char *filename, struct json_object *obj); /** * Open and truncate the given file, creating it if necessary, then * convert the json_object to a string and write it to the file. * * Returns -1 if something fails. See json_util_get_last_err() for details. */ JSON_EXPORT int json_object_to_file_ext(const char *filename, struct json_object *obj, int flags); /** * Convert the json_object to a string and write it to the file descriptor. * Handles partial writes and will keep writing until done, or an error * occurs. * * @param fd an open, writable file descriptor to write to * @param obj the object to serializer and write * @param flags flags to pass to json_object_to_json_string_ext() * @return -1 if something fails. See json_util_get_last_err() for details. */ JSON_EXPORT int json_object_to_fd(int fd, struct json_object *obj, int flags); /** * Return the last error from various json-c functions, including: * json_object_to_file{,_ext}, json_object_to_fd() or * json_object_from_{file,fd}, or NULL if there is none. */ JSON_EXPORT const char *json_util_get_last_err(void); /** * A parsing helper for integer values. Returns 0 on success, * with the parsed value assigned to *retval. Overflow/underflow * are NOT considered errors, but errno will be set to ERANGE, * just like the strtol/strtoll functions do. */ JSON_EXPORT int json_parse_int64(const char *buf, int64_t *retval); /** * A parsing help for integer values, providing one extra bit of * magnitude beyond json_parse_int64(). */ JSON_EXPORT int json_parse_uint64(const char *buf, uint64_t *retval); /** * @deprecated */ JSON_EXPORT int json_parse_double(const char *buf, double *retval); /** * Return a string describing the type of the object. * e.g. "int", or "object", etc... */ JSON_EXPORT const char *json_type_to_name(enum json_type o_type); #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/json_visit.c000066400000000000000000000076151446575330000172730ustar00rootroot00000000000000/* * Copyright (c) 2016 Eric Haszlakiewicz * * This is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. */ #include #include "config.h" #include "json_inttypes.h" #include "json_object.h" #include "json_visit.h" #include "linkhash.h" static int _json_c_visit(json_object *jso, json_object *parent_jso, const char *jso_key, size_t *jso_index, json_c_visit_userfunc *userfunc, void *userarg); int json_c_visit(json_object *jso, int future_flags, json_c_visit_userfunc *userfunc, void *userarg) { int ret = _json_c_visit(jso, NULL, NULL, NULL, userfunc, userarg); switch (ret) { case JSON_C_VISIT_RETURN_CONTINUE: case JSON_C_VISIT_RETURN_SKIP: case JSON_C_VISIT_RETURN_POP: case JSON_C_VISIT_RETURN_STOP: return 0; default: return JSON_C_VISIT_RETURN_ERROR; } } static int _json_c_visit(json_object *jso, json_object *parent_jso, const char *jso_key, size_t *jso_index, json_c_visit_userfunc *userfunc, void *userarg) { int userret = userfunc(jso, 0, parent_jso, jso_key, jso_index, userarg); switch (userret) { case JSON_C_VISIT_RETURN_CONTINUE: break; case JSON_C_VISIT_RETURN_SKIP: case JSON_C_VISIT_RETURN_POP: case JSON_C_VISIT_RETURN_STOP: case JSON_C_VISIT_RETURN_ERROR: return userret; default: fprintf(stderr, "ERROR: invalid return value from json_c_visit userfunc: %d\n", userret); return JSON_C_VISIT_RETURN_ERROR; } switch (json_object_get_type(jso)) { case json_type_null: case json_type_boolean: case json_type_double: case json_type_int: case json_type_string: // we already called userfunc above, move on to the next object return JSON_C_VISIT_RETURN_CONTINUE; case json_type_object: { json_object_object_foreach(jso, key, child) { userret = _json_c_visit(child, jso, key, NULL, userfunc, userarg); if (userret == JSON_C_VISIT_RETURN_POP) break; if (userret == JSON_C_VISIT_RETURN_STOP || userret == JSON_C_VISIT_RETURN_ERROR) return userret; if (userret != JSON_C_VISIT_RETURN_CONTINUE && userret != JSON_C_VISIT_RETURN_SKIP) { fprintf(stderr, "INTERNAL ERROR: _json_c_visit returned %d\n", userret); return JSON_C_VISIT_RETURN_ERROR; } } break; } case json_type_array: { size_t array_len = json_object_array_length(jso); size_t ii; for (ii = 0; ii < array_len; ii++) { json_object *child = json_object_array_get_idx(jso, ii); userret = _json_c_visit(child, jso, NULL, &ii, userfunc, userarg); if (userret == JSON_C_VISIT_RETURN_POP) break; if (userret == JSON_C_VISIT_RETURN_STOP || userret == JSON_C_VISIT_RETURN_ERROR) return userret; if (userret != JSON_C_VISIT_RETURN_CONTINUE && userret != JSON_C_VISIT_RETURN_SKIP) { fprintf(stderr, "INTERNAL ERROR: _json_c_visit returned %d\n", userret); return JSON_C_VISIT_RETURN_ERROR; } } break; } default: fprintf(stderr, "INTERNAL ERROR: _json_c_visit found object of unknown type: %d\n", json_object_get_type(jso)); return JSON_C_VISIT_RETURN_ERROR; } // Call userfunc for the second type on container types, after all // members of the container have been visited. // Non-container types will have already returned before this point. userret = userfunc(jso, JSON_C_VISIT_SECOND, parent_jso, jso_key, jso_index, userarg); switch (userret) { case JSON_C_VISIT_RETURN_SKIP: case JSON_C_VISIT_RETURN_POP: // These are not really sensible during JSON_C_VISIT_SECOND, // but map them to JSON_C_VISIT_CONTINUE anyway. // FALLTHROUGH case JSON_C_VISIT_RETURN_CONTINUE: return JSON_C_VISIT_RETURN_CONTINUE; case JSON_C_VISIT_RETURN_STOP: case JSON_C_VISIT_RETURN_ERROR: return userret; default: fprintf(stderr, "ERROR: invalid return value from json_c_visit userfunc: %d\n", userret); return JSON_C_VISIT_RETURN_ERROR; } // NOTREACHED } json-c-json-c-0.17-20230812/json_visit.h000066400000000000000000000061471446575330000172770ustar00rootroot00000000000000 #ifndef _json_c_json_visit_h_ #define _json_c_json_visit_h_ /** * @file * @brief Methods for walking a tree of objects. */ #include "json_object.h" #ifdef __cplusplus extern "C" { #endif typedef int(json_c_visit_userfunc)(json_object *jso, int flags, json_object *parent_jso, const char *jso_key, size_t *jso_index, void *userarg); /** * Visit each object in the JSON hierarchy starting at jso. * For each object, userfunc is called, passing the object and userarg. * If the object has a parent (i.e. anything other than jso itself) * its parent will be passed as parent_jso, and either jso_key or jso_index * will be set, depending on whether the parent is an object or an array. * * Nodes will be visited depth first, but containers (arrays and objects) * will be visited twice, the second time with JSON_C_VISIT_SECOND set in * flags. * * userfunc must return one of the defined return values, to indicate * whether and how to continue visiting nodes, or one of various ways to stop. * * Returns 0 if nodes were visited successfully, even if some were * intentionally skipped due to what userfunc returned. * Returns <0 if an error occurred during iteration, including if * userfunc returned JSON_C_VISIT_RETURN_ERROR. */ JSON_EXPORT int json_c_visit(json_object *jso, int future_flags, json_c_visit_userfunc *userfunc, void *userarg); /** * Passed to json_c_visit_userfunc as one of the flags values to indicate * that this is the second time a container (array or object) is being * called, after all of it's members have been iterated over. */ #define JSON_C_VISIT_SECOND 0x02 /** * This json_c_visit_userfunc return value indicates that iteration * should proceed normally. */ #define JSON_C_VISIT_RETURN_CONTINUE 0 /** * This json_c_visit_userfunc return value indicates that iteration * over the members of the current object should be skipped. * If the current object isn't a container (array or object), this * is no different than JSON_C_VISIT_RETURN_CONTINUE. */ #define JSON_C_VISIT_RETURN_SKIP 7547 /** * This json_c_visit_userfunc return value indicates that iteration * of the fields/elements of the containing object should stop * and continue "popped up" a level of the object hierarchy. * For example, returning this when handling arg will result in * arg3 and any other fields being skipped. The next call to userfunc * will be the JSON_C_VISIT_SECOND call on "foo", followed by a userfunc * call on "bar". * 
 * {
 *   "foo": {
 *     "arg1": 1,
 *     "arg2": 2,
 *     "arg3": 3,
 *     ...
 *   },
 *   "bar": {
 *     ...
 *   }
 * }
 *
*/ #define JSON_C_VISIT_RETURN_POP 767 /** * This json_c_visit_userfunc return value indicates that iteration * should stop immediately, and cause json_c_visit to return success. */ #define JSON_C_VISIT_RETURN_STOP 7867 /** * This json_c_visit_userfunc return value indicates that iteration * should stop immediately, and cause json_c_visit to return an error. */ #define JSON_C_VISIT_RETURN_ERROR -1 #ifdef __cplusplus } #endif #endif /* _json_c_json_visit_h_ */ json-c-json-c-0.17-20230812/libjson.c000066400000000000000000000011331446575330000165310ustar00rootroot00000000000000 /* dummy source file for compatibility purposes */ #if defined(HAVE_CDEFS_H) #include #endif #ifndef __warn_references #if defined(__GNUC__) && defined(HAS_GNU_WARNING_LONG) #define __warn_references(sym, msg) \ __asm__(".section .gnu" #sym ",\n\t.ascii \"" msg "\"\n\t.text"); #else #define __warn_references(sym, msg) /* nothing */ #endif #endif #include "json_object.h" __warn_references(json_object_get, "Warning: please link against libjson-c instead of libjson"); /* __asm__(".section .gnu.warning." __STRING(sym) \ " ; .ascii \"" msg "\" ; .text") */ json-c-json-c-0.17-20230812/linkhash.c000066400000000000000000000514531446575330000167040ustar00rootroot00000000000000/* * $Id: linkhash.c,v 1.4 2006/01/26 02:16:28 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * Copyright (c) 2009 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ #include "config.h" #include #include #include #include #include #include #include #ifdef HAVE_ENDIAN_H #include /* attempt to define endianness */ #endif #if defined(_MSC_VER) || defined(__MINGW32__) #define WIN32_LEAN_AND_MEAN #include /* Get InterlockedCompareExchange */ #endif #include "linkhash.h" #include "random_seed.h" /* hash functions */ static unsigned long lh_char_hash(const void *k); static unsigned long lh_perllike_str_hash(const void *k); static lh_hash_fn *char_hash_fn = lh_char_hash; /* comparison functions */ int lh_char_equal(const void *k1, const void *k2); int lh_ptr_equal(const void *k1, const void *k2); int json_global_set_string_hash(const int h) { switch (h) { case JSON_C_STR_HASH_DFLT: char_hash_fn = lh_char_hash; break; case JSON_C_STR_HASH_PERLLIKE: char_hash_fn = lh_perllike_str_hash; break; default: return -1; } return 0; } static unsigned long lh_ptr_hash(const void *k) { /* CAW: refactored to be 64bit nice */ return (unsigned long)((((ptrdiff_t)k * LH_PRIME) >> 4) & ULONG_MAX); } int lh_ptr_equal(const void *k1, const void *k2) { return (k1 == k2); } /* * hashlittle from lookup3.c, by Bob Jenkins, May 2006, Public Domain. * https://burtleburtle.net/bob/c/lookup3.c * minor modifications to make functions static so no symbols are exported * minor modifications to compile with -Werror */ /* ------------------------------------------------------------------------------- lookup3.c, by Bob Jenkins, May 2006, Public Domain. These are functions for producing 32-bit hashes for hash table lookup. hashword(), hashlittle(), hashlittle2(), hashbig(), mix(), and final() are externally useful functions. Routines to test the hash are included if SELF_TEST is defined. You can use this free for any purpose. It's in the public domain. It has no warranty. You probably want to use hashlittle(). hashlittle() and hashbig() hash byte arrays. hashlittle() is faster than hashbig() on little-endian machines. Intel and AMD are little-endian machines. On second thought, you probably want hashlittle2(), which is identical to hashlittle() except it returns two 32-bit hashes for the price of one. You could implement hashbig2() if you wanted but I haven't bothered here. If you want to find a hash of, say, exactly 7 integers, do a = i1; b = i2; c = i3; mix(a,b,c); a += i4; b += i5; c += i6; mix(a,b,c); a += i7; final(a,b,c); then use c as the hash value. If you have a variable length array of 4-byte integers to hash, use hashword(). If you have a byte array (like a character string), use hashlittle(). If you have several byte arrays, or a mix of things, see the comments above hashlittle(). Why is this so big? I read 12 bytes at a time into 3 4-byte integers, then mix those integers. This is fast (you can do a lot more thorough mixing with 12*3 instructions on 3 integers than you can with 3 instructions on 1 byte), but shoehorning those bytes into integers efficiently is messy. ------------------------------------------------------------------------------- */ /* * My best guess at if you are big-endian or little-endian. This may * need adjustment. */ #if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN) || \ (defined(i386) || defined(__i386__) || defined(__i486__) || defined(__i586__) || \ defined(__i686__) || defined(vax) || defined(MIPSEL)) #define HASH_LITTLE_ENDIAN 1 #define HASH_BIG_ENDIAN 0 #elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && __BYTE_ORDER == __BIG_ENDIAN) || \ (defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel)) #define HASH_LITTLE_ENDIAN 0 #define HASH_BIG_ENDIAN 1 #else #define HASH_LITTLE_ENDIAN 0 #define HASH_BIG_ENDIAN 0 #endif #define hashsize(n) ((uint32_t)1 << (n)) #define hashmask(n) (hashsize(n) - 1) #define rot(x, k) (((x) << (k)) | ((x) >> (32 - (k)))) /* ------------------------------------------------------------------------------- mix -- mix 3 32-bit values reversibly. This is reversible, so any information in (a,b,c) before mix() is still in (a,b,c) after mix(). If four pairs of (a,b,c) inputs are run through mix(), or through mix() in reverse, there are at least 32 bits of the output that are sometimes the same for one pair and different for another pair. This was tested for: * pairs that differed by one bit, by two bits, in any combination of top bits of (a,b,c), or in any combination of bottom bits of (a,b,c). * "differ" is defined as +, -, ^, or ~^. For + and -, I transformed the output delta to a Gray code (a^(a>>1)) so a string of 1's (as is commonly produced by subtraction) look like a single 1-bit difference. * the base values were pseudorandom, all zero but one bit set, or all zero plus a counter that starts at zero. Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that satisfy this are 4 6 8 16 19 4 9 15 3 18 27 15 14 9 3 7 17 3 Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing for "differ" defined as + with a one-bit base and a two-bit delta. I used https://burtleburtle.net/bob/hash/avalanche.html to choose the operations, constants, and arrangements of the variables. This does not achieve avalanche. There are input bits of (a,b,c) that fail to affect some output bits of (a,b,c), especially of a. The most thoroughly mixed value is c, but it doesn't really even achieve avalanche in c. This allows some parallelism. Read-after-writes are good at doubling the number of bits affected, so the goal of mixing pulls in the opposite direction as the goal of parallelism. I did what I could. Rotates seem to cost as much as shifts on every machine I could lay my hands on, and rotates are much kinder to the top and bottom bits, so I used rotates. ------------------------------------------------------------------------------- */ /* clang-format off */ #define mix(a,b,c) \ { \ a -= c; a ^= rot(c, 4); c += b; \ b -= a; b ^= rot(a, 6); a += c; \ c -= b; c ^= rot(b, 8); b += a; \ a -= c; a ^= rot(c,16); c += b; \ b -= a; b ^= rot(a,19); a += c; \ c -= b; c ^= rot(b, 4); b += a; \ } /* clang-format on */ /* ------------------------------------------------------------------------------- final -- final mixing of 3 32-bit values (a,b,c) into c Pairs of (a,b,c) values differing in only a few bits will usually produce values of c that look totally different. This was tested for * pairs that differed by one bit, by two bits, in any combination of top bits of (a,b,c), or in any combination of bottom bits of (a,b,c). * "differ" is defined as +, -, ^, or ~^. For + and -, I transformed the output delta to a Gray code (a^(a>>1)) so a string of 1's (as is commonly produced by subtraction) look like a single 1-bit difference. * the base values were pseudorandom, all zero but one bit set, or all zero plus a counter that starts at zero. These constants passed: 14 11 25 16 4 14 24 12 14 25 16 4 14 24 and these came close: 4 8 15 26 3 22 24 10 8 15 26 3 22 24 11 8 15 26 3 22 24 ------------------------------------------------------------------------------- */ /* clang-format off */ #define final(a,b,c) \ { \ c ^= b; c -= rot(b,14); \ a ^= c; a -= rot(c,11); \ b ^= a; b -= rot(a,25); \ c ^= b; c -= rot(b,16); \ a ^= c; a -= rot(c,4); \ b ^= a; b -= rot(a,14); \ c ^= b; c -= rot(b,24); \ } /* clang-format on */ /* ------------------------------------------------------------------------------- hashlittle() -- hash a variable-length key into a 32-bit value k : the key (the unaligned variable-length array of bytes) length : the length of the key, counting by bytes initval : can be any 4-byte value Returns a 32-bit value. Every bit of the key affects every bit of the return value. Two keys differing by one or two bits will have totally different hash values. The best hash table sizes are powers of 2. There is no need to do mod a prime (mod is sooo slow!). If you need less than 32 bits, use a bitmask. For example, if you need only 10 bits, do h = (h & hashmask(10)); In which case, the hash table should have hashsize(10) elements. If you are hashing n strings (uint8_t **)k, do it like this: for (i=0, h=0; i 12) { a += k[0]; b += k[1]; c += k[2]; mix(a,b,c); length -= 12; k += 3; } /*----------------------------- handle the last (probably partial) block */ /* * "k[2]&0xffffff" actually reads beyond the end of the string, but * then masks off the part it's not allowed to read. Because the * string is aligned, the masked-off tail is in the same word as the * rest of the string. Every machine with memory protection I've seen * does it on word boundaries, so is OK with this. But VALGRIND will * still catch it and complain. The masking trick does make the hash * noticeably faster for short strings (like English words). * AddressSanitizer is similarly picky about overrunning * the buffer. (https://clang.llvm.org/docs/AddressSanitizer.html) */ #ifdef VALGRIND #define PRECISE_MEMORY_ACCESS 1 #elif defined(__SANITIZE_ADDRESS__) /* GCC's ASAN */ #define PRECISE_MEMORY_ACCESS 1 #elif defined(__has_feature) #if __has_feature(address_sanitizer) /* Clang's ASAN */ #define PRECISE_MEMORY_ACCESS 1 #endif #endif #ifndef PRECISE_MEMORY_ACCESS switch(length) { case 12: c+=k[2]; b+=k[1]; a+=k[0]; break; case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break; case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break; case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break; case 8 : b+=k[1]; a+=k[0]; break; case 7 : b+=k[1]&0xffffff; a+=k[0]; break; case 6 : b+=k[1]&0xffff; a+=k[0]; break; case 5 : b+=k[1]&0xff; a+=k[0]; break; case 4 : a+=k[0]; break; case 3 : a+=k[0]&0xffffff; break; case 2 : a+=k[0]&0xffff; break; case 1 : a+=k[0]&0xff; break; case 0 : return c; /* zero length strings require no mixing */ } #else /* make valgrind happy */ const uint8_t *k8 = (const uint8_t *)k; switch(length) { case 12: c+=k[2]; b+=k[1]; a+=k[0]; break; case 11: c+=((uint32_t)k8[10])<<16; /* fall through */ case 10: c+=((uint32_t)k8[9])<<8; /* fall through */ case 9 : c+=k8[8]; /* fall through */ case 8 : b+=k[1]; a+=k[0]; break; case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */ case 6 : b+=((uint32_t)k8[5])<<8; /* fall through */ case 5 : b+=k8[4]; /* fall through */ case 4 : a+=k[0]; break; case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */ case 2 : a+=((uint32_t)k8[1])<<8; /* fall through */ case 1 : a+=k8[0]; break; case 0 : return c; } #endif /* !valgrind */ } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) { const uint16_t *k = (const uint16_t *)key; /* read 16-bit chunks */ const uint8_t *k8; /*--------------- all but last block: aligned reads and different mixing */ while (length > 12) { a += k[0] + (((uint32_t)k[1])<<16); b += k[2] + (((uint32_t)k[3])<<16); c += k[4] + (((uint32_t)k[5])<<16); mix(a,b,c); length -= 12; k += 6; } /*----------------------------- handle the last (probably partial) block */ k8 = (const uint8_t *)k; switch(length) { case 12: c+=k[4]+(((uint32_t)k[5])<<16); b+=k[2]+(((uint32_t)k[3])<<16); a+=k[0]+(((uint32_t)k[1])<<16); break; case 11: c+=((uint32_t)k8[10])<<16; /* fall through */ case 10: c+=k[4]; b+=k[2]+(((uint32_t)k[3])<<16); a+=k[0]+(((uint32_t)k[1])<<16); break; case 9 : c+=k8[8]; /* fall through */ case 8 : b+=k[2]+(((uint32_t)k[3])<<16); a+=k[0]+(((uint32_t)k[1])<<16); break; case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */ case 6 : b+=k[2]; a+=k[0]+(((uint32_t)k[1])<<16); break; case 5 : b+=k8[4]; /* fall through */ case 4 : a+=k[0]+(((uint32_t)k[1])<<16); break; case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */ case 2 : a+=k[0]; break; case 1 : a+=k8[0]; break; case 0 : return c; /* zero length requires no mixing */ } } else { /* need to read the key one byte at a time */ const uint8_t *k = (const uint8_t *)key; /*--------------- all but the last block: affect some 32 bits of (a,b,c) */ while (length > 12) { a += k[0]; a += ((uint32_t)k[1])<<8; a += ((uint32_t)k[2])<<16; a += ((uint32_t)k[3])<<24; b += k[4]; b += ((uint32_t)k[5])<<8; b += ((uint32_t)k[6])<<16; b += ((uint32_t)k[7])<<24; c += k[8]; c += ((uint32_t)k[9])<<8; c += ((uint32_t)k[10])<<16; c += ((uint32_t)k[11])<<24; mix(a,b,c); length -= 12; k += 12; } /*-------------------------------- last block: affect all 32 bits of (c) */ switch(length) /* all the case statements fall through */ { case 12: c+=((uint32_t)k[11])<<24; /* FALLTHRU */ case 11: c+=((uint32_t)k[10])<<16; /* FALLTHRU */ case 10: c+=((uint32_t)k[9])<<8; /* FALLTHRU */ case 9 : c+=k[8]; /* FALLTHRU */ case 8 : b+=((uint32_t)k[7])<<24; /* FALLTHRU */ case 7 : b+=((uint32_t)k[6])<<16; /* FALLTHRU */ case 6 : b+=((uint32_t)k[5])<<8; /* FALLTHRU */ case 5 : b+=k[4]; /* FALLTHRU */ case 4 : a+=((uint32_t)k[3])<<24; /* FALLTHRU */ case 3 : a+=((uint32_t)k[2])<<16; /* FALLTHRU */ case 2 : a+=((uint32_t)k[1])<<8; /* FALLTHRU */ case 1 : a+=k[0]; break; case 0 : return c; } } final(a,b,c); return c; } /* clang-format on */ /* a simple hash function similar to what perl does for strings. * for good results, the string should not be excessively large. */ static unsigned long lh_perllike_str_hash(const void *k) { const char *rkey = (const char *)k; unsigned hashval = 1; while (*rkey) hashval = hashval * 33 + *rkey++; return hashval; } static unsigned long lh_char_hash(const void *k) { #if defined _MSC_VER || defined __MINGW32__ #define RANDOM_SEED_TYPE LONG #else #define RANDOM_SEED_TYPE int #endif static volatile RANDOM_SEED_TYPE random_seed = -1; if (random_seed == -1) { RANDOM_SEED_TYPE seed; /* we can't use -1 as it is the uninitialized sentinel */ while ((seed = json_c_get_random_seed()) == -1) {} #if SIZEOF_INT == 8 && defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 #define USE_SYNC_COMPARE_AND_SWAP 1 #endif #if SIZEOF_INT == 4 && defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 #define USE_SYNC_COMPARE_AND_SWAP 1 #endif #if SIZEOF_INT == 2 && defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 #define USE_SYNC_COMPARE_AND_SWAP 1 #endif #if defined USE_SYNC_COMPARE_AND_SWAP (void)__sync_val_compare_and_swap(&random_seed, -1, seed); #elif defined _MSC_VER || defined __MINGW32__ InterlockedCompareExchange(&random_seed, seed, -1); #else //#warning "racy random seed initialization if used by multiple threads" random_seed = seed; /* potentially racy */ #endif } return hashlittle((const char *)k, strlen((const char *)k), (uint32_t)random_seed); } int lh_char_equal(const void *k1, const void *k2) { return (strcmp((const char *)k1, (const char *)k2) == 0); } struct lh_table *lh_table_new(int size, lh_entry_free_fn *free_fn, lh_hash_fn *hash_fn, lh_equal_fn *equal_fn) { int i; struct lh_table *t; /* Allocate space for elements to avoid divisions by zero. */ assert(size > 0); t = (struct lh_table *)calloc(1, sizeof(struct lh_table)); if (!t) return NULL; t->count = 0; t->size = size; t->table = (struct lh_entry *)calloc(size, sizeof(struct lh_entry)); if (!t->table) { free(t); return NULL; } t->free_fn = free_fn; t->hash_fn = hash_fn; t->equal_fn = equal_fn; for (i = 0; i < size; i++) t->table[i].k = LH_EMPTY; return t; } struct lh_table *lh_kchar_table_new(int size, lh_entry_free_fn *free_fn) { return lh_table_new(size, free_fn, char_hash_fn, lh_char_equal); } struct lh_table *lh_kptr_table_new(int size, lh_entry_free_fn *free_fn) { return lh_table_new(size, free_fn, lh_ptr_hash, lh_ptr_equal); } int lh_table_resize(struct lh_table *t, int new_size) { struct lh_table *new_t; struct lh_entry *ent; new_t = lh_table_new(new_size, NULL, t->hash_fn, t->equal_fn); if (new_t == NULL) return -1; for (ent = t->head; ent != NULL; ent = ent->next) { unsigned long h = lh_get_hash(new_t, ent->k); unsigned int opts = 0; if (ent->k_is_constant) opts = JSON_C_OBJECT_ADD_CONSTANT_KEY; if (lh_table_insert_w_hash(new_t, ent->k, ent->v, h, opts) != 0) { lh_table_free(new_t); return -1; } } free(t->table); t->table = new_t->table; t->size = new_size; t->head = new_t->head; t->tail = new_t->tail; free(new_t); return 0; } void lh_table_free(struct lh_table *t) { struct lh_entry *c; if (t->free_fn) { for (c = t->head; c != NULL; c = c->next) t->free_fn(c); } free(t->table); free(t); } int lh_table_insert_w_hash(struct lh_table *t, const void *k, const void *v, const unsigned long h, const unsigned opts) { unsigned long n; if (t->count >= t->size * LH_LOAD_FACTOR) { /* Avoid signed integer overflow with large tables. */ int new_size = (t->size > INT_MAX / 2) ? INT_MAX : (t->size * 2); if (t->size == INT_MAX || lh_table_resize(t, new_size) != 0) return -1; } n = h % t->size; while (1) { if (t->table[n].k == LH_EMPTY || t->table[n].k == LH_FREED) break; if ((int)++n == t->size) n = 0; } t->table[n].k = k; t->table[n].k_is_constant = (opts & JSON_C_OBJECT_ADD_CONSTANT_KEY); t->table[n].v = v; t->count++; if (t->head == NULL) { t->head = t->tail = &t->table[n]; t->table[n].next = t->table[n].prev = NULL; } else { t->tail->next = &t->table[n]; t->table[n].prev = t->tail; t->table[n].next = NULL; t->tail = &t->table[n]; } return 0; } int lh_table_insert(struct lh_table *t, const void *k, const void *v) { return lh_table_insert_w_hash(t, k, v, lh_get_hash(t, k), 0); } struct lh_entry *lh_table_lookup_entry_w_hash(struct lh_table *t, const void *k, const unsigned long h) { unsigned long n = h % t->size; int count = 0; while (count < t->size) { if (t->table[n].k == LH_EMPTY) return NULL; if (t->table[n].k != LH_FREED && t->equal_fn(t->table[n].k, k)) return &t->table[n]; if ((int)++n == t->size) n = 0; count++; } return NULL; } struct lh_entry *lh_table_lookup_entry(struct lh_table *t, const void *k) { return lh_table_lookup_entry_w_hash(t, k, lh_get_hash(t, k)); } json_bool lh_table_lookup_ex(struct lh_table *t, const void *k, void **v) { struct lh_entry *e = lh_table_lookup_entry(t, k); if (e != NULL) { if (v != NULL) *v = lh_entry_v(e); return 1; /* key found */ } if (v != NULL) *v = NULL; return 0; /* key not found */ } int lh_table_delete_entry(struct lh_table *t, struct lh_entry *e) { /* CAW: fixed to be 64bit nice, still need the crazy negative case... */ ptrdiff_t n = (ptrdiff_t)(e - t->table); /* CAW: this is bad, really bad, maybe stack goes other direction on this machine... */ if (n < 0) { return -2; } if (t->table[n].k == LH_EMPTY || t->table[n].k == LH_FREED) return -1; t->count--; if (t->free_fn) t->free_fn(e); t->table[n].v = NULL; t->table[n].k = LH_FREED; if (t->tail == &t->table[n] && t->head == &t->table[n]) { t->head = t->tail = NULL; } else if (t->head == &t->table[n]) { t->head->next->prev = NULL; t->head = t->head->next; } else if (t->tail == &t->table[n]) { t->tail->prev->next = NULL; t->tail = t->tail->prev; } else { t->table[n].prev->next = t->table[n].next; t->table[n].next->prev = t->table[n].prev; } t->table[n].next = t->table[n].prev = NULL; return 0; } int lh_table_delete(struct lh_table *t, const void *k) { struct lh_entry *e = lh_table_lookup_entry(t, k); if (!e) return -1; return lh_table_delete_entry(t, e); } int lh_table_length(struct lh_table *t) { return t->count; } json-c-json-c-0.17-20230812/linkhash.h000066400000000000000000000301341446575330000167020ustar00rootroot00000000000000/* * $Id: linkhash.h,v 1.6 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * Copyright (c) 2009 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Internal methods for working with json_type_object objects. Although * this is exposed by the json_object_get_object() function and within the * json_object_iter type, it is not recommended for direct use. */ #ifndef _json_c_linkhash_h_ #define _json_c_linkhash_h_ #include "json_object.h" #ifdef __cplusplus extern "C" { #endif /** * golden prime used in hash functions */ #define LH_PRIME 0x9e370001UL /** * The fraction of filled hash buckets until an insert will cause the table * to be resized. * This can range from just above 0 up to 1.0. */ #define LH_LOAD_FACTOR 0.66 /** * sentinel pointer value for empty slots */ #define LH_EMPTY (void *)-1 /** * sentinel pointer value for freed slots */ #define LH_FREED (void *)-2 /** * default string hash function */ #define JSON_C_STR_HASH_DFLT 0 /** * perl-like string hash function */ #define JSON_C_STR_HASH_PERLLIKE 1 /** * This function sets the hash function to be used for strings. * Must be one of the JSON_C_STR_HASH_* values. * @returns 0 - ok, -1 if parameter was invalid */ int json_global_set_string_hash(const int h); struct lh_entry; /** * callback function prototypes */ typedef void(lh_entry_free_fn)(struct lh_entry *e); /** * callback function prototypes */ typedef unsigned long(lh_hash_fn)(const void *k); /** * callback function prototypes */ typedef int(lh_equal_fn)(const void *k1, const void *k2); /** * An entry in the hash table. Outside of linkhash.c, treat this as opaque. */ struct lh_entry { /** * The key. * @deprecated Use lh_entry_k() instead of accessing this directly. */ const void *k; /** * A flag for users of linkhash to know whether or not they * need to free k. * @deprecated use lh_entry_k_is_constant() instead. */ int k_is_constant; /** * The value. * @deprecated Use lh_entry_v() instead of accessing this directly. */ const void *v; /** * The next entry. * @deprecated Use lh_entry_next() instead of accessing this directly. */ struct lh_entry *next; /** * The previous entry. * @deprecated Use lh_entry_prev() instead of accessing this directly. */ struct lh_entry *prev; }; /** * The hash table structure. Outside of linkhash.c, treat this as opaque. */ struct lh_table { /** * Size of our hash. * @deprecated do not use outside of linkhash.c */ int size; /** * Numbers of entries. * @deprecated Use lh_table_length() instead. */ int count; /** * The first entry. * @deprecated Use lh_table_head() instead. */ struct lh_entry *head; /** * The last entry. * @deprecated Do not use, may be removed in a future release. */ struct lh_entry *tail; /** * Internal storage of the actual table of entries. * @deprecated do not use outside of linkhash.c */ struct lh_entry *table; /** * A pointer to the function responsible for freeing an entry. * @deprecated do not use outside of linkhash.c */ lh_entry_free_fn *free_fn; /** * @deprecated do not use outside of linkhash.c */ lh_hash_fn *hash_fn; /** * @deprecated do not use outside of linkhash.c */ lh_equal_fn *equal_fn; }; typedef struct lh_table lh_table; /** * Convenience list iterator. */ #define lh_foreach(table, entry) for (entry = lh_table_head(table); entry; entry = lh_entry_next(entry)) /** * lh_foreach_safe allows calling of deletion routine while iterating. * * @param table a struct lh_table * to iterate over * @param entry a struct lh_entry * variable to hold each element * @param tmp a struct lh_entry * variable to hold a temporary pointer to the next element */ #define lh_foreach_safe(table, entry, tmp) \ for (entry = lh_table_head(table); entry && ((tmp = lh_entry_next(entry)) || 1); entry = tmp) /** * Create a new linkhash table. * * @param size initial table size. The table is automatically resized * although this incurs a performance penalty. * @param free_fn callback function used to free memory for entries * when lh_table_free or lh_table_delete is called. * If NULL is provided, then memory for keys and values * must be freed by the caller. * @param hash_fn function used to hash keys. 2 standard ones are defined: * lh_ptr_hash and lh_char_hash for hashing pointer values * and C strings respectively. * @param equal_fn comparison function to compare keys. 2 standard ones defined: * lh_ptr_hash and lh_char_hash for comparing pointer values * and C strings respectively. * @return On success, a pointer to the new linkhash table is returned. * On error, a null pointer is returned. */ extern struct lh_table *lh_table_new(int size, lh_entry_free_fn *free_fn, lh_hash_fn *hash_fn, lh_equal_fn *equal_fn); /** * Convenience function to create a new linkhash table with char keys. * * @param size initial table size. * @param free_fn callback function used to free memory for entries. * @return On success, a pointer to the new linkhash table is returned. * On error, a null pointer is returned. */ extern struct lh_table *lh_kchar_table_new(int size, lh_entry_free_fn *free_fn); /** * Convenience function to create a new linkhash table with ptr keys. * * @param size initial table size. * @param free_fn callback function used to free memory for entries. * @return On success, a pointer to the new linkhash table is returned. * On error, a null pointer is returned. */ extern struct lh_table *lh_kptr_table_new(int size, lh_entry_free_fn *free_fn); /** * Free a linkhash table. * * If a lh_entry_free_fn callback free function was provided then it is * called for all entries in the table. * * @param t table to free. */ extern void lh_table_free(struct lh_table *t); /** * Insert a record into the table. * * @param t the table to insert into. * @param k a pointer to the key to insert. * @param v a pointer to the value to insert. * * @return On success, 0 is returned. * On error, a negative value is returned. */ extern int lh_table_insert(struct lh_table *t, const void *k, const void *v); /** * Insert a record into the table using a precalculated key hash. * * The hash h, which should be calculated with lh_get_hash() on k, is provided by * the caller, to allow for optimization when multiple operations with the same * key are known to be needed. * * @param t the table to insert into. * @param k a pointer to the key to insert. * @param v a pointer to the value to insert. * @param h hash value of the key to insert * @param opts if set to JSON_C_OBJECT_ADD_CONSTANT_KEY, sets lh_entry.k_is_constant * so t's free function knows to avoid freeing the key. */ extern int lh_table_insert_w_hash(struct lh_table *t, const void *k, const void *v, const unsigned long h, const unsigned opts); /** * Lookup a record in the table. * * @param t the table to lookup * @param k a pointer to the key to lookup * @return a pointer to the record structure of the value or NULL if it does not exist. */ extern struct lh_entry *lh_table_lookup_entry(struct lh_table *t, const void *k); /** * Lookup a record in the table using a precalculated key hash. * * The hash h, which should be calculated with lh_get_hash() on k, is provided by * the caller, to allow for optimization when multiple operations with the same * key are known to be needed. * * @param t the table to lookup * @param k a pointer to the key to lookup * @param h hash value of the key to lookup * @return a pointer to the record structure of the value or NULL if it does not exist. */ extern struct lh_entry *lh_table_lookup_entry_w_hash(struct lh_table *t, const void *k, const unsigned long h); /** * Lookup a record in the table. * * @param t the table to lookup * @param k a pointer to the key to lookup * @param v a pointer to a where to store the found value (set to NULL if it doesn't exist). * @return whether or not the key was found */ extern json_bool lh_table_lookup_ex(struct lh_table *t, const void *k, void **v); /** * Delete a record from the table. * * If a callback free function is provided then it is called for the * for the item being deleted. * @param t the table to delete from. * @param e a pointer to the entry to delete. * @return 0 if the item was deleted. * @return -1 if it was not found. */ extern int lh_table_delete_entry(struct lh_table *t, struct lh_entry *e); /** * Delete a record from the table. * * If a callback free function is provided then it is called for the * for the item being deleted. * @param t the table to delete from. * @param k a pointer to the key to delete. * @return 0 if the item was deleted. * @return -1 if it was not found. */ extern int lh_table_delete(struct lh_table *t, const void *k); /** * Return the number of entries in the table. */ extern int lh_table_length(struct lh_table *t); /** * Resizes the specified table. * * @param t Pointer to table to resize. * @param new_size New table size. Must be positive. * * @return On success, 0 is returned. * On error, a negative value is returned. */ int lh_table_resize(struct lh_table *t, int new_size); /** * @deprecated Don't use this outside of linkhash.h: */ #if (defined(AIX_CC) || (defined(_MSC_VER) && (_MSC_VER <= 1800)) ) /* VS2010 can't handle inline funcs, so skip it there */ #define _LH_INLINE #else #define _LH_INLINE inline #endif /** * Return the first entry in the lh_table. * @see lh_entry_next() */ static _LH_INLINE struct lh_entry *lh_table_head(const lh_table *t) { return t->head; } /** * Calculate the hash of a key for a given table. * * This is an extension to support functions that need to calculate * the hash several times and allows them to do it just once and then pass * in the hash to all utility functions. Depending on use case, this can be a * considerable performance improvement. * @param t the table (used to obtain hash function) * @param k a pointer to the key to lookup * @return the key's hash */ static _LH_INLINE unsigned long lh_get_hash(const struct lh_table *t, const void *k) { return t->hash_fn(k); } /** * @deprecated Don't use this outside of linkhash.h: */ #ifdef __UNCONST #define _LH_UNCONST(a) __UNCONST(a) #else #define _LH_UNCONST(a) ((void *)(uintptr_t)(const void *)(a)) #endif /** * Return a non-const version of lh_entry.k. * * lh_entry.k is const to indicate and help ensure that linkhash itself doesn't modify * it, but callers are allowed to do what they want with it. * @see lh_entry_k_is_constant() */ static _LH_INLINE void *lh_entry_k(const struct lh_entry *e) { return _LH_UNCONST(e->k); } /** * Returns 1 if the key for the given entry is constant, and thus * does not need to be freed when the lh_entry is freed. * @see lh_table_insert_w_hash() */ static _LH_INLINE int lh_entry_k_is_constant(const struct lh_entry *e) { return e->k_is_constant; } /** * Return a non-const version of lh_entry.v. * * v is const to indicate and help ensure that linkhash itself doesn't modify * it, but callers are allowed to do what they want with it. */ static _LH_INLINE void *lh_entry_v(const struct lh_entry *e) { return _LH_UNCONST(e->v); } /** * Change the value for an entry. The caller is responsible for freeing * the previous value. */ static _LH_INLINE void lh_entry_set_val(struct lh_entry *e, void *newval) { e->v = newval; } /** * Return the next element, or NULL if there is no next element. * @see lh_table_head() * @see lh_entry_prev() */ static _LH_INLINE struct lh_entry *lh_entry_next(const struct lh_entry *e) { return e->next; } /** * Return the previous element, or NULL if there is no previous element. * @see lh_table_head() * @see lh_entry_next() */ static _LH_INLINE struct lh_entry *lh_entry_prev(const struct lh_entry *e) { return e->prev; } #undef _LH_INLINE #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/math_compat.h000066400000000000000000000016021446575330000173730ustar00rootroot00000000000000#ifndef __math_compat_h #define __math_compat_h /** * @file * @brief Do not use, json-c internal, may be changed or removed at any time. */ /* Define isnan, isinf, infinity and nan on Windows/MSVC */ #ifndef HAVE_DECL_ISNAN #ifdef HAVE_DECL__ISNAN #include #define isnan(x) _isnan(x) #else /* On platforms like AIX and "IBM i" we need to provide our own isnan */ #define isnan(x) ((x) != (x)) #endif #endif #ifndef HAVE_DECL_ISINF #ifdef HAVE_DECL__FINITE #include #define isinf(x) (!_finite(x)) #else #include /* On platforms like AIX and "IBM i" we need to provide our own isinf */ #define isinf(x) ((x) < -DBL_MAX || (x) > DBL_MAX) #endif #endif #ifndef HAVE_DECL_INFINITY #include #define INFINITY (DBL_MAX + DBL_MAX) #define HAVE_DECL_INFINITY #endif #ifndef HAVE_DECL_NAN #define NAN (INFINITY - INFINITY) #define HAVE_DECL_NAN #endif #endif json-c-json-c-0.17-20230812/printbuf.c000066400000000000000000000101161446575330000167230ustar00rootroot00000000000000/* * $Id: printbuf.c,v 1.5 2006/01/26 02:16:28 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * * * Copyright (c) 2008-2009 Yahoo! Inc. All rights reserved. * The copyrights to the contents of this file are licensed under the MIT License * (https://www.opensource.org/licenses/mit-license.php) */ #include "config.h" #include #include #include #include #include #ifdef HAVE_STDARG_H #include #else /* !HAVE_STDARG_H */ #error Not enough var arg support! #endif /* HAVE_STDARG_H */ #include "debug.h" #include "printbuf.h" #include "snprintf_compat.h" #include "vasprintf_compat.h" static int printbuf_extend(struct printbuf *p, int min_size); struct printbuf *printbuf_new(void) { struct printbuf *p; p = (struct printbuf *)calloc(1, sizeof(struct printbuf)); if (!p) return NULL; p->size = 32; p->bpos = 0; if (!(p->buf = (char *)malloc(p->size))) { free(p); return NULL; } p->buf[0] = '\0'; return p; } /** * Extend the buffer p so it has a size of at least min_size. * * If the current size is large enough, nothing is changed. * * If extension failed, errno is set to indicate the error. * * Note: this does not check the available space! The caller * is responsible for performing those calculations. */ static int printbuf_extend(struct printbuf *p, int min_size) { char *t; int new_size; if (p->size >= min_size) return 0; /* Prevent signed integer overflows with large buffers. */ if (min_size > INT_MAX - 8) { errno = EFBIG; return -1; } if (p->size > INT_MAX / 2) new_size = min_size + 8; else { new_size = p->size * 2; if (new_size < min_size + 8) new_size = min_size + 8; } #ifdef PRINTBUF_DEBUG MC_DEBUG("printbuf_extend: realloc " "bpos=%d min_size=%d old_size=%d new_size=%d\n", p->bpos, min_size, p->size, new_size); #endif /* PRINTBUF_DEBUG */ if (!(t = (char *)realloc(p->buf, new_size))) return -1; p->size = new_size; p->buf = t; return 0; } int printbuf_memappend(struct printbuf *p, const char *buf, int size) { /* Prevent signed integer overflows with large buffers. */ if (size < 0 || size > INT_MAX - p->bpos - 1) { errno = EFBIG; return -1; } if (p->size <= p->bpos + size + 1) { if (printbuf_extend(p, p->bpos + size + 1) < 0) return -1; } memcpy(p->buf + p->bpos, buf, size); p->bpos += size; p->buf[p->bpos] = '\0'; return size; } int printbuf_memset(struct printbuf *pb, int offset, int charvalue, int len) { int size_needed; if (offset == -1) offset = pb->bpos; /* Prevent signed integer overflows with large buffers. */ if (len < 0 || offset < -1 || len > INT_MAX - offset) { errno = EFBIG; return -1; } size_needed = offset + len; if (pb->size < size_needed) { if (printbuf_extend(pb, size_needed) < 0) return -1; } if (pb->bpos < offset) memset(pb->buf + pb->bpos, '\0', offset - pb->bpos); memset(pb->buf + offset, charvalue, len); if (pb->bpos < size_needed) pb->bpos = size_needed; return 0; } int sprintbuf(struct printbuf *p, const char *msg, ...) { va_list ap; char *t; int size; char buf[128]; /* use stack buffer first */ va_start(ap, msg); size = vsnprintf(buf, 128, msg, ap); va_end(ap); /* if string is greater than stack buffer, then use dynamic string * with vasprintf. Note: some implementations of vsnprintf return -1 * if output is truncated whereas some return the number of bytes that * would have been written - this code handles both cases. */ if (size < 0 || size > 127) { va_start(ap, msg); if ((size = vasprintf(&t, msg, ap)) < 0) { va_end(ap); return -1; } va_end(ap); size = printbuf_memappend(p, t, size); free(t); } else { size = printbuf_memappend(p, buf, size); } return size; } void printbuf_reset(struct printbuf *p) { p->buf[0] = '\0'; p->bpos = 0; } void printbuf_free(struct printbuf *p) { if (p) { free(p->buf); free(p); } } json-c-json-c-0.17-20230812/printbuf.h000066400000000000000000000104011446575330000167250ustar00rootroot00000000000000/* * $Id: printbuf.h,v 1.4 2006/01/26 02:16:28 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * * * Copyright (c) 2008-2009 Yahoo! Inc. All rights reserved. * The copyrights to the contents of this file are licensed under the MIT License * (https://www.opensource.org/licenses/mit-license.php) */ /** * @file * @brief Internal string buffer handling. Unless you're writing a * json_object_to_json_string_fn implementation for use with * json_object_set_serializer() direct use of this is not * recommended. */ #ifndef _json_c_printbuf_h_ #define _json_c_printbuf_h_ #ifndef JSON_EXPORT #if defined(_MSC_VER) && defined(JSON_C_DLL) #define JSON_EXPORT __declspec(dllexport) #else #define JSON_EXPORT extern #endif #endif #ifdef __cplusplus extern "C" { #endif struct printbuf { char *buf; int bpos; int size; }; typedef struct printbuf printbuf; JSON_EXPORT struct printbuf *printbuf_new(void); /* As an optimization, printbuf_memappend_fast() is defined as a macro * that handles copying data if the buffer is large enough; otherwise * it invokes printbuf_memappend() which performs the heavy * lifting of realloc()ing the buffer and copying data. * * Your code should not use printbuf_memappend() directly unless it * checks the return code. Use printbuf_memappend_fast() instead. */ JSON_EXPORT int printbuf_memappend(struct printbuf *p, const char *buf, int size); #define printbuf_memappend_fast(p, bufptr, bufsize) \ do \ { \ if ((p->size - p->bpos) > bufsize) \ { \ memcpy(p->buf + p->bpos, (bufptr), bufsize); \ p->bpos += bufsize; \ p->buf[p->bpos] = '\0'; \ } \ else \ { \ printbuf_memappend(p, (bufptr), bufsize); \ } \ } while (0) #define printbuf_length(p) ((p)->bpos) /** * Results in a compile error if the argument is not a string literal. */ #define _printbuf_check_literal(mystr) ("" mystr) /** * This is an optimization wrapper around printbuf_memappend() that is useful * for appending string literals. Since the size of string constants is known * at compile time, using this macro can avoid a costly strlen() call. This is * especially helpful when a constant string must be appended many times. If * you got here because of a compilation error caused by passing something * other than a string literal, use printbuf_memappend_fast() in conjunction * with strlen(). * * See also: * printbuf_memappend_fast() * printbuf_memappend() * sprintbuf() */ #define printbuf_strappend(pb, str) \ printbuf_memappend((pb), _printbuf_check_literal(str), sizeof(str) - 1) /** * Set len bytes of the buffer to charvalue, starting at offset offset. * Similar to calling memset(x, charvalue, len); * * The memory allocated for the buffer is extended as necessary. * * If offset is -1, this starts at the end of the current data in the buffer. */ JSON_EXPORT int printbuf_memset(struct printbuf *pb, int offset, int charvalue, int len); /** * Formatted print to printbuf. * * This function is the most expensive of the available functions for appending * string data to a printbuf and should be used only where convenience is more * important than speed. Avoid using this function in high performance code or * tight loops; in these scenarios, consider using snprintf() with a static * buffer in conjunction with one of the printbuf_*append() functions. * * See also: * printbuf_memappend_fast() * printbuf_memappend() * printbuf_strappend() */ JSON_EXPORT int sprintbuf(struct printbuf *p, const char *msg, ...); JSON_EXPORT void printbuf_reset(struct printbuf *p); JSON_EXPORT void printbuf_free(struct printbuf *p); #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/random_seed.c000066400000000000000000000152431446575330000173600ustar00rootroot00000000000000/* * random_seed.c * * Copyright (c) 2013 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ #include "random_seed.h" #include "config.h" #include "strerror_override.h" #include #include #ifdef HAVE_BSD_STDLIB_H #include #endif #define DEBUG_SEED(s) #if defined(__APPLE__) || defined(__unix__) || defined(__linux__) #define HAVE_DEV_RANDOM 1 #endif #ifdef HAVE_ARC4RANDOM #undef HAVE_GETRANDOM #undef HAVE_DEV_RANDOM #undef HAVE_CRYPTGENRANDOM #endif #if defined ENABLE_RDRAND /* cpuid */ #if defined __GNUC__ && (defined __i386__ || defined __x86_64__) #define HAS_X86_CPUID 1 static void do_cpuid(int regs[], int h) { /* clang-format off */ __asm__ __volatile__("cpuid" : "=a"(regs[0]), "=b"(regs[1]), "=c"(regs[2]), "=d"(regs[3]) : "a"(h)); /* clang-format on */ } #elif defined _MSC_VER #define HAS_X86_CPUID 1 #define do_cpuid __cpuid #endif /* has_rdrand */ #if HAS_X86_CPUID static int get_rdrand_seed(void); /* Valid values are -1 (haven't tested), 0 (no), and 1 (yes). */ static int _has_rdrand = -1; static int has_rdrand(void) { if (_has_rdrand != -1) { return _has_rdrand; } /* CPUID.01H:ECX.RDRAND[bit 30] == 1 */ int regs[4]; do_cpuid(regs, 1); if (!(regs[2] & (1 << 30))) { _has_rdrand = 0; return 0; } /* * Some CPUs advertise RDRAND in CPUID, but return 0xFFFFFFFF * unconditionally. To avoid locking up later, test RDRAND here. If over * 3 trials RDRAND has returned the same value, declare it broken. * Example CPUs are AMD Ryzen 3000 series * and much older AMD APUs, such as the E1-1500 * https://github.com/systemd/systemd/issues/11810 * https://linuxreviews.org/RDRAND_stops_returning_random_values_on_older_AMD_CPUs_after_suspend */ _has_rdrand = 0; int prev = get_rdrand_seed(); for (int i = 0; i < 3; i++) { int temp = get_rdrand_seed(); if (temp != prev) { _has_rdrand = 1; break; } prev = temp; } return _has_rdrand; } #endif /* get_rdrand_seed - GCC x86 and X64 */ #if defined __GNUC__ && (defined __i386__ || defined __x86_64__) #define HAVE_RDRAND 1 static int get_rdrand_seed(void) { DEBUG_SEED("get_rdrand_seed"); int _eax; /* rdrand eax */ /* clang-format off */ __asm__ __volatile__("1: .byte 0x0F\n" " .byte 0xC7\n" " .byte 0xF0\n" " jnc 1b;\n" : "=a" (_eax)); /* clang-format on */ return _eax; } #endif #if defined _MSC_VER #if _MSC_VER >= 1700 #define HAVE_RDRAND 1 /* get_rdrand_seed - Visual Studio 2012 and above */ static int get_rdrand_seed(void) { DEBUG_SEED("get_rdrand_seed"); int r; while (_rdrand32_step(&r) == 0) ; return r; } #elif defined _M_IX86 #define HAVE_RDRAND 1 /* get_rdrand_seed - Visual Studio 2010 and below - x86 only */ /* clang-format off */ static int get_rdrand_seed(void) { DEBUG_SEED("get_rdrand_seed"); int _eax; retry: /* rdrand eax */ __asm _emit 0x0F __asm _emit 0xC7 __asm _emit 0xF0 __asm jnc retry __asm mov _eax, eax return _eax; } /* clang-format on */ #endif #endif #endif /* defined ENABLE_RDRAND */ #ifdef HAVE_GETRANDOM #include #ifdef HAVE_SYS_RANDOM_H #include #endif static int get_getrandom_seed(int *seed) { DEBUG_SEED("get_getrandom_seed"); ssize_t ret; do { ret = getrandom(seed, sizeof(*seed), GRND_NONBLOCK); } while ((ret == -1) && (errno == EINTR)); if (ret == -1) { if (errno == ENOSYS) /* syscall not available in kernel */ return -1; if (errno == EAGAIN) /* entropy not yet initialized */ return -1; fprintf(stderr, "error from getrandom(): %s", strerror(errno)); return -1; } if (ret != sizeof(*seed)) return -1; return 0; } #endif /* defined HAVE_GETRANDOM */ /* get_dev_random_seed */ #ifdef HAVE_DEV_RANDOM #include #include #if HAVE_UNISTD_H #include #endif /* HAVE_UNISTD_H */ #include #include static const char *dev_random_file = "/dev/urandom"; static int get_dev_random_seed(int *seed) { DEBUG_SEED("get_dev_random_seed"); struct stat buf; if (stat(dev_random_file, &buf)) return -1; if ((buf.st_mode & S_IFCHR) == 0) return -1; int fd = open(dev_random_file, O_RDONLY); if (fd < 0) { fprintf(stderr, "error opening %s: %s", dev_random_file, strerror(errno)); return -1; } ssize_t nread = read(fd, seed, sizeof(*seed)); close(fd); if (nread != sizeof(*seed)) { fprintf(stderr, "error short read %s: %s", dev_random_file, strerror(errno)); return -1; } return 0; } #endif /* get_cryptgenrandom_seed */ #ifdef WIN32 #define HAVE_CRYPTGENRANDOM 1 /* clang-format off */ #include /* Caution: these blank lines must remain so clang-format doesn't reorder includes to put windows.h after wincrypt.h */ #include /* clang-format on */ #ifndef __GNUC__ #pragma comment(lib, "advapi32.lib") #endif static int get_cryptgenrandom_seed(int *seed) { HCRYPTPROV hProvider = 0; DWORD dwFlags = CRYPT_VERIFYCONTEXT; DEBUG_SEED("get_cryptgenrandom_seed"); /* WinNT 4 and Win98 do no support CRYPT_SILENT */ if (LOBYTE(LOWORD(GetVersion())) > 4) dwFlags |= CRYPT_SILENT; if (!CryptAcquireContextA(&hProvider, 0, 0, PROV_RSA_FULL, dwFlags)) { fprintf(stderr, "error CryptAcquireContextA 0x%08lx", GetLastError()); return -1; } else { BOOL ret = CryptGenRandom(hProvider, sizeof(*seed), (BYTE *)seed); CryptReleaseContext(hProvider, 0); if (!ret) { fprintf(stderr, "error CryptGenRandom 0x%08lx", GetLastError()); return -1; } } return 0; } #endif /* get_time_seed */ #ifndef HAVE_ARC4RANDOM #include static int get_time_seed(void) { DEBUG_SEED("get_time_seed"); /* coverity[store_truncates_time_t] */ return (unsigned)time(NULL) * 433494437; } #endif /* json_c_get_random_seed */ int json_c_get_random_seed(void) { #ifdef OVERRIDE_GET_RANDOM_SEED OVERRIDE_GET_RANDOM_SEED; #endif #if defined HAVE_RDRAND && HAVE_RDRAND if (has_rdrand()) return get_rdrand_seed(); #endif #ifdef HAVE_ARC4RANDOM /* arc4random never fails, so use it if it's available */ return arc4random(); #else #ifdef HAVE_GETRANDOM { int seed = 0; if (get_getrandom_seed(&seed) == 0) return seed; } #endif #if defined HAVE_DEV_RANDOM && HAVE_DEV_RANDOM { int seed = 0; if (get_dev_random_seed(&seed) == 0) return seed; } #endif #if defined HAVE_CRYPTGENRANDOM && HAVE_CRYPTGENRANDOM { int seed = 0; if (get_cryptgenrandom_seed(&seed) == 0) return seed; } #endif return get_time_seed(); #endif /* !HAVE_ARC4RANDOM */ } json-c-json-c-0.17-20230812/random_seed.h000066400000000000000000000007721446575330000173660ustar00rootroot00000000000000/* * random_seed.h * * Copyright (c) 2013 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Do not use, json-c internal, may be changed or removed at any time. */ #ifndef seed_h #define seed_h #ifdef __cplusplus extern "C" { #endif extern int json_c_get_random_seed(void); #ifdef __cplusplus } #endif #endif json-c-json-c-0.17-20230812/snprintf_compat.h000066400000000000000000000017371446575330000203160ustar00rootroot00000000000000#ifndef __snprintf_compat_h #define __snprintf_compat_h /** * @file * @brief Do not use, json-c internal, may be changed or removed at any time. */ /* * Microsoft's _vsnprintf and _snprint don't always terminate * the string, so use wrappers that ensure that. */ #include #if !defined(HAVE_SNPRINTF) && (defined(_MSC_VER) || defined(__MINGW32__)) static int json_c_vsnprintf(char *str, size_t size, const char *format, va_list ap) { int ret; ret = _vsnprintf(str, size, format, ap); str[size - 1] = '\0'; return ret; } #define vsnprintf json_c_vsnprintf static int json_c_snprintf(char *str, size_t size, const char *format, ...) { va_list ap; int ret; va_start(ap, format); ret = json_c_vsnprintf(str, size, format, ap); va_end(ap); return ret; } #define snprintf json_c_snprintf #elif !defined(HAVE_SNPRINTF) /* !HAVE_SNPRINTF */ #error snprintf is required but was not found #endif /* !HAVE_SNPRINTF && defined(WIN32) */ #endif /* __snprintf_compat_h */ json-c-json-c-0.17-20230812/strdup_compat.h000066400000000000000000000005531446575330000177670ustar00rootroot00000000000000#ifndef __strdup_compat_h #define __strdup_compat_h /** * @file * @brief Do not use, json-c internal, may be changed or removed at any time. */ #if !defined(HAVE_STRDUP) && defined(_MSC_VER) /* MSC has the version as _strdup */ #define strdup _strdup #elif !defined(HAVE_STRDUP) #error You do not have strdup on your system. #endif /* HAVE_STRDUP */ #endif json-c-json-c-0.17-20230812/strerror_override.c000066400000000000000000000044031446575330000206550ustar00rootroot00000000000000#define STRERROR_OVERRIDE_IMPL 1 #include "strerror_override.h" /* * Override strerror() to get consistent output across platforms. */ static struct { int errno_value; const char *errno_str; } errno_list[] = { /* clang-format off */ #define STRINGIFY(x) #x #define ENTRY(x) {x, &STRINGIFY(undef_ ## x)[6]} ENTRY(EPERM), ENTRY(ENOENT), ENTRY(ESRCH), ENTRY(EINTR), ENTRY(EIO), ENTRY(ENXIO), ENTRY(E2BIG), #ifdef ENOEXEC ENTRY(ENOEXEC), #endif ENTRY(EBADF), ENTRY(ECHILD), ENTRY(EDEADLK), ENTRY(ENOMEM), ENTRY(EACCES), ENTRY(EFAULT), #ifdef ENOTBLK ENTRY(ENOTBLK), #endif ENTRY(EBUSY), ENTRY(EEXIST), ENTRY(EXDEV), ENTRY(ENODEV), ENTRY(ENOTDIR), ENTRY(EISDIR), ENTRY(EINVAL), ENTRY(ENFILE), ENTRY(EMFILE), ENTRY(ENOTTY), #ifdef ETXTBSY ENTRY(ETXTBSY), #endif ENTRY(EFBIG), ENTRY(ENOSPC), ENTRY(ESPIPE), ENTRY(EROFS), ENTRY(EMLINK), ENTRY(EPIPE), ENTRY(EDOM), ENTRY(ERANGE), ENTRY(EAGAIN), { 0, (char *)0 } }; /* clang-format on */ // Enabled during tests static int _json_c_strerror_enable = 0; extern char *getenv(const char *name); // Avoid including stdlib.h #define PREFIX "ERRNO=" static char errno_buf[128] = PREFIX; char *_json_c_strerror(int errno_in) { int start_idx; char digbuf[20]; int ii, jj; if (!_json_c_strerror_enable) _json_c_strerror_enable = (getenv("_JSON_C_STRERROR_ENABLE") == NULL) ? -1 : 1; if (_json_c_strerror_enable == -1) return strerror(errno_in); // Avoid standard functions, so we don't need to include any // headers, or guess at signatures. for (ii = 0; errno_list[ii].errno_str != (char *)0; ii++) { const char *errno_str = errno_list[ii].errno_str; if (errno_list[ii].errno_value != errno_in) continue; for (start_idx = sizeof(PREFIX) - 1, jj = 0; errno_str[jj] != '\0'; jj++, start_idx++) { errno_buf[start_idx] = errno_str[jj]; } errno_buf[start_idx] = '\0'; return errno_buf; } // It's not one of the known errno values, return the numeric value. for (ii = 0; errno_in >= 10; errno_in /= 10, ii++) { digbuf[ii] = "0123456789"[(errno_in % 10)]; } digbuf[ii] = "0123456789"[(errno_in % 10)]; // Reverse the digits for (start_idx = sizeof(PREFIX) - 1; ii >= 0; ii--, start_idx++) { errno_buf[start_idx] = digbuf[ii]; } errno_buf[start_idx] = '\0'; return errno_buf; } json-c-json-c-0.17-20230812/strerror_override.h000066400000000000000000000007751446575330000206720ustar00rootroot00000000000000#ifndef _json_strerror_override_h_ #define _json_strerror_override_h_ /** * @file * @brief Do not use, json-c internal, may be changed or removed at any time. */ #include "config.h" #include #include "json_object.h" /* for JSON_EXPORT */ #ifdef __cplusplus extern "C" { #endif #include JSON_EXPORT char *_json_c_strerror(int errno_in); #ifndef STRERROR_OVERRIDE_IMPL #define strerror _json_c_strerror #endif #ifdef __cplusplus } #endif #endif /* _json_strerror_override_h_ */ json-c-json-c-0.17-20230812/tests/000077500000000000000000000000001446575330000160715ustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/CMakeLists.txt000066400000000000000000000031501446575330000206300ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.1) add_executable(test1Formatted test1.c parse_flags.c parse_flags.h) target_compile_definitions(test1Formatted PRIVATE TEST_FORMATTED=1) target_link_libraries(test1Formatted PRIVATE ${PROJECT_NAME}) add_executable(test2Formatted test2.c parse_flags.c parse_flags.h) target_compile_definitions(test2Formatted PRIVATE TEST_FORMATTED=1) target_link_libraries(test2Formatted PRIVATE ${PROJECT_NAME}) # https://cmake.org/cmake/help/v3.0/command/add_test.html # https://pabloariasal.github.io/2018/02/19/its-time-to-do-cmake-right/ include_directories(PUBLIC ${CMAKE_SOURCE_DIR}) set(ALL_TEST_NAMES test1 test2 test4 testReplaceExisting test_cast test_charcase test_compare test_deep_copy test_double_serializer test_float test_int_add test_int_get test_locale test_null test_parse test_parse_int64 test_printbuf test_set_serializer test_set_value test_strerror test_util_file test_visit test_object_iterator) if (NOT DISABLE_JSON_POINTER) set(ALL_TEST_NAMES ${ALL_TEST_NAMES} test_json_pointer) if (NOT DISABLE_JSON_PATCH) set(ALL_TEST_NAMES ${ALL_TEST_NAMES} test_json_patch) endif() endif() foreach(TESTNAME ${ALL_TEST_NAMES}) add_executable(${TESTNAME} ${TESTNAME}.c) add_test(NAME ${TESTNAME} COMMAND ${PROJECT_SOURCE_DIR}/tests/${TESTNAME}.test) # XXX using the non-target_ versions of these doesn't work :( target_include_directories( ${TESTNAME} PUBLIC ${CMAKE_CURRENT_LIST_DIR} ) target_link_libraries( ${TESTNAME} PRIVATE ${PROJECT_NAME} ) endforeach(TESTNAME) json-c-json-c-0.17-20230812/tests/json_patch_spec_tests.json000066400000000000000000000077741446575330000233670ustar00rootroot00000000000000[ { "comment": "4.1. add with missing object", "doc": { "q": { "bar": 2 } }, "patch": [ {"op": "add", "path": "/a/b", "value": 1} ], "error": "path /a does not exist -- missing objects are not created recursively" }, { "comment": "A.1. Adding an Object Member", "doc": { "foo": "bar" }, "patch": [ { "op": "add", "path": "/baz", "value": "qux" } ], "expected": { "baz": "qux", "foo": "bar" } }, { "comment": "A.2. Adding an Array Element", "doc": { "foo": [ "bar", "baz" ] }, "patch": [ { "op": "add", "path": "/foo/1", "value": "qux" } ], "expected": { "foo": [ "bar", "qux", "baz" ] } }, { "comment": "A.3. Removing an Object Member", "doc": { "baz": "qux", "foo": "bar" }, "patch": [ { "op": "remove", "path": "/baz" } ], "expected": { "foo": "bar" } }, { "comment": "A.4. Removing an Array Element", "doc": { "foo": [ "bar", "qux", "baz" ] }, "patch": [ { "op": "remove", "path": "/foo/1" } ], "expected": { "foo": [ "bar", "baz" ] } }, { "comment": "A.5. Replacing a Value", "doc": { "baz": "qux", "foo": "bar" }, "patch": [ { "op": "replace", "path": "/baz", "value": "boo" } ], "expected": { "baz": "boo", "foo": "bar" } }, { "comment": "A.6. Moving a Value", "doc": { "foo": { "bar": "baz", "waldo": "fred" }, "qux": { "corge": "grault" } }, "patch": [ { "op": "move", "from": "/foo/waldo", "path": "/qux/thud" } ], "expected": { "foo": { "bar": "baz" }, "qux": { "corge": "grault", "thud": "fred" } } }, { "comment": "A.7. Moving an Array Element", "doc": { "foo": [ "all", "grass", "cows", "eat" ] }, "patch": [ { "op": "move", "from": "/foo/1", "path": "/foo/3" } ], "expected": { "foo": [ "all", "cows", "eat", "grass" ] } }, { "comment": "A.8. Testing a Value: Success", "doc": { "baz": "qux", "foo": [ "a", 2, "c" ] }, "patch": [ { "op": "test", "path": "/baz", "value": "qux" }, { "op": "test", "path": "/foo/1", "value": 2 } ], "expected": { "baz": "qux", "foo": [ "a", 2, "c" ] } }, { "comment": "A.9. Testing a Value: Error", "doc": { "baz": "qux" }, "patch": [ { "op": "test", "path": "/baz", "value": "bar" } ], "error": "string not equivalent" }, { "comment": "A.10. Adding a nested Member Object", "doc": { "foo": "bar" }, "patch": [ { "op": "add", "path": "/child", "value": { "grandchild": { } } } ], "expected": { "foo": "bar", "child": { "grandchild": { } } } }, { "comment": "A.11. Ignoring Unrecognized Elements", "doc": { "foo":"bar" }, "patch": [ { "op": "add", "path": "/baz", "value": "qux", "xyz": 123 } ], "expected": { "foo":"bar", "baz":"qux" } }, { "comment": "A.12. Adding to a Non-existent Target", "doc": { "foo": "bar" }, "patch": [ { "op": "add", "path": "/baz/bat", "value": "qux" } ], "error": "add to a non-existent target" }, { "comment": "A.13 Invalid JSON Patch Document", "doc": { "foo": "bar" }, "patch": [ { "op": "add", "path": "/baz", "value": "qux", "op": "remove" } ], "error_wont_happen_in_jsonc": "operation has two 'op' members", "error": "Did not find element referenced by path field" }, { "comment": "A.14. ~ Escape Ordering", "doc": { "/": 9, "~1": 10 }, "patch": [{"op": "test", "path": "/~01", "value": 10}], "expected": { "/": 9, "~1": 10 } }, { "comment": "A.15. Comparing Strings and Numbers", "doc": { "/": 9, "~1": 10 }, "patch": [{"op": "test", "path": "/~01", "value": "10"}], "error": "number is not equal to string" }, { "comment": "A.16. Adding an Array Value", "doc": { "foo": ["bar"] }, "patch": [{ "op": "add", "path": "/foo/-", "value": ["abc", "def"] }], "expected": { "foo": ["bar", ["abc", "def"]] } } ] json-c-json-c-0.17-20230812/tests/json_patch_tests.json000066400000000000000000000467601446575330000223530ustar00rootroot00000000000000[ { "comment": "empty list, empty docs", "doc": {}, "patch": [], "expected": {} }, { "comment": "empty patch list", "doc": {"foo": 1}, "patch": [], "expected": {"foo": 1} }, { "comment": "rearrangements OK?", "doc": {"foo": 1, "bar": 2}, "patch": [], "expected": {"bar":2, "foo": 1} }, { "comment": "rearrangements OK? How about one level down ... array", "doc": [{"foo": 1, "bar": 2}], "patch": [], "expected": [{"bar":2, "foo": 1}] }, { "comment": "rearrangements OK? How about one level down...", "doc": {"foo":{"foo": 1, "bar": 2}}, "patch": [], "expected": {"foo":{"bar":2, "foo": 1}} }, { "comment": "add replaces any existing field", "doc": {"foo": null}, "patch": [{"op": "add", "path": "/foo", "value":1}], "expected": {"foo": 1} }, { "comment": "toplevel array", "doc": [], "patch": [{"op": "add", "path": "/0", "value": "foo"}], "expected": ["foo"] }, { "comment": "toplevel array, no change", "doc": ["foo"], "patch": [], "expected": ["foo"] }, { "comment": "toplevel object, numeric string", "doc": {}, "patch": [{"op": "add", "path": "/foo", "value": "1"}], "expected": {"foo":"1"} }, { "comment": "toplevel object, integer", "doc": {}, "patch": [{"op": "add", "path": "/foo", "value": 1}], "expected": {"foo":1} }, { "comment": "Toplevel scalar values OK?", "doc": "foo", "patch": [{"op": "replace", "path": "", "value": "bar"}], "expected": "bar" }, { "comment": "replace object document with array document?", "doc": {}, "patch": [{"op": "add", "path": "", "value": []}], "expected": [] }, { "comment": "replace array document with object document?", "doc": [], "patch": [{"op": "add", "path": "", "value": {}}], "expected": {} }, { "comment": "append to root array document?", "doc": [], "patch": [{"op": "add", "path": "/-", "value": "hi"}], "expected": ["hi"] }, { "comment": "Add, / target", "doc": {}, "patch": [ {"op": "add", "path": "/", "value":1 } ], "expected": {"":1} }, { "comment": "Add, /foo/ deep target (trailing slash)", "doc": {"foo": {}}, "patch": [ {"op": "add", "path": "/foo/", "value":1 } ], "expected": {"foo":{"": 1}} }, { "comment": "Add composite value at top level", "doc": {"foo": 1}, "patch": [{"op": "add", "path": "/bar", "value": [1, 2]}], "expected": {"foo": 1, "bar": [1, 2]} }, { "comment": "Add into composite value", "doc": {"foo": 1, "baz": [{"qux": "hello"}]}, "patch": [{"op": "add", "path": "/baz/0/foo", "value": "world"}], "expected": {"foo": 1, "baz": [{"qux": "hello", "foo": "world"}]} }, { "doc": {"bar": [1, 2]}, "patch": [{"op": "add", "path": "/bar/8", "value": "5"}], "error": "Out of bounds (upper)" }, { "doc": {"bar": [1, 2]}, "patch": [{"op": "add", "path": "/bar/-1", "value": "5"}], "error": "Out of bounds (lower)" }, { "doc": {"foo": 1}, "patch": [{"op": "add", "path": "/bar", "value": true}], "expected": {"foo": 1, "bar": true} }, { "doc": {"foo": 1}, "patch": [{"op": "add", "path": "/bar", "value": false}], "expected": {"foo": 1, "bar": false} }, { "doc": {"foo": 1}, "patch": [{"op": "add", "path": "/bar", "value": null}], "expected": {"foo": 1, "bar": null} }, { "comment": "0 can be an array index or object element name", "doc": {"foo": 1}, "patch": [{"op": "add", "path": "/0", "value": "bar"}], "expected": {"foo": 1, "0": "bar" } }, { "doc": ["foo"], "patch": [{"op": "add", "path": "/1", "value": "bar"}], "expected": ["foo", "bar"] }, { "doc": ["foo", "sil"], "patch": [{"op": "add", "path": "/1", "value": "bar"}], "expected": ["foo", "bar", "sil"] }, { "doc": ["foo", "sil"], "patch": [{"op": "add", "path": "/0", "value": "bar"}], "expected": ["bar", "foo", "sil"] }, { "comment": "push item to array via last index + 1", "doc": ["foo", "sil"], "patch": [{"op":"add", "path": "/2", "value": "bar"}], "expected": ["foo", "sil", "bar"] }, { "comment": "add item to array at index > length should fail", "doc": ["foo", "sil"], "patch": [{"op":"add", "path": "/3", "value": "bar"}], "error": "index is greater than number of items in array" }, { "comment": "test against implementation-specific numeric parsing", "doc": {"1e0": "foo"}, "patch": [{"op": "test", "path": "/1e0", "value": "foo"}], "expected": {"1e0": "foo"} }, { "comment": "test with bad number should fail", "doc": ["foo", "bar"], "patch": [{"op": "test", "path": "/1e0", "value": "bar"}], "error": "test op shouldn't get array element 1" }, { "doc": ["foo", "sil"], "patch": [{"op": "add", "path": "/bar", "value": 42}], "error": "Object operation on array target" }, { "doc": ["foo", "sil"], "patch": [{"op": "add", "path": "/1", "value": ["bar", "baz"]}], "expected": ["foo", ["bar", "baz"], "sil"], "comment": "value in array add not flattened" }, { "doc": {"foo": 1, "bar": [1, 2, 3, 4]}, "patch": [{"op": "remove", "path": "/bar"}], "expected": {"foo": 1} }, { "doc": {"foo": 1, "baz": [{"qux": "hello"}]}, "patch": [{"op": "remove", "path": "/baz/0/qux"}], "expected": {"foo": 1, "baz": [{}]} }, { "doc": {"foo": 1, "baz": [{"qux": "hello"}]}, "patch": [{"op": "replace", "path": "/foo", "value": [1, 2, 3, 4]}], "expected": {"foo": [1, 2, 3, 4], "baz": [{"qux": "hello"}]} }, { "doc": {"foo": [1, 2, 3, 4], "baz": [{"qux": "hello"}]}, "patch": [{"op": "replace", "path": "/baz/0/qux", "value": "world"}], "expected": {"foo": [1, 2, 3, 4], "baz": [{"qux": "world"}]} }, { "doc": ["foo"], "patch": [{"op": "replace", "path": "/0", "value": "bar"}], "expected": ["bar"] }, { "doc": [""], "patch": [{"op": "replace", "path": "/0", "value": 0}], "expected": [0] }, { "doc": [""], "patch": [{"op": "replace", "path": "/0", "value": true}], "expected": [true] }, { "doc": [""], "patch": [{"op": "replace", "path": "/0", "value": false}], "expected": [false] }, { "doc": [""], "patch": [{"op": "replace", "path": "/0", "value": null}], "expected": [null] }, { "doc": ["foo", "sil"], "patch": [{"op": "replace", "path": "/1", "value": ["bar", "baz"]}], "expected": ["foo", ["bar", "baz"]], "comment": "value in array replace not flattened" }, { "comment": "replace whole document", "doc": {"foo": "bar"}, "patch": [{"op": "replace", "path": "", "value": {"baz": "qux"}}], "expected": {"baz": "qux"} }, { "comment": "add whole document, null", "doc": {}, "Note1": "We can't pass null in to json_patch_apply, so start with _something_ and remove it", "patch": [ {"op": "remove", "path": ""}, {"op": "add", "path": "", "value": {"baz": "qux"}} ], "expected": {"baz": "qux"} }, { "comment": "replace whole document, null", "doc": {}, "Note1": "We can't pass null in to json_patch_apply, so start with _something_ and remove it", "patch": [ {"op": "remove", "path": ""}, {"op": "replace", "path": "", "value": {"baz": "qux"}} ], "error": "The spec says the target location must exist, so replacing a null document fails" }, { "comment": "remove whole document", "doc": {"foo": "bar"}, "patch": [{"op": "remove", "path": ""}], "expected": null }, { "comment": "remove whole document", "doc": {"foo": "bar"}, "patch": [{"op": "remove", "path": ""}], "expected": null }, { "comment": "remove whole document, array", "doc": ["foo", "bar"], "patch": [{"op": "remove", "path": ""}], "expected": null }, { "comment": "remove whole document, string", "doc": "foo", "patch": [{"op": "remove", "path": ""}], "expected": null }, { "comment": "remove whole document, null", "doc": {}, "Note1": "We can't pass null in to json_patch_apply, so start with _something_ and remove it", "patch": [ {"op": "remove", "path": ""}, {"op": "remove", "path": ""}, ], "error": "The spec says the target location must exist, so removing a null document fails" }, { "comment": "test replace with missing parent key should fail", "doc": {"bar": "baz"}, "patch": [{"op": "replace", "path": "/foo/bar", "value": false}], "error": "replace op should fail with missing parent key" }, { "comment": "spurious patch properties", "doc": {"foo": 1}, "patch": [{"op": "test", "path": "/foo", "value": 1, "spurious": 1}], "expected": {"foo": 1} }, { "doc": {"foo": null}, "patch": [{"op": "test", "path": "/foo", "value": null}], "expected": {"foo": null}, "comment": "null value should be valid obj property" }, { "doc": {"foo": null}, "patch": [{"op": "replace", "path": "/foo", "value": "truthy"}], "expected": {"foo": "truthy"}, "comment": "null value should be valid obj property to be replaced with something truthy" }, { "doc": {"foo": null}, "patch": [{"op": "move", "from": "/foo", "path": "/bar"}], "expected": {"bar": null}, "comment": "null value should be valid obj property to be moved" }, { "doc": {"foo": null}, "patch": [{"op": "copy", "from": "/foo", "path": "/bar"}], "expected": {"foo": null, "bar": null}, "comment": "null value should be valid obj property to be copied" }, { "doc": {"foo": null}, "patch": [{"op": "remove", "path": "/foo"}], "expected": {}, "comment": "null value should be valid obj property to be removed" }, { "doc": {"foo": "bar"}, "patch": [{"op": "replace", "path": "/foo", "value": null}], "expected": {"foo": null}, "comment": "null value should still be valid obj property replace other value" }, { "doc": {"foo": {"foo": 1, "bar": 2}}, "patch": [{"op": "test", "path": "/foo", "value": {"bar": 2, "foo": 1}}], "expected": {"foo": {"foo": 1, "bar": 2}}, "comment": "test should pass despite rearrangement" }, { "doc": {"foo": [{"foo": 1, "bar": 2}]}, "patch": [{"op": "test", "path": "/foo", "value": [{"bar": 2, "foo": 1}]}], "expected": {"foo": [{"foo": 1, "bar": 2}]}, "comment": "test should pass despite (nested) rearrangement" }, { "doc": {"foo": {"bar": [1, 2, 5, 4]}}, "patch": [{"op": "test", "path": "/foo", "value": {"bar": [1, 2, 5, 4]}}], "expected": {"foo": {"bar": [1, 2, 5, 4]}}, "comment": "test should pass - no error" }, { "doc": {"foo": {"bar": [1, 2, 5, 4]}}, "patch": [{"op": "test", "path": "/foo", "value": [1, 2]}], "error": "test op should fail" }, { "comment": "Test the whole document", "doc": { "foo": 1 }, "patch": [{"op": "test", "path": "", "value": {"foo": 1}}], "expected": { "foo": 1 } }, { "comment": "Test the whole document, no match", "doc": { "foo": 1 }, "patch": [{"op": "test", "path": "", "value": {"foo": 2}}], "expected": { "foo": 1 }, "error": "Tested value does not match original doc" }, { "comment": "Empty-string element", "doc": { "": 1 }, "patch": [{"op": "test", "path": "/", "value": 1}], "expected": { "": 1 } }, { "doc": { "foo": ["bar", "baz"], "": 0, "a/b": 1, "c%d": 2, "e^f": 3, "g|h": 4, "i\\j": 5, "k\"l": 6, " ": 7, "m~n": 8 }, "patch": [{"op": "test", "path": "/foo", "value": ["bar", "baz"]}, {"op": "test", "path": "/foo/0", "value": "bar"}, {"op": "test", "path": "/", "value": 0}, {"op": "test", "path": "/a~1b", "value": 1}, {"op": "test", "path": "/c%d", "value": 2}, {"op": "test", "path": "/e^f", "value": 3}, {"op": "test", "path": "/g|h", "value": 4}, {"op": "test", "path": "/i\\j", "value": 5}, {"op": "test", "path": "/k\"l", "value": 6}, {"op": "test", "path": "/ ", "value": 7}, {"op": "test", "path": "/m~0n", "value": 8}], "expected": { "": 0, " ": 7, "a/b": 1, "c%d": 2, "e^f": 3, "foo": [ "bar", "baz" ], "g|h": 4, "i\\j": 5, "k\"l": 6, "m~n": 8 } }, { "comment": "Move to same location has no effect", "doc": {"foo": 1}, "patch": [{"op": "move", "from": "/foo", "path": "/foo"}], "expected": {"foo": 1} }, { "doc": {"foo": 1, "baz": [{"qux": "hello"}]}, "patch": [{"op": "move", "from": "/foo", "path": "/bar"}], "expected": {"baz": [{"qux": "hello"}], "bar": 1} }, { "doc": {"baz": [{"qux": "hello"}], "bar": 1}, "patch": [{"op": "move", "from": "/baz/0/qux", "path": "/baz/1"}], "expected": {"baz": [{}, "hello"], "bar": 1} }, { "doc": {"baz": [{"qux": "hello"}], "bar": 1}, "patch": [{"op": "copy", "from": "/baz/0", "path": "/boo"}], "expected": {"baz":[{"qux":"hello"}],"bar":1,"boo":{"qux":"hello"}} }, { "comment": "replacing the root of the document is possible with add", "doc": {"foo": "bar"}, "patch": [{"op": "add", "path": "", "value": {"baz": "qux"}}], "expected": {"baz":"qux"}}, { "comment": "Adding to \"/-\" adds to the end of the array", "doc": [ 1, 2 ], "patch": [ { "op": "add", "path": "/-", "value": { "foo": [ "bar", "baz" ] } } ], "expected": [ 1, 2, { "foo": [ "bar", "baz" ] } ]}, { "comment": "Adding to \"/-\" adds to the end of the array, even n levels down", "doc": [ 1, 2, [ 3, [ 4, 5 ] ] ], "patch": [ { "op": "add", "path": "/2/1/-", "value": { "foo": [ "bar", "baz" ] } } ], "expected": [ 1, 2, [ 3, [ 4, 5, { "foo": [ "bar", "baz" ] } ] ] ]}, { "comment": "test remove with bad number should fail", "doc": {"foo": 1, "baz": [{"qux": "hello"}]}, "patch": [{"op": "remove", "path": "/baz/1e0/qux"}], "error": "remove op shouldn't remove from array with bad number" }, { "comment": "test remove on array", "doc": [1, 2, 3, 4], "patch": [{"op": "remove", "path": "/0"}], "expected": [2, 3, 4] }, { "comment": "test repeated removes", "doc": [1, 2, 3, 4], "patch": [{ "op": "remove", "path": "/1" }, { "op": "remove", "path": "/2" }], "expected": [1, 3] }, { "comment": "test remove with bad index should fail", "doc": [1, 2, 3, 4], "patch": [{"op": "remove", "path": "/1e0"}], "error": "remove op shouldn't remove from array with bad number" }, { "comment": "test replace with bad number should fail", "doc": [""], "patch": [{"op": "replace", "path": "/1e0", "value": false}], "error": "replace op shouldn't replace in array with bad number" }, { "comment": "test copy with bad number should fail", "doc": {"baz": [1,2,3], "bar": 1}, "patch": [{"op": "copy", "from": "/baz/1e0", "path": "/boo"}], "error": "copy op shouldn't work with bad number" }, { "comment": "test move with bad number should fail", "doc": {"foo": 1, "baz": [1,2,3,4]}, "patch": [{"op": "move", "from": "/baz/1e0", "path": "/foo"}], "error": "move op shouldn't work with bad number" }, { "comment": "test add with bad number should fail", "doc": ["foo", "sil"], "patch": [{"op": "add", "path": "/1e0", "value": "bar"}], "error": "add op shouldn't add to array with bad number" }, { "comment": "missing 'path' parameter", "doc": {}, "patch": [ { "op": "add", "value": "bar" } ], "error": "missing 'path' parameter" }, { "comment": "'path' parameter with null value", "doc": {}, "patch": [ { "op": "add", "path": null, "value": "bar" } ], "error": "null is not valid value for 'path'" }, { "comment": "invalid JSON Pointer token", "doc": {}, "patch": [ { "op": "add", "path": "foo", "value": "bar" } ], "error": "JSON Pointer should start with a slash" }, { "comment": "missing 'value' parameter to add", "doc": [ 1 ], "patch": [ { "op": "add", "path": "/-" } ], "error": "missing 'value' parameter" }, { "comment": "missing 'value' parameter to replace", "doc": [ 1 ], "patch": [ { "op": "replace", "path": "/0" } ], "error": "missing 'value' parameter" }, { "comment": "missing 'value' parameter to test", "doc": [ null ], "patch": [ { "op": "test", "path": "/0" } ], "error": "missing 'value' parameter" }, { "comment": "missing value parameter to test - where undef is falsy", "doc": [ false ], "patch": [ { "op": "test", "path": "/0" } ], "error": "missing 'value' parameter" }, { "comment": "missing from parameter to copy", "doc": [ 1 ], "patch": [ { "op": "copy", "path": "/-" } ], "error": "missing 'from' parameter" }, { "comment": "missing from location to copy", "doc": { "foo": 1 }, "patch": [ { "op": "copy", "from": "/bar", "path": "/foo" } ], "error": "missing 'from' location" }, { "comment": "missing from parameter to move", "doc": { "foo": 1 }, "patch": [ { "op": "move", "path": "" } ], "error": "missing 'from' parameter" }, { "comment": "missing from location to move", "doc": { "foo": 1 }, "patch": [ { "op": "move", "from": "/bar", "path": "/foo" } ], "error": "missing 'from' location" }, { "comment": "duplicate ops, json-c parses this as op:move", "doc": { "foo": "bar" }, "patch": [ { "op": "add", "path": "/baz", "value": "qux", "op": "move", "from":"/foo" } ], "error_wont_happen_in_jsonc": "patch has two 'op' members", "expected": { "baz": "bar" } }, { "comment": "unrecognized op should fail", "doc": {"foo": 1}, "patch": [{"op": "spam", "path": "/foo", "value": 1}], "error": "Unrecognized op 'spam'" }, { "comment": "test with bad array number that has leading zeros", "doc": ["foo", "bar"], "patch": [{"op": "test", "path": "/00", "value": "foo"}], "error": "test op should reject the array value, it has leading zeros" }, { "comment": "test with bad array number that has leading zeros", "doc": ["foo", "bar"], "patch": [{"op": "test", "path": "/01", "value": "bar"}], "error": "test op should reject the array value, it has leading zeros" }, { "comment": "Removing nonexistent field", "doc": {"foo" : "bar"}, "patch": [{"op": "remove", "path": "/baz"}], "error": "removing a nonexistent field should fail" }, { "comment": "Removing deep nonexistent path", "doc": {"foo" : "bar"}, "patch": [{"op": "remove", "path": "/missing1/missing2"}], "error": "removing a nonexistent field should fail" }, { "comment": "Removing nonexistent index", "doc": ["foo", "bar"], "patch": [{"op": "remove", "path": "/2"}], "error": "removing a nonexistent index should fail" }, { "comment": "Patch with different capitalisation than doc", "doc": {"foo":"bar"}, "patch": [{"op": "add", "path": "/FOO", "value": "BAR"}], "expected": {"foo": "bar", "FOO": "BAR"} } ] json-c-json-c-0.17-20230812/tests/parse_flags.c000066400000000000000000000020501446575330000205200ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include "config.h" #include #include #include "json.h" #include "parse_flags.h" #if !defined(HAVE_STRCASECMP) && defined(_MSC_VER) #define strcasecmp _stricmp #elif !defined(HAVE_STRCASECMP) #error You do not have strcasecmp on your system. #endif /* HAVE_STRNCASECMP */ static struct { const char *arg; int flag; } format_args[] = { {"plain", JSON_C_TO_STRING_PLAIN}, {"spaced", JSON_C_TO_STRING_SPACED}, {"pretty", JSON_C_TO_STRING_PRETTY}, {"pretty_tab", JSON_C_TO_STRING_PRETTY_TAB}, }; #ifndef NELEM #define NELEM(x) (sizeof(x) / sizeof(x[0])) #endif int parse_flags(int argc, char **argv) { int arg_idx; int sflags = 0; for (arg_idx = 1; arg_idx < argc; arg_idx++) { int jj; for (jj = 0; jj < (int)NELEM(format_args); jj++) { if (strcasecmp(argv[arg_idx], format_args[jj].arg) == 0) { sflags |= format_args[jj].flag; break; } } if (jj == NELEM(format_args)) { printf("Unknown arg: %s\n", argv[arg_idx]); exit(1); } } return sflags; } json-c-json-c-0.17-20230812/tests/parse_flags.h000066400000000000000000000001371446575330000205310ustar00rootroot00000000000000#ifndef __parse_flags_h #define __parse_flags_h int parse_flags(int argc, char **argv); #endif json-c-json-c-0.17-20230812/tests/test-defs.sh000077500000000000000000000063041446575330000203310ustar00rootroot00000000000000#!/bin/sh if [ ! -z "$JSONC_TEST_TRACE" ] ; then VERBOSE=1 set -x set -v fi # Make sure srcdir is an absolute path. Supply the variable # if it does not exist. We want to be able to run the tests # stand-alone!! # srcdir=${srcdir-.} if test ! -d $srcdir ; then echo "test-defs.sh: installation error" 1>&2 exit 1 fi # Use absolute paths case "$srcdir" in /* | [A-Za-z]:\\*) ;; *) srcdir=`\cd $srcdir && pwd` ;; esac case "$top_builddir" in /* | [A-Za-z]:\\*) ;; *) top_builddir=`\cd ${top_builddir-..} && pwd` ;; esac top_builddir=${top_builddir}/tests progname=`echo "$0" | sed 's,^.*/,,'` testname=`echo "$progname" | sed 's,-.*$,,'` testsubdir=${testsubdir-testSubDir} testsubdir=${testsubdir}/${progname} # User can set VERBOSE to cause output redirection case "$VERBOSE" in [Nn]|[Nn][Oo]|0|"") VERBOSE=0 exec > /dev/null ;; [Yy]|[Yy][Ee][Ss]) VERBOSE=1 ;; esac rm -rf "$testsubdir" > /dev/null 2>&1 mkdir -p "$testsubdir" CURDIR=$(pwd) cd "$testsubdir" \ || { echo "Cannot make or change into $testsubdir"; exit 1; } echo "=== Running test $progname" CMP="${CMP-cmp}" use_valgrind=${USE_VALGRIND-1} case "${use_valgrind}" in [0Nn]*) use_valgrind=0 ;; *) use_valgrind=1 ;; esac valgrind_path=$(which valgrind 2> /dev/null) if [ -z "${valgrind_path}" -o ! -x "${valgrind_path}" ] ; then use_valgrind=0 fi # # This is a common function to check the results of a test program # that is intended to generate consistent output across runs. # # ${top_builddir} must be set to the top level build directory. # # Output will be written to the current directory. # # It must be passed the name of the test command to run, which must be present # in the ${top_builddir} directory. # # It will compare the output of running that against .expected # run_output_test() { if [ "$1" = "-o" ] ; then TEST_OUTPUT="$2" shift shift fi TEST_COMMAND="$1" shift if [ -z "${TEST_OUTPUT}" ] ; then TEST_OUTPUT=${TEST_COMMAND} fi REDIR_OUTPUT="> \"${TEST_OUTPUT}.out\"" if [ $VERBOSE -gt 1 ] ; then REDIR_OUTPUT="| tee \"${TEST_OUTPUT}.out\"" fi if [ $use_valgrind -eq 1 ] ; then eval valgrind --tool=memcheck \ --trace-children=yes \ --demangle=yes \ --log-file="${TEST_OUTPUT}.vg.out" \ --leak-check=full \ --show-reachable=yes \ --run-libc-freeres=yes \ "\"${top_builddir}/${TEST_COMMAND}\"" \"\$@\" ${REDIR_OUTPUT} err=$? else eval "\"${top_builddir}/${TEST_COMMAND}"\" \"\$@\" ${REDIR_OUTPUT} err=$? fi if [ $err -ne 0 ] ; then echo "ERROR: \"${TEST_COMMAND} $@\" exited with non-zero exit status: $err" 1>&2 fi if [ $use_valgrind -eq 1 ] ; then if ! tail -1 "${TEST_OUTPUT}.vg.out" | grep -q "ERROR SUMMARY: 0 errors" ; then echo "ERROR: valgrind found errors during execution:" 1>&2 cat "${TEST_OUTPUT}.vg.out" err=1 fi fi if ! "$CMP" -s "${srcdir}/${TEST_OUTPUT}.expected" "${TEST_OUTPUT}.out" ; then echo "ERROR: \"${TEST_COMMAND} $@\" (${TEST_OUTPUT}) failed (set VERBOSE=1 to see full output):" 1>&2 (cd "${CURDIR}" ; set -x ; diff "${srcdir}/${TEST_OUTPUT}.expected" "$testsubdir/${TEST_OUTPUT}.out") echo "cp \"$testsubdir/${TEST_OUTPUT}.out\" \"${srcdir}/${TEST_OUTPUT}.expected\"" 1>&2 err=1 fi return $err } json-c-json-c-0.17-20230812/tests/test1.c000066400000000000000000000300161446575330000172750ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include #include #include #include "config.h" #include "json.h" #include "parse_flags.h" static int sort_fn(const void *j1, const void *j2) { json_object *const *jso1, *const *jso2; int i1, i2; jso1 = (json_object *const *)j1; jso2 = (json_object *const *)j2; if (!*jso1 && !*jso2) return 0; if (!*jso1) return -1; if (!*jso2) return 1; i1 = json_object_get_int(*jso1); i2 = json_object_get_int(*jso2); return i1 - i2; } #ifdef TEST_FORMATTED static const char *to_json_string(json_object *obj, int flags) { size_t length; char *copy; const char *result; result = json_object_to_json_string_length(obj, flags, &length); copy = strdup(result); if (copy == NULL) printf("to_json_string: Allocation failed!\n"); else { result = json_object_to_json_string_ext(obj, flags); if (length != strlen(result)) printf("to_json_string: Length mismatch!\n"); if (strcmp(copy, result) != 0) printf("to_json_string: Comparison Failed!\n"); free(copy); } return result; } #define json_object_to_json_string(obj) to_json_string(obj, sflags) #else /* no special define */ #endif json_object *make_array(void); json_object *make_array(void) { json_object *my_array; my_array = json_object_new_array(); json_object_array_add(my_array, json_object_new_int(1)); json_object_array_add(my_array, json_object_new_int(2)); json_object_array_add(my_array, json_object_new_int(3)); json_object_array_put_idx(my_array, 4, json_object_new_int(5)); json_object_array_put_idx(my_array, 3, json_object_new_int(4)); json_object_array_put_idx(my_array, 6, json_object_new_int(7)); return my_array; } void test_array_del_idx(void); void test_array_del_idx(void) { int rc; size_t ii; size_t orig_array_len; json_object *my_array; #ifdef TEST_FORMATTED int sflags = 0; #endif my_array = make_array(); orig_array_len = json_object_array_length(my_array); printf("my_array=\n"); for (ii = 0; ii < json_object_array_length(my_array); ii++) { json_object *obj = json_object_array_get_idx(my_array, ii); printf("\t[%d]=%s\n", (int)ii, json_object_to_json_string(obj)); } printf("my_array.to_string()=%s\n", json_object_to_json_string(my_array)); for (ii = 0; ii < orig_array_len; ii++) { rc = json_object_array_del_idx(my_array, 0, 1); printf("after del_idx(0,1)=%d, my_array.to_string()=%s\n", rc, json_object_to_json_string(my_array)); } /* One more time, with the empty array: */ rc = json_object_array_del_idx(my_array, 0, 1); printf("after del_idx(0,1)=%d, my_array.to_string()=%s\n", rc, json_object_to_json_string(my_array)); json_object_put(my_array); /* Delete all array indexes at once */ my_array = make_array(); rc = json_object_array_del_idx(my_array, 0, orig_array_len); printf("after del_idx(0,%d)=%d, my_array.to_string()=%s\n", (int)orig_array_len, rc, json_object_to_json_string(my_array)); json_object_put(my_array); /* Delete *more* than all array indexes at once */ my_array = make_array(); rc = json_object_array_del_idx(my_array, 0, orig_array_len + 1); printf("after del_idx(0,%d)=%d, my_array.to_string()=%s\n", (int)(orig_array_len + 1), rc, json_object_to_json_string(my_array)); json_object_put(my_array); /* Delete some array indexes, then add more */ my_array = make_array(); rc = json_object_array_del_idx(my_array, 0, orig_array_len - 1); printf("after del_idx(0,%d)=%d, my_array.to_string()=%s\n", (int)(orig_array_len - 1), rc, json_object_to_json_string(my_array)); json_object_array_add(my_array, json_object_new_string("s1")); json_object_array_add(my_array, json_object_new_string("s2")); json_object_array_add(my_array, json_object_new_string("s3")); printf("after adding more entries, my_array.to_string()=%s\n", json_object_to_json_string(my_array)); json_object_put(my_array); } void test_array_list_expand_internal(void); void test_array_list_expand_internal(void) { int rc; size_t ii; size_t idx; json_object *my_array; #ifdef TEST_FORMATTED int sflags = 0; #endif my_array = make_array(); printf("my_array=\n"); for (ii = 0; ii < json_object_array_length(my_array); ii++) { json_object *obj = json_object_array_get_idx(my_array, ii); printf("\t[%d]=%s\n", (int)ii, json_object_to_json_string(obj)); } printf("my_array.to_string()=%s\n", json_object_to_json_string(my_array)); /* Put iNdex < array->size, no expand. */ rc = json_object_array_put_idx(my_array, 5, json_object_new_int(6)); printf("put_idx(5,6)=%d\n", rc); /* array->size < Put Index < array->size * 2 <= SIZE_T_MAX, the size = array->size * 2. */ idx = ARRAY_LIST_DEFAULT_SIZE * 2 - 1; rc = json_object_array_put_idx(my_array, idx, json_object_new_int(0)); printf("put_idx(%d,0)=%d\n", (int)(idx), rc); /* array->size * 2 < Put Index, the size = Put Index. */ idx = ARRAY_LIST_DEFAULT_SIZE * 2 * 2 + 1; rc = json_object_array_put_idx(my_array, idx, json_object_new_int(0)); printf("put_idx(%d,0)=%d\n", (int)(idx), rc); /* SIZE_T_MAX <= Put Index, it will fail and the size will no change. */ idx = SIZE_MAX; // SIZE_MAX = SIZE_T_MAX json_object *tmp = json_object_new_int(10); rc = json_object_array_put_idx(my_array, idx, tmp); printf("put_idx(SIZE_T_MAX,0)=%d\n", rc); if (rc == -1) { json_object_put(tmp); } json_object_put(my_array); } void test_array_insert_idx(void); void test_array_insert_idx(void) { json_object *my_array; struct json_object *jo1; my_array = json_object_new_array(); json_object_array_add(my_array, json_object_new_int(1)); json_object_array_add(my_array, json_object_new_int(2)); json_object_array_add(my_array, json_object_new_int(5)); json_object_array_insert_idx(my_array, 2, json_object_new_int(4)); jo1 = json_tokener_parse("[1, 2, 4, 5]"); assert(1 == json_object_equal(my_array, jo1)); json_object_put(jo1); json_object_array_insert_idx(my_array, 2, json_object_new_int(3)); jo1 = json_tokener_parse("[1, 2, 3, 4, 5]"); assert(1 == json_object_equal(my_array, jo1)); json_object_put(jo1); json_object_array_insert_idx(my_array, 5, json_object_new_int(6)); jo1 = json_tokener_parse("[1, 2, 3, 4, 5, 6]"); assert(1 == json_object_equal(my_array, jo1)); json_object_put(jo1); json_object_array_insert_idx(my_array, 7, json_object_new_int(8)); jo1 = json_tokener_parse("[1, 2, 3, 4, 5, 6, null, 8]"); assert(1 == json_object_equal(my_array, jo1)); json_object_put(jo1); json_object_put(my_array); } int main(int argc, char **argv) { json_object *my_string, *my_int, *my_null, *my_object, *my_array; size_t i; #ifdef TEST_FORMATTED int sflags = 0; #endif MC_SET_DEBUG(1); #ifdef TEST_FORMATTED sflags = parse_flags(argc, argv); #endif my_string = json_object_new_string("\t"); printf("my_string=%s\n", json_object_get_string(my_string)); printf("my_string.to_string()=%s\n", json_object_to_json_string(my_string)); json_object_put(my_string); my_string = json_object_new_string("\\"); printf("my_string=%s\n", json_object_get_string(my_string)); printf("my_string.to_string()=%s\n", json_object_to_json_string(my_string)); json_object_put(my_string); my_string = json_object_new_string("/"); printf("my_string=%s\n", json_object_get_string(my_string)); printf("my_string.to_string()=%s\n", json_object_to_json_string(my_string)); printf("my_string.to_string(NOSLASHESCAPE)=%s\n", json_object_to_json_string_ext(my_string, JSON_C_TO_STRING_NOSLASHESCAPE)); json_object_put(my_string); my_string = json_object_new_string("/foo/bar/baz"); printf("my_string=%s\n", json_object_get_string(my_string)); printf("my_string.to_string()=%s\n", json_object_to_json_string(my_string)); printf("my_string.to_string(NOSLASHESCAPE)=%s\n", json_object_to_json_string_ext(my_string, JSON_C_TO_STRING_NOSLASHESCAPE)); json_object_put(my_string); my_string = json_object_new_string("foo"); printf("my_string=%s\n", json_object_get_string(my_string)); printf("my_string.to_string()=%s\n", json_object_to_json_string(my_string)); my_int = json_object_new_int(9); printf("my_int=%d\n", json_object_get_int(my_int)); printf("my_int.to_string()=%s\n", json_object_to_json_string(my_int)); my_null = json_object_new_null(); printf("my_null.to_string()=%s\n", json_object_to_json_string(my_null)); my_array = json_object_new_array(); json_object_array_add(my_array, json_object_new_int(1)); json_object_array_add(my_array, json_object_new_int(2)); json_object_array_add(my_array, json_object_new_int(3)); json_object_array_put_idx(my_array, 4, json_object_new_int(5)); printf("my_array=\n"); for (i = 0; i < json_object_array_length(my_array); i++) { json_object *obj = json_object_array_get_idx(my_array, i); printf("\t[%d]=%s\n", (int)i, json_object_to_json_string(obj)); } printf("my_array.to_string()=%s\n", json_object_to_json_string(my_array)); json_object_put(my_array); test_array_insert_idx(); test_array_del_idx(); test_array_list_expand_internal(); my_array = json_object_new_array_ext(5); json_object_array_add(my_array, json_object_new_int(3)); json_object_array_add(my_array, json_object_new_int(1)); json_object_array_add(my_array, json_object_new_int(2)); json_object_array_put_idx(my_array, 4, json_object_new_int(0)); printf("my_array=\n"); for (i = 0; i < json_object_array_length(my_array); i++) { json_object *obj = json_object_array_get_idx(my_array, i); printf("\t[%d]=%s\n", (int)i, json_object_to_json_string(obj)); } printf("my_array.to_string()=%s\n", json_object_to_json_string(my_array)); json_object_array_sort(my_array, sort_fn); printf("my_array=\n"); for (i = 0; i < json_object_array_length(my_array); i++) { json_object *obj = json_object_array_get_idx(my_array, i); printf("\t[%d]=%s\n", (int)i, json_object_to_json_string(obj)); } printf("my_array.to_string()=%s\n", json_object_to_json_string(my_array)); json_object *one = json_object_new_int(1); json_object *result = json_object_array_bsearch(one, my_array, sort_fn); printf("find json_object(1) in my_array successfully: %s\n", json_object_to_json_string(result)); json_object_put(one); my_object = json_object_new_object(); int rc = json_object_object_add(my_object, "abc", my_object); if (rc != -1) { printf("ERROR: able to successfully add object to itself!\n"); fflush(stdout); } json_object_object_add(my_object, "abc", json_object_new_int(12)); json_object_object_add(my_object, "foo", json_object_new_string("bar")); json_object_object_add(my_object, "bool0", json_object_new_boolean(0)); json_object_object_add(my_object, "bool1", json_object_new_boolean(1)); json_object_object_add(my_object, "baz", json_object_new_string("bang")); json_object *baz_obj = json_object_new_string("fark"); json_object_get(baz_obj); json_object_object_add(my_object, "baz", baz_obj); json_object_object_del(my_object, "baz"); /* baz_obj should still be valid */ printf("baz_obj.to_string()=%s\n", json_object_to_json_string(baz_obj)); json_object_put(baz_obj); /*json_object_object_add(my_object, "arr", my_array);*/ printf("my_object=\n"); json_object_object_foreach(my_object, key, val) { printf("\t%s: %s\n", key, json_object_to_json_string(val)); } json_object *empty_array = json_object_new_array(); json_object *empty_obj = json_object_new_object(); json_object_object_add(my_object, "empty_array", empty_array); json_object_object_add(my_object, "empty_obj", empty_obj); printf("my_object.to_string()=%s\n", json_object_to_json_string(my_object)); json_object_put(my_array); my_array = json_object_new_array_ext(INT_MIN + 1); if (my_array != NULL) { printf("ERROR: able to allocate an array of negative size!\n"); fflush(stdout); json_object_put(my_array); my_array = NULL; } #if SIZEOF_SIZE_T == SIZEOF_INT my_array = json_object_new_array_ext(INT_MAX / 2 + 2); if (my_array != NULL) { printf("ERROR: able to allocate an array of insufficient size!\n"); fflush(stdout); json_object_put(my_array); my_array = NULL; } #endif json_object_put(my_string); json_object_put(my_int); json_object_put(my_null); json_object_put(my_object); json_object_put(my_array); return EXIT_SUCCESS; } json-c-json-c-0.17-20230812/tests/test1.expected000066400000000000000000000035161446575330000206610ustar00rootroot00000000000000my_string= my_string.to_string()="\t" my_string=\ my_string.to_string()="\\" my_string=/ my_string.to_string()="\/" my_string.to_string(NOSLASHESCAPE)="/" my_string=/foo/bar/baz my_string.to_string()="\/foo\/bar\/baz" my_string.to_string(NOSLASHESCAPE)="/foo/bar/baz" my_string=foo my_string.to_string()="foo" my_int=9 my_int.to_string()=9 my_null.to_string()=null my_array= [0]=1 [1]=2 [2]=3 [3]=null [4]=5 my_array.to_string()=[ 1, 2, 3, null, 5 ] my_array= [0]=1 [1]=2 [2]=3 [3]=4 [4]=5 [5]=null [6]=7 my_array.to_string()=[ 1, 2, 3, 4, 5, null, 7 ] after del_idx(0,1)=0, my_array.to_string()=[ 2, 3, 4, 5, null, 7 ] after del_idx(0,1)=0, my_array.to_string()=[ 3, 4, 5, null, 7 ] after del_idx(0,1)=0, my_array.to_string()=[ 4, 5, null, 7 ] after del_idx(0,1)=0, my_array.to_string()=[ 5, null, 7 ] after del_idx(0,1)=0, my_array.to_string()=[ null, 7 ] after del_idx(0,1)=0, my_array.to_string()=[ 7 ] after del_idx(0,1)=0, my_array.to_string()=[ ] after del_idx(0,1)=-1, my_array.to_string()=[ ] after del_idx(0,7)=0, my_array.to_string()=[ ] after del_idx(0,8)=-1, my_array.to_string()=[ 1, 2, 3, 4, 5, null, 7 ] after del_idx(0,6)=0, my_array.to_string()=[ 7 ] after adding more entries, my_array.to_string()=[ 7, "s1", "s2", "s3" ] my_array= [0]=1 [1]=2 [2]=3 [3]=4 [4]=5 [5]=null [6]=7 my_array.to_string()=[ 1, 2, 3, 4, 5, null, 7 ] put_idx(5,6)=0 put_idx(63,0)=0 put_idx(129,0)=0 put_idx(SIZE_T_MAX,0)=-1 my_array= [0]=3 [1]=1 [2]=2 [3]=null [4]=0 my_array.to_string()=[ 3, 1, 2, null, 0 ] my_array= [0]=null [1]=0 [2]=1 [3]=2 [4]=3 my_array.to_string()=[ null, 0, 1, 2, 3 ] find json_object(1) in my_array successfully: 1 baz_obj.to_string()="fark" my_object= abc: 12 foo: "bar" bool0: false bool1: true my_object.to_string()={ "abc": 12, "foo": "bar", "bool0": false, "bool1": true, "empty_array": [ ], "empty_obj": { } } json-c-json-c-0.17-20230812/tests/test1.test000077500000000000000000000013641446575330000200410ustar00rootroot00000000000000#!/bin/sh # Common definitions if test -z "$srcdir"; then srcdir="${0%/*}" test "$srcdir" = "$0" && srcdir=. test -z "$srcdir" && srcdir=. fi . "$srcdir/test-defs.sh" run_output_test test1 _err=$? for flag in plain spaced pretty ; do run_output_test -o test1Formatted_${flag} test1Formatted ${flag} _err2=$? if [ $_err -eq 0 ] ; then _err=$_err2 fi done # Spaced and pretty JSON string run_output_test -o test1Formatted_spaced_pretty \ test1Formatted spaced pretty _err2=$? if [ $_err -eq 0 ] ; then _err=$_err2 fi # Spaced and pretty JSON string using tabs run_output_test -o test1Formatted_spaced_pretty_pretty_tab \ test1Formatted spaced pretty pretty_tab _err2=$? if [ $_err -eq 0 ] ; then _err=$_err2 fi exit $_err json-c-json-c-0.17-20230812/tests/test1Formatted_plain.expected000066400000000000000000000033601446575330000237070ustar00rootroot00000000000000my_string= my_string.to_string()="\t" my_string=\ my_string.to_string()="\\" my_string=/ my_string.to_string()="\/" my_string.to_string(NOSLASHESCAPE)="/" my_string=/foo/bar/baz my_string.to_string()="\/foo\/bar\/baz" my_string.to_string(NOSLASHESCAPE)="/foo/bar/baz" my_string=foo my_string.to_string()="foo" my_int=9 my_int.to_string()=9 my_null.to_string()=null my_array= [0]=1 [1]=2 [2]=3 [3]=null [4]=5 my_array.to_string()=[1,2,3,null,5] my_array= [0]=1 [1]=2 [2]=3 [3]=4 [4]=5 [5]=null [6]=7 my_array.to_string()=[1,2,3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[2,3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[5,null,7] after del_idx(0,1)=0, my_array.to_string()=[null,7] after del_idx(0,1)=0, my_array.to_string()=[7] after del_idx(0,1)=0, my_array.to_string()=[] after del_idx(0,1)=-1, my_array.to_string()=[] after del_idx(0,7)=0, my_array.to_string()=[] after del_idx(0,8)=-1, my_array.to_string()=[1,2,3,4,5,null,7] after del_idx(0,6)=0, my_array.to_string()=[7] after adding more entries, my_array.to_string()=[7,"s1","s2","s3"] my_array= [0]=1 [1]=2 [2]=3 [3]=4 [4]=5 [5]=null [6]=7 my_array.to_string()=[1,2,3,4,5,null,7] put_idx(5,6)=0 put_idx(63,0)=0 put_idx(129,0)=0 put_idx(SIZE_T_MAX,0)=-1 my_array= [0]=3 [1]=1 [2]=2 [3]=null [4]=0 my_array.to_string()=[3,1,2,null,0] my_array= [0]=null [1]=0 [2]=1 [3]=2 [4]=3 my_array.to_string()=[null,0,1,2,3] find json_object(1) in my_array successfully: 1 baz_obj.to_string()="fark" my_object= abc: 12 foo: "bar" bool0: false bool1: true my_object.to_string()={"abc":12,"foo":"bar","bool0":false,"bool1":true,"empty_array":[],"empty_obj":{}} json-c-json-c-0.17-20230812/tests/test1Formatted_pretty.expected000066400000000000000000000034631446575330000241370ustar00rootroot00000000000000my_string= my_string.to_string()="\t" my_string=\ my_string.to_string()="\\" my_string=/ my_string.to_string()="\/" my_string.to_string(NOSLASHESCAPE)="/" my_string=/foo/bar/baz my_string.to_string()="\/foo\/bar\/baz" my_string.to_string(NOSLASHESCAPE)="/foo/bar/baz" my_string=foo my_string.to_string()="foo" my_int=9 my_int.to_string()=9 my_null.to_string()=null my_array= [0]=1 [1]=2 [2]=3 [3]=null [4]=5 my_array.to_string()=[ 1, 2, 3, null, 5 ] my_array= [0]=1 [1]=2 [2]=3 [3]=4 [4]=5 [5]=null [6]=7 my_array.to_string()=[1,2,3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[2,3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[5,null,7] after del_idx(0,1)=0, my_array.to_string()=[null,7] after del_idx(0,1)=0, my_array.to_string()=[7] after del_idx(0,1)=0, my_array.to_string()=[] after del_idx(0,1)=-1, my_array.to_string()=[] after del_idx(0,7)=0, my_array.to_string()=[] after del_idx(0,8)=-1, my_array.to_string()=[1,2,3,4,5,null,7] after del_idx(0,6)=0, my_array.to_string()=[7] after adding more entries, my_array.to_string()=[7,"s1","s2","s3"] my_array= [0]=1 [1]=2 [2]=3 [3]=4 [4]=5 [5]=null [6]=7 my_array.to_string()=[1,2,3,4,5,null,7] put_idx(5,6)=0 put_idx(63,0)=0 put_idx(129,0)=0 put_idx(SIZE_T_MAX,0)=-1 my_array= [0]=3 [1]=1 [2]=2 [3]=null [4]=0 my_array.to_string()=[ 3, 1, 2, null, 0 ] my_array= [0]=null [1]=0 [2]=1 [3]=2 [4]=3 my_array.to_string()=[ null, 0, 1, 2, 3 ] find json_object(1) in my_array successfully: 1 baz_obj.to_string()="fark" my_object= abc: 12 foo: "bar" bool0: false bool1: true my_object.to_string()={ "abc":12, "foo":"bar", "bool0":false, "bool1":true, "empty_array":[], "empty_obj":{} } json-c-json-c-0.17-20230812/tests/test1Formatted_spaced.expected000066400000000000000000000034211446575330000240410ustar00rootroot00000000000000my_string= my_string.to_string()="\t" my_string=\ my_string.to_string()="\\" my_string=/ my_string.to_string()="\/" my_string.to_string(NOSLASHESCAPE)="/" my_string=/foo/bar/baz my_string.to_string()="\/foo\/bar\/baz" my_string.to_string(NOSLASHESCAPE)="/foo/bar/baz" my_string=foo my_string.to_string()="foo" my_int=9 my_int.to_string()=9 my_null.to_string()=null my_array= [0]=1 [1]=2 [2]=3 [3]=null [4]=5 my_array.to_string()=[ 1, 2, 3, null, 5 ] my_array= [0]=1 [1]=2 [2]=3 [3]=4 [4]=5 [5]=null [6]=7 my_array.to_string()=[1,2,3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[2,3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[5,null,7] after del_idx(0,1)=0, my_array.to_string()=[null,7] after del_idx(0,1)=0, my_array.to_string()=[7] after del_idx(0,1)=0, my_array.to_string()=[] after del_idx(0,1)=-1, my_array.to_string()=[] after del_idx(0,7)=0, my_array.to_string()=[] after del_idx(0,8)=-1, my_array.to_string()=[1,2,3,4,5,null,7] after del_idx(0,6)=0, my_array.to_string()=[7] after adding more entries, my_array.to_string()=[7,"s1","s2","s3"] my_array= [0]=1 [1]=2 [2]=3 [3]=4 [4]=5 [5]=null [6]=7 my_array.to_string()=[1,2,3,4,5,null,7] put_idx(5,6)=0 put_idx(63,0)=0 put_idx(129,0)=0 put_idx(SIZE_T_MAX,0)=-1 my_array= [0]=3 [1]=1 [2]=2 [3]=null [4]=0 my_array.to_string()=[ 3, 1, 2, null, 0 ] my_array= [0]=null [1]=0 [2]=1 [3]=2 [4]=3 my_array.to_string()=[ null, 0, 1, 2, 3 ] find json_object(1) in my_array successfully: 1 baz_obj.to_string()="fark" my_object= abc: 12 foo: "bar" bool0: false bool1: true my_object.to_string()={ "abc": 12, "foo": "bar", "bool0": false, "bool1": true, "empty_array": [ ], "empty_obj": { } } json-c-json-c-0.17-20230812/tests/test1Formatted_spaced_pretty.expected000066400000000000000000000034711446575330000254550ustar00rootroot00000000000000my_string= my_string.to_string()="\t" my_string=\ my_string.to_string()="\\" my_string=/ my_string.to_string()="\/" my_string.to_string(NOSLASHESCAPE)="/" my_string=/foo/bar/baz my_string.to_string()="\/foo\/bar\/baz" my_string.to_string(NOSLASHESCAPE)="/foo/bar/baz" my_string=foo my_string.to_string()="foo" my_int=9 my_int.to_string()=9 my_null.to_string()=null my_array= [0]=1 [1]=2 [2]=3 [3]=null [4]=5 my_array.to_string()=[ 1, 2, 3, null, 5 ] my_array= [0]=1 [1]=2 [2]=3 [3]=4 [4]=5 [5]=null [6]=7 my_array.to_string()=[1,2,3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[2,3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[5,null,7] after del_idx(0,1)=0, my_array.to_string()=[null,7] after del_idx(0,1)=0, my_array.to_string()=[7] after del_idx(0,1)=0, my_array.to_string()=[] after del_idx(0,1)=-1, my_array.to_string()=[] after del_idx(0,7)=0, my_array.to_string()=[] after del_idx(0,8)=-1, my_array.to_string()=[1,2,3,4,5,null,7] after del_idx(0,6)=0, my_array.to_string()=[7] after adding more entries, my_array.to_string()=[7,"s1","s2","s3"] my_array= [0]=1 [1]=2 [2]=3 [3]=4 [4]=5 [5]=null [6]=7 my_array.to_string()=[1,2,3,4,5,null,7] put_idx(5,6)=0 put_idx(63,0)=0 put_idx(129,0)=0 put_idx(SIZE_T_MAX,0)=-1 my_array= [0]=3 [1]=1 [2]=2 [3]=null [4]=0 my_array.to_string()=[ 3, 1, 2, null, 0 ] my_array= [0]=null [1]=0 [2]=1 [3]=2 [4]=3 my_array.to_string()=[ null, 0, 1, 2, 3 ] find json_object(1) in my_array successfully: 1 baz_obj.to_string()="fark" my_object= abc: 12 foo: "bar" bool0: false bool1: true my_object.to_string()={ "abc": 12, "foo": "bar", "bool0": false, "bool1": true, "empty_array": [], "empty_obj": {} } json-c-json-c-0.17-20230812/tests/test1Formatted_spaced_pretty_pretty_tab.expected000066400000000000000000000034441446575330000277120ustar00rootroot00000000000000my_string= my_string.to_string()="\t" my_string=\ my_string.to_string()="\\" my_string=/ my_string.to_string()="\/" my_string.to_string(NOSLASHESCAPE)="/" my_string=/foo/bar/baz my_string.to_string()="\/foo\/bar\/baz" my_string.to_string(NOSLASHESCAPE)="/foo/bar/baz" my_string=foo my_string.to_string()="foo" my_int=9 my_int.to_string()=9 my_null.to_string()=null my_array= [0]=1 [1]=2 [2]=3 [3]=null [4]=5 my_array.to_string()=[ 1, 2, 3, null, 5 ] my_array= [0]=1 [1]=2 [2]=3 [3]=4 [4]=5 [5]=null [6]=7 my_array.to_string()=[1,2,3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[2,3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[3,4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[4,5,null,7] after del_idx(0,1)=0, my_array.to_string()=[5,null,7] after del_idx(0,1)=0, my_array.to_string()=[null,7] after del_idx(0,1)=0, my_array.to_string()=[7] after del_idx(0,1)=0, my_array.to_string()=[] after del_idx(0,1)=-1, my_array.to_string()=[] after del_idx(0,7)=0, my_array.to_string()=[] after del_idx(0,8)=-1, my_array.to_string()=[1,2,3,4,5,null,7] after del_idx(0,6)=0, my_array.to_string()=[7] after adding more entries, my_array.to_string()=[7,"s1","s2","s3"] my_array= [0]=1 [1]=2 [2]=3 [3]=4 [4]=5 [5]=null [6]=7 my_array.to_string()=[1,2,3,4,5,null,7] put_idx(5,6)=0 put_idx(63,0)=0 put_idx(129,0)=0 put_idx(SIZE_T_MAX,0)=-1 my_array= [0]=3 [1]=1 [2]=2 [3]=null [4]=0 my_array.to_string()=[ 3, 1, 2, null, 0 ] my_array= [0]=null [1]=0 [2]=1 [3]=2 [4]=3 my_array.to_string()=[ null, 0, 1, 2, 3 ] find json_object(1) in my_array successfully: 1 baz_obj.to_string()="fark" my_object= abc: 12 foo: "bar" bool0: false bool1: true my_object.to_string()={ "abc": 12, "foo": "bar", "bool0": false, "bool1": true, "empty_array": [], "empty_obj": {} } json-c-json-c-0.17-20230812/tests/test2.c000066400000000000000000000021551446575330000173010ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include #include "json.h" #include "parse_flags.h" #ifdef TEST_FORMATTED #define json_object_to_json_string(obj) json_object_to_json_string_ext(obj, sflags) #else /* no special define */ #endif int main(int argc, char **argv) { json_object *new_obj; #ifdef TEST_FORMATTED int sflags = 0; #endif MC_SET_DEBUG(1); #ifdef TEST_FORMATTED sflags = parse_flags(argc, argv); #endif new_obj = json_tokener_parse( "/* more difficult test case */" "{ \"glossary\": { \"title\": \"example glossary\", \"GlossDiv\": { \"title\": \"S\", " "\"GlossList\": [ { \"ID\": \"SGML\", \"SortAs\": \"SGML\", \"GlossTerm\": \"Standard " "Generalized Markup Language\", \"Acronym\": \"SGML\", \"Abbrev\": \"ISO 8879:1986\", " "\"GlossDef\": \"A meta-markup language, used to create markup languages such as " "DocBook.\", \"GlossSeeAlso\": [\"GML\", \"XML\", \"markup\"] } ] } } }"); printf("new_obj.to_string()=%s\n", json_object_to_json_string(new_obj)); json_object_put(new_obj); return EXIT_SUCCESS; } json-c-json-c-0.17-20230812/tests/test2.expected000066400000000000000000000005761446575330000206650ustar00rootroot00000000000000new_obj.to_string()={ "glossary": { "title": "example glossary", "GlossDiv": { "title": "S", "GlossList": [ { "ID": "SGML", "SortAs": "SGML", "GlossTerm": "Standard Generalized Markup Language", "Acronym": "SGML", "Abbrev": "ISO 8879:1986", "GlossDef": "A meta-markup language, used to create markup languages such as DocBook.", "GlossSeeAlso": [ "GML", "XML", "markup" ] } ] } } } json-c-json-c-0.17-20230812/tests/test2.test000077500000000000000000000013641446575330000200420ustar00rootroot00000000000000#!/bin/sh # Common definitions if test -z "$srcdir"; then srcdir="${0%/*}" test "$srcdir" = "$0" && srcdir=. test -z "$srcdir" && srcdir=. fi . "$srcdir/test-defs.sh" run_output_test test2 _err=$? for flag in plain spaced pretty ; do run_output_test -o test2Formatted_${flag} test2Formatted ${flag} _err2=$? if [ $_err -eq 0 ] ; then _err=$_err2 fi done # Spaced and pretty JSON string run_output_test -o test2Formatted_spaced_pretty \ test2Formatted spaced pretty _err2=$? if [ $_err -eq 0 ] ; then _err=$_err2 fi # Spaced and pretty JSON string using tabs run_output_test -o test2Formatted_spaced_pretty_pretty_tab \ test2Formatted spaced pretty pretty_tab _err2=$? if [ $_err -eq 0 ] ; then _err=$_err2 fi exit $_err json-c-json-c-0.17-20230812/tests/test2Formatted_plain.expected000066400000000000000000000005341446575330000237100ustar00rootroot00000000000000new_obj.to_string()={"glossary":{"title":"example glossary","GlossDiv":{"title":"S","GlossList":[{"ID":"SGML","SortAs":"SGML","GlossTerm":"Standard Generalized Markup Language","Acronym":"SGML","Abbrev":"ISO 8879:1986","GlossDef":"A meta-markup language, used to create markup languages such as DocBook.","GlossSeeAlso":["GML","XML","markup"]}]}}} json-c-json-c-0.17-20230812/tests/test2Formatted_pretty.expected000066400000000000000000000010301446575330000241240ustar00rootroot00000000000000new_obj.to_string()={ "glossary":{ "title":"example glossary", "GlossDiv":{ "title":"S", "GlossList":[ { "ID":"SGML", "SortAs":"SGML", "GlossTerm":"Standard Generalized Markup Language", "Acronym":"SGML", "Abbrev":"ISO 8879:1986", "GlossDef":"A meta-markup language, used to create markup languages such as DocBook.", "GlossSeeAlso":[ "GML", "XML", "markup" ] } ] } } } json-c-json-c-0.17-20230812/tests/test2Formatted_spaced.expected000066400000000000000000000005761446575330000240520ustar00rootroot00000000000000new_obj.to_string()={ "glossary": { "title": "example glossary", "GlossDiv": { "title": "S", "GlossList": [ { "ID": "SGML", "SortAs": "SGML", "GlossTerm": "Standard Generalized Markup Language", "Acronym": "SGML", "Abbrev": "ISO 8879:1986", "GlossDef": "A meta-markup language, used to create markup languages such as DocBook.", "GlossSeeAlso": [ "GML", "XML", "markup" ] } ] } } } json-c-json-c-0.17-20230812/tests/test2Formatted_spaced_pretty.expected000066400000000000000000000010441446575330000254500ustar00rootroot00000000000000new_obj.to_string()={ "glossary": { "title": "example glossary", "GlossDiv": { "title": "S", "GlossList": [ { "ID": "SGML", "SortAs": "SGML", "GlossTerm": "Standard Generalized Markup Language", "Acronym": "SGML", "Abbrev": "ISO 8879:1986", "GlossDef": "A meta-markup language, used to create markup languages such as DocBook.", "GlossSeeAlso": [ "GML", "XML", "markup" ] } ] } } } json-c-json-c-0.17-20230812/tests/test2Formatted_spaced_pretty_pretty_tab.expected000066400000000000000000000007211446575330000277060ustar00rootroot00000000000000new_obj.to_string()={ "glossary": { "title": "example glossary", "GlossDiv": { "title": "S", "GlossList": [ { "ID": "SGML", "SortAs": "SGML", "GlossTerm": "Standard Generalized Markup Language", "Acronym": "SGML", "Abbrev": "ISO 8879:1986", "GlossDef": "A meta-markup language, used to create markup languages such as DocBook.", "GlossSeeAlso": [ "GML", "XML", "markup" ] } ] } } } json-c-json-c-0.17-20230812/tests/test4.c000066400000000000000000000035311446575330000173020ustar00rootroot00000000000000/* * gcc -o utf8 utf8.c -I/home/y/include -L./.libs -ljson */ #ifdef NDEBUG #undef NDEBUG #endif #include "config.h" #include #include #include #include #include "json_inttypes.h" #include "json_object.h" #include "json_tokener.h" #include "snprintf_compat.h" void print_hex(const char *s) { const char *iter = s; unsigned char ch; while ((ch = *iter++) != 0) { if (',' != ch) printf("%x ", ch); else printf(","); } putchar('\n'); } static void test_lot_of_adds(void); static void test_lot_of_adds(void) { int ii; char key[50]; json_object *jobj = json_object_new_object(); assert(jobj != NULL); for (ii = 0; ii < 500; ii++) { snprintf(key, sizeof(key), "k%d", ii); json_object *iobj = json_object_new_int(ii); assert(iobj != NULL); if (json_object_object_add(jobj, key, iobj)) { fprintf(stderr, "FAILED to add object #%d\n", ii); abort(); } } printf("%s\n", json_object_to_json_string(jobj)); assert(json_object_object_length(jobj) == 500); json_object_put(jobj); } int main(void) { const char *input = "\"\\ud840\\udd26,\\ud840\\udd27,\\ud800\\udd26,\\ud800\\udd27\""; const char *expected = "\xF0\xA0\x84\xA6,\xF0\xA0\x84\xA7,\xF0\x90\x84\xA6,\xF0\x90\x84\xA7"; struct json_object *parse_result = json_tokener_parse(input); const char *unjson = json_object_get_string(parse_result); printf("input: %s\n", input); int strings_match = !strcmp(expected, unjson); int retval = 0; if (strings_match) { printf("JSON parse result is correct: %s\n", unjson); puts("PASS"); } else { printf("JSON parse result doesn't match expected string\n"); printf("expected string bytes: "); print_hex(expected); printf("parsed string bytes: "); print_hex(unjson); puts("FAIL"); retval = 1; } json_object_put(parse_result); test_lot_of_adds(); return retval; } json-c-json-c-0.17-20230812/tests/test4.expected000066400000000000000000000143771446575330000206730ustar00rootroot00000000000000input: "\ud840\udd26,\ud840\udd27,\ud800\udd26,\ud800\udd27" JSON parse result is correct: 𠄦,𠄧,𐄦,𐄧 PASS { "k0": 0, "k1": 1, "k2": 2, "k3": 3, "k4": 4, "k5": 5, "k6": 6, "k7": 7, "k8": 8, "k9": 9, "k10": 10, "k11": 11, "k12": 12, "k13": 13, "k14": 14, "k15": 15, "k16": 16, "k17": 17, "k18": 18, "k19": 19, "k20": 20, "k21": 21, "k22": 22, "k23": 23, "k24": 24, "k25": 25, "k26": 26, "k27": 27, "k28": 28, "k29": 29, "k30": 30, "k31": 31, "k32": 32, "k33": 33, "k34": 34, "k35": 35, "k36": 36, "k37": 37, "k38": 38, "k39": 39, "k40": 40, "k41": 41, "k42": 42, "k43": 43, "k44": 44, "k45": 45, "k46": 46, "k47": 47, "k48": 48, "k49": 49, "k50": 50, "k51": 51, "k52": 52, "k53": 53, "k54": 54, "k55": 55, "k56": 56, "k57": 57, "k58": 58, "k59": 59, "k60": 60, "k61": 61, "k62": 62, "k63": 63, "k64": 64, "k65": 65, "k66": 66, "k67": 67, "k68": 68, "k69": 69, "k70": 70, "k71": 71, "k72": 72, "k73": 73, "k74": 74, "k75": 75, "k76": 76, "k77": 77, "k78": 78, "k79": 79, "k80": 80, "k81": 81, "k82": 82, "k83": 83, "k84": 84, "k85": 85, "k86": 86, "k87": 87, "k88": 88, "k89": 89, "k90": 90, "k91": 91, "k92": 92, "k93": 93, "k94": 94, "k95": 95, "k96": 96, "k97": 97, "k98": 98, "k99": 99, "k100": 100, "k101": 101, "k102": 102, "k103": 103, "k104": 104, "k105": 105, "k106": 106, "k107": 107, "k108": 108, "k109": 109, "k110": 110, "k111": 111, "k112": 112, "k113": 113, "k114": 114, "k115": 115, "k116": 116, "k117": 117, "k118": 118, "k119": 119, "k120": 120, "k121": 121, "k122": 122, "k123": 123, "k124": 124, "k125": 125, "k126": 126, "k127": 127, "k128": 128, "k129": 129, "k130": 130, "k131": 131, "k132": 132, "k133": 133, "k134": 134, "k135": 135, "k136": 136, "k137": 137, "k138": 138, "k139": 139, "k140": 140, "k141": 141, "k142": 142, "k143": 143, "k144": 144, "k145": 145, "k146": 146, "k147": 147, "k148": 148, "k149": 149, "k150": 150, "k151": 151, "k152": 152, "k153": 153, "k154": 154, "k155": 155, "k156": 156, "k157": 157, "k158": 158, "k159": 159, "k160": 160, "k161": 161, "k162": 162, "k163": 163, "k164": 164, "k165": 165, "k166": 166, "k167": 167, "k168": 168, "k169": 169, "k170": 170, "k171": 171, "k172": 172, "k173": 173, "k174": 174, "k175": 175, "k176": 176, "k177": 177, "k178": 178, "k179": 179, "k180": 180, "k181": 181, "k182": 182, "k183": 183, "k184": 184, "k185": 185, "k186": 186, "k187": 187, "k188": 188, "k189": 189, "k190": 190, "k191": 191, "k192": 192, "k193": 193, "k194": 194, "k195": 195, "k196": 196, "k197": 197, "k198": 198, "k199": 199, "k200": 200, "k201": 201, "k202": 202, "k203": 203, "k204": 204, "k205": 205, "k206": 206, "k207": 207, "k208": 208, "k209": 209, "k210": 210, "k211": 211, "k212": 212, "k213": 213, "k214": 214, "k215": 215, "k216": 216, "k217": 217, "k218": 218, "k219": 219, "k220": 220, "k221": 221, "k222": 222, "k223": 223, "k224": 224, "k225": 225, "k226": 226, "k227": 227, "k228": 228, "k229": 229, "k230": 230, "k231": 231, "k232": 232, "k233": 233, "k234": 234, "k235": 235, "k236": 236, "k237": 237, "k238": 238, "k239": 239, "k240": 240, "k241": 241, "k242": 242, "k243": 243, "k244": 244, "k245": 245, "k246": 246, "k247": 247, "k248": 248, "k249": 249, "k250": 250, "k251": 251, "k252": 252, "k253": 253, "k254": 254, "k255": 255, "k256": 256, "k257": 257, "k258": 258, "k259": 259, "k260": 260, "k261": 261, "k262": 262, "k263": 263, "k264": 264, "k265": 265, "k266": 266, "k267": 267, "k268": 268, "k269": 269, "k270": 270, "k271": 271, "k272": 272, "k273": 273, "k274": 274, "k275": 275, "k276": 276, "k277": 277, "k278": 278, "k279": 279, "k280": 280, "k281": 281, "k282": 282, "k283": 283, "k284": 284, "k285": 285, "k286": 286, "k287": 287, "k288": 288, "k289": 289, "k290": 290, "k291": 291, "k292": 292, "k293": 293, "k294": 294, "k295": 295, "k296": 296, "k297": 297, "k298": 298, "k299": 299, "k300": 300, "k301": 301, "k302": 302, "k303": 303, "k304": 304, "k305": 305, "k306": 306, "k307": 307, "k308": 308, "k309": 309, "k310": 310, "k311": 311, "k312": 312, "k313": 313, "k314": 314, "k315": 315, "k316": 316, "k317": 317, "k318": 318, "k319": 319, "k320": 320, "k321": 321, "k322": 322, "k323": 323, "k324": 324, "k325": 325, "k326": 326, "k327": 327, "k328": 328, "k329": 329, "k330": 330, "k331": 331, "k332": 332, "k333": 333, "k334": 334, "k335": 335, "k336": 336, "k337": 337, "k338": 338, "k339": 339, "k340": 340, "k341": 341, "k342": 342, "k343": 343, "k344": 344, "k345": 345, "k346": 346, "k347": 347, "k348": 348, "k349": 349, "k350": 350, "k351": 351, "k352": 352, "k353": 353, "k354": 354, "k355": 355, "k356": 356, "k357": 357, "k358": 358, "k359": 359, "k360": 360, "k361": 361, "k362": 362, "k363": 363, "k364": 364, "k365": 365, "k366": 366, "k367": 367, "k368": 368, "k369": 369, "k370": 370, "k371": 371, "k372": 372, "k373": 373, "k374": 374, "k375": 375, "k376": 376, "k377": 377, "k378": 378, "k379": 379, "k380": 380, "k381": 381, "k382": 382, "k383": 383, "k384": 384, "k385": 385, "k386": 386, "k387": 387, "k388": 388, "k389": 389, "k390": 390, "k391": 391, "k392": 392, "k393": 393, "k394": 394, "k395": 395, "k396": 396, "k397": 397, "k398": 398, "k399": 399, "k400": 400, "k401": 401, "k402": 402, "k403": 403, "k404": 404, "k405": 405, "k406": 406, "k407": 407, "k408": 408, "k409": 409, "k410": 410, "k411": 411, "k412": 412, "k413": 413, "k414": 414, "k415": 415, "k416": 416, "k417": 417, "k418": 418, "k419": 419, "k420": 420, "k421": 421, "k422": 422, "k423": 423, "k424": 424, "k425": 425, "k426": 426, "k427": 427, "k428": 428, "k429": 429, "k430": 430, "k431": 431, "k432": 432, "k433": 433, "k434": 434, "k435": 435, "k436": 436, "k437": 437, "k438": 438, "k439": 439, "k440": 440, "k441": 441, "k442": 442, "k443": 443, "k444": 444, "k445": 445, "k446": 446, "k447": 447, "k448": 448, "k449": 449, "k450": 450, "k451": 451, "k452": 452, "k453": 453, "k454": 454, "k455": 455, "k456": 456, "k457": 457, "k458": 458, "k459": 459, "k460": 460, "k461": 461, "k462": 462, "k463": 463, "k464": 464, "k465": 465, "k466": 466, "k467": 467, "k468": 468, "k469": 469, "k470": 470, "k471": 471, "k472": 472, "k473": 473, "k474": 474, "k475": 475, "k476": 476, "k477": 477, "k478": 478, "k479": 479, "k480": 480, "k481": 481, "k482": 482, "k483": 483, "k484": 484, "k485": 485, "k486": 486, "k487": 487, "k488": 488, "k489": 489, "k490": 490, "k491": 491, "k492": 492, "k493": 493, "k494": 494, "k495": 495, "k496": 496, "k497": 497, "k498": 498, "k499": 499 } json-c-json-c-0.17-20230812/tests/test4.test000077700000000000000000000000001446575330000230512test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/testReplaceExisting.c000066400000000000000000000040661446575330000222310ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include #include "json.h" int main(int argc, char **argv) { MC_SET_DEBUG(1); /* * Check that replacing an existing object keeps the key valid, * and that it keeps the order the same. */ json_object *my_object = json_object_new_object(); json_object_object_add(my_object, "foo1", json_object_new_string("bar1")); json_object_object_add(my_object, "foo2", json_object_new_string("bar2")); json_object_object_add(my_object, "deleteme", json_object_new_string("bar2")); json_object_object_add(my_object, "foo3", json_object_new_string("bar3")); printf("==== delete-in-loop test starting ====\n"); int orig_count = 0; json_object_object_foreach(my_object, key0, val0) { printf("Key at index %d is [%s] %d", orig_count, key0, (val0 == NULL)); if (strcmp(key0, "deleteme") == 0) { json_object_object_del(my_object, key0); printf(" (deleted)\n"); } else printf(" (kept)\n"); orig_count++; } printf("==== replace-value first loop starting ====\n"); const char *original_key = NULL; orig_count = 0; json_object_object_foreach(my_object, key, val) { printf("Key at index %d is [%s] %d\n", orig_count, key, (val == NULL)); orig_count++; if (strcmp(key, "foo2") != 0) continue; printf("replacing value for key [%s]\n", key); original_key = key; json_object_object_add(my_object, key, json_object_new_string("zzz")); } printf("==== second loop starting ====\n"); int new_count = 0; int retval = 0; json_object_object_foreach(my_object, key2, val2) { printf("Key at index %d is [%s] %d\n", new_count, key2, (val2 == NULL)); new_count++; if (strcmp(key2, "foo2") != 0) continue; printf("pointer for key [%s] does %smatch\n", key2, (key2 == original_key) ? "" : "NOT "); if (key2 != original_key) retval = 1; } if (new_count != orig_count) { printf("mismatch between original count (%d) and new count (%d)\n", orig_count, new_count); retval = 1; } json_object_put(my_object); return retval; } json-c-json-c-0.17-20230812/tests/testReplaceExisting.expected000066400000000000000000000007441446575330000236070ustar00rootroot00000000000000==== delete-in-loop test starting ==== Key at index 0 is [foo1] 0 (kept) Key at index 1 is [foo2] 0 (kept) Key at index 2 is [deleteme] 0 (deleted) Key at index 3 is [foo3] 0 (kept) ==== replace-value first loop starting ==== Key at index 0 is [foo1] 0 Key at index 1 is [foo2] 0 replacing value for key [foo2] Key at index 2 is [foo3] 0 ==== second loop starting ==== Key at index 0 is [foo1] 0 Key at index 1 is [foo2] 0 pointer for key [foo2] does match Key at index 2 is [foo3] 0 json-c-json-c-0.17-20230812/tests/testReplaceExisting.test000077700000000000000000000000001446575330000257742test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_basic.test000077500000000000000000000006421446575330000211170ustar00rootroot00000000000000#!/bin/sh export _JSON_C_STRERROR_ENABLE=1 # Common definitions if test -z "$srcdir"; then srcdir="${0%/*}" test "$srcdir" = "$0" && srcdir=. test -z "$srcdir" && srcdir=. fi . "$srcdir/test-defs.sh" filename=$(basename "$0") filename="${filename%.*}" # This is only for the test_util_file.test ; # more stuff could be extended cp -f "$srcdir/valid.json" . run_output_test $filename "$srcdir" exit $? json-c-json-c-0.17-20230812/tests/test_cast.c000066400000000000000000000100641446575330000202270ustar00rootroot00000000000000/* * Tests if casting within the json_object_get_* functions work correctly. * Also checks the json_object_get_type and json_object_is_type functions. */ #ifdef NDEBUG #undef NDEBUG #endif #include "config.h" #include #include #include #include "json_inttypes.h" #include "json_object.h" #include "json_tokener.h" #include "json_util.h" static void getit(struct json_object *new_obj, const char *field); static void checktype_header(void); static void checktype(struct json_object *new_obj, const char *field); int main(int argc, char **argv) { const char *input = "{\n\ \"string_of_digits\": \"123\",\n\ \"regular_number\": 222,\n\ \"decimal_number\": 99.55,\n\ \"boolean_true\": true,\n\ \"boolean_false\": false,\n\ \"int64_number\": 2147483649,\n\ \"negative_number\": -321321321,\n\ \"a_null\": null,\n\ \"empty_array\": [],\n\ \"nonempty_array\": [ 123 ],\n\ \"array_with_zero\": [ 0 ],\n\ \"empty_object\": {},\n\ \"nonempty_object\": { \"a\": 123 },\n\ }"; /* Note: 2147483649 = INT_MAX + 2 */ /* Note: 9223372036854775809 = INT64_MAX + 2 */ /* Note: 18446744073709551617 = UINT64_MAX + 2 */ struct json_object *new_obj; new_obj = json_tokener_parse(input); printf("Parsed input: %s\n", input); printf("Result is %s\n", (new_obj == NULL) ? "NULL (error!)" : "not NULL"); if (!new_obj) return 1; // oops, we failed. getit(new_obj, "string_of_digits"); getit(new_obj, "regular_number"); getit(new_obj, "decimal_number"); getit(new_obj, "boolean_true"); getit(new_obj, "boolean_false"); getit(new_obj, "int64_number"); getit(new_obj, "negative_number"); getit(new_obj, "a_null"); getit(new_obj, "empty_array"); getit(new_obj, "nonempty_array"); getit(new_obj, "array_with_zero"); getit(new_obj, "empty_object"); getit(new_obj, "nonempty_object"); // Now check the behaviour of the json_object_is_type() function. printf("\n================================\n"); checktype_header(); checktype(new_obj, NULL); checktype(new_obj, "string_of_digits"); checktype(new_obj, "regular_number"); checktype(new_obj, "decimal_number"); checktype(new_obj, "boolean_true"); checktype(new_obj, "boolean_false"); checktype(new_obj, "int64_number"); checktype(new_obj, "negative_number"); checktype(new_obj, "a_null"); json_object_put(new_obj); return 0; } static void getit(struct json_object *new_obj, const char *field) { struct json_object *o = NULL; if (!json_object_object_get_ex(new_obj, field, &o)) printf("Field %s does not exist\n", field); enum json_type o_type = json_object_get_type(o); printf("new_obj.%s json_object_get_type()=%s\n", field, json_type_to_name(o_type)); printf("new_obj.%s json_object_get_int()=%d\n", field, json_object_get_int(o)); printf("new_obj.%s json_object_get_int64()=%" PRId64 "\n", field, json_object_get_int64(o)); printf("new_obj.%s json_object_get_uint64()=%" PRIu64 "\n", field, json_object_get_uint64(o)); printf("new_obj.%s json_object_get_boolean()=%d\n", field, json_object_get_boolean(o)); printf("new_obj.%s json_object_get_double()=%f\n", field, json_object_get_double(o)); } static void checktype_header(void) { printf("json_object_is_type: %s,%s,%s,%s,%s,%s,%s\n", json_type_to_name(json_type_null), json_type_to_name(json_type_boolean), json_type_to_name(json_type_double), json_type_to_name(json_type_int), json_type_to_name(json_type_object), json_type_to_name(json_type_array), json_type_to_name(json_type_string)); } static void checktype(struct json_object *new_obj, const char *field) { struct json_object *o = new_obj; if (field && !json_object_object_get_ex(new_obj, field, &o)) printf("Field %s does not exist\n", field); printf("new_obj%s%-18s: %d,%d,%d,%d,%d,%d,%d\n", field ? "." : " ", field ? field : "", json_object_is_type(o, json_type_null), json_object_is_type(o, json_type_boolean), json_object_is_type(o, json_type_double), json_object_is_type(o, json_type_int), json_object_is_type(o, json_type_object), json_object_is_type(o, json_type_array), json_object_is_type(o, json_type_string)); } json-c-json-c-0.17-20230812/tests/test_cast.expected000066400000000000000000000113561446575330000216130ustar00rootroot00000000000000Parsed input: { "string_of_digits": "123", "regular_number": 222, "decimal_number": 99.55, "boolean_true": true, "boolean_false": false, "int64_number": 2147483649, "negative_number": -321321321, "a_null": null, "empty_array": [], "nonempty_array": [ 123 ], "array_with_zero": [ 0 ], "empty_object": {}, "nonempty_object": { "a": 123 }, } Result is not NULL new_obj.string_of_digits json_object_get_type()=string new_obj.string_of_digits json_object_get_int()=123 new_obj.string_of_digits json_object_get_int64()=123 new_obj.string_of_digits json_object_get_uint64()=123 new_obj.string_of_digits json_object_get_boolean()=1 new_obj.string_of_digits json_object_get_double()=123.000000 new_obj.regular_number json_object_get_type()=int new_obj.regular_number json_object_get_int()=222 new_obj.regular_number json_object_get_int64()=222 new_obj.regular_number json_object_get_uint64()=222 new_obj.regular_number json_object_get_boolean()=1 new_obj.regular_number json_object_get_double()=222.000000 new_obj.decimal_number json_object_get_type()=double new_obj.decimal_number json_object_get_int()=99 new_obj.decimal_number json_object_get_int64()=99 new_obj.decimal_number json_object_get_uint64()=99 new_obj.decimal_number json_object_get_boolean()=1 new_obj.decimal_number json_object_get_double()=99.550000 new_obj.boolean_true json_object_get_type()=boolean new_obj.boolean_true json_object_get_int()=1 new_obj.boolean_true json_object_get_int64()=1 new_obj.boolean_true json_object_get_uint64()=1 new_obj.boolean_true json_object_get_boolean()=1 new_obj.boolean_true json_object_get_double()=1.000000 new_obj.boolean_false json_object_get_type()=boolean new_obj.boolean_false json_object_get_int()=0 new_obj.boolean_false json_object_get_int64()=0 new_obj.boolean_false json_object_get_uint64()=0 new_obj.boolean_false json_object_get_boolean()=0 new_obj.boolean_false json_object_get_double()=0.000000 new_obj.int64_number json_object_get_type()=int new_obj.int64_number json_object_get_int()=2147483647 new_obj.int64_number json_object_get_int64()=2147483649 new_obj.int64_number json_object_get_uint64()=2147483649 new_obj.int64_number json_object_get_boolean()=1 new_obj.int64_number json_object_get_double()=2147483649.000000 new_obj.negative_number json_object_get_type()=int new_obj.negative_number json_object_get_int()=-321321321 new_obj.negative_number json_object_get_int64()=-321321321 new_obj.negative_number json_object_get_uint64()=0 new_obj.negative_number json_object_get_boolean()=1 new_obj.negative_number json_object_get_double()=-321321321.000000 new_obj.a_null json_object_get_type()=null new_obj.a_null json_object_get_int()=0 new_obj.a_null json_object_get_int64()=0 new_obj.a_null json_object_get_uint64()=0 new_obj.a_null json_object_get_boolean()=0 new_obj.a_null json_object_get_double()=0.000000 new_obj.empty_array json_object_get_type()=array new_obj.empty_array json_object_get_int()=0 new_obj.empty_array json_object_get_int64()=0 new_obj.empty_array json_object_get_uint64()=0 new_obj.empty_array json_object_get_boolean()=0 new_obj.empty_array json_object_get_double()=0.000000 new_obj.nonempty_array json_object_get_type()=array new_obj.nonempty_array json_object_get_int()=0 new_obj.nonempty_array json_object_get_int64()=0 new_obj.nonempty_array json_object_get_uint64()=0 new_obj.nonempty_array json_object_get_boolean()=0 new_obj.nonempty_array json_object_get_double()=0.000000 new_obj.array_with_zero json_object_get_type()=array new_obj.array_with_zero json_object_get_int()=0 new_obj.array_with_zero json_object_get_int64()=0 new_obj.array_with_zero json_object_get_uint64()=0 new_obj.array_with_zero json_object_get_boolean()=0 new_obj.array_with_zero json_object_get_double()=0.000000 new_obj.empty_object json_object_get_type()=object new_obj.empty_object json_object_get_int()=0 new_obj.empty_object json_object_get_int64()=0 new_obj.empty_object json_object_get_uint64()=0 new_obj.empty_object json_object_get_boolean()=0 new_obj.empty_object json_object_get_double()=0.000000 new_obj.nonempty_object json_object_get_type()=object new_obj.nonempty_object json_object_get_int()=0 new_obj.nonempty_object json_object_get_int64()=0 new_obj.nonempty_object json_object_get_uint64()=0 new_obj.nonempty_object json_object_get_boolean()=0 new_obj.nonempty_object json_object_get_double()=0.000000 ================================ json_object_is_type: null,boolean,double,int,object,array,string new_obj : 0,0,0,0,1,0,0 new_obj.string_of_digits : 0,0,0,0,0,0,1 new_obj.regular_number : 0,0,0,1,0,0,0 new_obj.decimal_number : 0,0,1,0,0,0,0 new_obj.boolean_true : 0,1,0,0,0,0,0 new_obj.boolean_false : 0,1,0,0,0,0,0 new_obj.int64_number : 0,0,0,1,0,0,0 new_obj.negative_number : 0,0,0,1,0,0,0 new_obj.a_null : 1,0,0,0,0,0,0 json-c-json-c-0.17-20230812/tests/test_cast.test000077700000000000000000000000001446575330000237772test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_charcase.c000066400000000000000000000014521446575330000210470ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include #include #include "json.h" #include "json_tokener.h" static void test_case_parse(void); int main(int argc, char **argv) { MC_SET_DEBUG(1); test_case_parse(); return 0; } /* make sure only lowercase forms are parsed in strict mode */ static void test_case_parse(void) { struct json_tokener *tok; json_object *new_obj; tok = json_tokener_new(); json_tokener_set_flags(tok, JSON_TOKENER_STRICT); new_obj = json_tokener_parse_ex(tok, "True", 4); assert(new_obj == NULL); new_obj = json_tokener_parse_ex(tok, "False", 5); assert(new_obj == NULL); new_obj = json_tokener_parse_ex(tok, "Null", 4); assert(new_obj == NULL); printf("OK\n"); json_tokener_free(tok); } json-c-json-c-0.17-20230812/tests/test_charcase.expected000066400000000000000000000000031446575330000224150ustar00rootroot00000000000000OK json-c-json-c-0.17-20230812/tests/test_charcase.test000077700000000000000000000000001446575330000246162test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_compare.c000066400000000000000000000206171446575330000207300ustar00rootroot00000000000000/* * Tests if json_object_equal behaves correct. */ #ifdef NDEBUG #undef NDEBUG #endif #include "config.h" #include #include #include "json_inttypes.h" #include "json_object.h" int main(int argc, char **argv) { /* integer tests */ struct json_object *int1 = json_object_new_int(0); struct json_object *int2 = json_object_new_int(1); struct json_object *int3 = json_object_new_int(1); struct json_object *int4 = json_object_new_int(-1); struct json_object *uint1 = json_object_new_uint64(0); struct json_object *uint2 = json_object_new_uint64(1); struct json_object *uint3 = json_object_new_uint64(1); struct json_object *uint4 = json_object_new_uint64((uint64_t)INT64_MAX + 100); if (!json_object_equal(int1, int2)) printf("JSON integer comparison is correct\n"); else printf("JSON integer comparison failed\n"); if (json_object_equal(int1, int1)) printf("JSON same object comparison is correct\n"); else printf("JSON same object comparison failed\n"); if (json_object_equal(int2, int3)) printf("JSON same integer comparison is correct\n"); else printf("JSON same integer comparison failed\n"); if (!json_object_equal(uint1, uint2)) printf("JSON usigned integer comparison is correct\n"); else printf("JSON usigned integer comparison failed\n"); if (json_object_equal(uint1, uint1)) printf("JSON same usigned object comparison is correct\n"); else printf("JSON same usigned object comparison failed\n"); if (json_object_equal(uint2, uint3)) printf("JSON same usigned integer comparison is correct\n"); else printf("JSON same usigned integer comparison failed\n"); if (json_object_equal(int2, uint2)) printf("JSON integer & usigned integer comparison is correct\n"); else printf("JSON integer & usigned integer comparison failed\n"); if (!json_object_equal(int2, uint4)) printf("JSON integer & usigned integer comparison is correct\n"); else printf("JSON integer & usigned integer comparison failed\n"); if (!json_object_equal(int4, uint2)) printf("JSON integer & usigned integer comparison is correct\n"); else printf("JSON integer & usigned integer comparison failed\n"); if (!json_object_equal(int4, uint4)) printf("JSON integer & usigned integer comparison is correct\n"); else printf("JSON integer & usigned integer comparison failed\n"); if (json_object_equal(uint2, int2)) printf("JSON usigned integer & integer comparison is correct\n"); else printf("JSON usigned integer & integer comparison failed\n"); if (!json_object_equal(uint2, int4)) printf("JSON usigned integer & integer comparison is correct\n"); else printf("JSON usigned integer & integer comparison failed\n"); if (!json_object_equal(uint4, int2)) printf("JSON usigned integer & integer comparison is correct\n"); else printf("JSON usigned integer & integer comparison failed\n"); if (!json_object_equal(uint4, int4)) printf("JSON usigned integer & integer comparison is correct\n"); else printf("JSON usigned integer & integer comparison failed\n"); json_object_put(int1); json_object_put(int2); json_object_put(int3); json_object_put(int4); json_object_put(uint1); json_object_put(uint2); json_object_put(uint3); json_object_put(uint4); /* string tests */ struct json_object *str1 = json_object_new_string("TESTSTRING"); struct json_object *str2 = json_object_new_string("TESTSTRING"); struct json_object *str3 = json_object_new_string("DIFFERENT"); if (json_object_equal(str1, str2)) printf("Comparing equal strings is correct\n"); else printf("Comparing equal strings failed\n"); if (!json_object_equal(str1, str3)) printf("Comparing different strings is correct\n"); else printf("Comparing different strings failed\n"); json_object_put(str1); json_object_put(str2); json_object_put(str3); /* double tests */ struct json_object *dbl1 = json_object_new_double(3.14159); struct json_object *dbl2 = json_object_new_double(3.14159); struct json_object *dbl3 = json_object_new_double(3.0); if (json_object_equal(dbl1, dbl2)) printf("Comparing equal doubles is correct\n"); else printf("Comparing equal doubles failed\n"); if (!json_object_equal(dbl1, dbl3)) printf("Comparing different doubles is correct\n"); else printf("Comparing different doubles failed\n"); json_object_put(dbl1); json_object_put(dbl2); json_object_put(dbl3); /* array tests */ struct json_object *ar1 = json_object_new_array(); struct json_object *ar2 = json_object_new_array(); struct json_object *ar3 = json_object_new_array(); struct json_object *ar4 = json_object_new_array(); json_object_array_add(ar1, json_object_new_int(1)); json_object_array_add(ar1, json_object_new_int(2)); json_object_array_add(ar2, json_object_new_int(1)); json_object_array_add(ar2, json_object_new_int(2)); json_object_array_add(ar3, json_object_new_int(1)); json_object_array_add(ar3, json_object_new_int(1)); if (json_object_equal(ar1, ar2)) printf("Comparing equal arrays is correct\n"); else printf("Comparing equal arrays failed\n"); json_object_array_add(ar2, json_object_new_int(1)); if (!json_object_equal(ar1, ar2)) printf("Comparing arrays of different len is correct\n"); else printf("Comparing arrays of different len failed\n"); if (!json_object_equal(ar1, ar3)) printf("Comparing different arrays is correct\n"); else printf("Comparing different arrays failed\n"); if (!json_object_equal(ar1, ar4)) printf("Comparing different arrays (one empty) is correct\n"); else printf("Comparing different arrays (one empty) failed\n"); json_object_put(ar1); json_object_put(ar2); json_object_put(ar3); json_object_put(ar4); /* object tests */ struct json_object *obj1 = json_object_new_object(); struct json_object *obj2 = json_object_new_object(); json_object_object_add(obj1, "test1", json_object_new_int(123)); json_object_object_add(obj1, "test2", json_object_new_int(321)); json_object_object_add(obj1, "test3", json_object_new_int(320)); json_object_object_add(obj1, "test4", json_object_new_int(319)); json_object_object_add(obj1, "test5", json_object_new_int(318)); json_object_object_add(obj2, "test5", json_object_new_int(318)); json_object_object_add(obj2, "test4", json_object_new_int(319)); json_object_object_add(obj2, "test3", json_object_new_int(320)); json_object_object_add(obj2, "test2", json_object_new_int(321)); json_object_object_add(obj2, "test1", json_object_new_int(123)); /* key-order is different between obj1 and obj2, should still be equal */ if (json_object_equal(obj1, obj2)) printf("Comparing JSON object with different key order is correct\n"); else printf("Comparing JSON object with different key order is incorrect\n"); /* make obj2 look different to obj1 */ json_object_object_add(obj2, "test3", json_object_new_int(234)); if (!json_object_equal(obj1, obj2)) printf("Comparing different objects is correct\n"); else printf("Comparing different objects is incorrect\n"); /* iterate over jso2 keys to see if any exist that are not in jso1 */ json_object_object_add(obj2, "test3", json_object_new_int(320)); json_object_object_add(obj2, "test6", json_object_new_int(321)); if (!json_object_equal(obj1, obj2)) printf("Comparing different objects is correct\n"); else printf("Comparing different objects is incorrect\n"); /* iterate over jso1 keys and see if they exist in jso1 */ json_object_object_add(obj1, "test6", json_object_new_int(321)); if (json_object_equal(obj1, obj2)) printf("Comparing different objects is correct\n"); else printf("Comparing different objects is incorrect\n"); json_object_object_add(obj1, "test7", json_object_new_int(322)); if (!json_object_equal(obj1, obj2)) printf("Comparing different objects is correct\n"); else printf("Comparing different objects is incorrect\n"); json_object_put(obj1); json_object_put(obj2); /* different types tests */ struct json_object *int5 = json_object_new_int(0); struct json_object *dbl5 = json_object_new_double(3.14159); if (!json_object_equal(int5, NULL)) printf("JSON integer and NULL comparison is correct\n"); else printf("JSON integer and NULL comparison failed\n"); if (!json_object_equal(NULL, dbl5)) printf("JSON NULL and double comparison is correct\n"); else printf("JSON NULL and double comparison failed\n"); if (!json_object_equal(int5, dbl5)) printf("JSON integer and double comparison is correct\n"); else printf("JSON integer and double comparison failed\n"); json_object_put(int5); json_object_put(dbl5); return 0; } json-c-json-c-0.17-20230812/tests/test_compare.expected000066400000000000000000000024721446575330000223060ustar00rootroot00000000000000JSON integer comparison is correct JSON same object comparison is correct JSON same integer comparison is correct JSON usigned integer comparison is correct JSON same usigned object comparison is correct JSON same usigned integer comparison is correct JSON integer & usigned integer comparison is correct JSON integer & usigned integer comparison is correct JSON integer & usigned integer comparison is correct JSON integer & usigned integer comparison is correct JSON usigned integer & integer comparison is correct JSON usigned integer & integer comparison is correct JSON usigned integer & integer comparison is correct JSON usigned integer & integer comparison is correct Comparing equal strings is correct Comparing different strings is correct Comparing equal doubles is correct Comparing different doubles is correct Comparing equal arrays is correct Comparing arrays of different len is correct Comparing different arrays is correct Comparing different arrays (one empty) is correct Comparing JSON object with different key order is correct Comparing different objects is correct Comparing different objects is correct Comparing different objects is correct Comparing different objects is correct JSON integer and NULL comparison is correct JSON NULL and double comparison is correct JSON integer and double comparison is correct json-c-json-c-0.17-20230812/tests/test_compare.test000077700000000000000000000000001446575330000244732test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_deep_copy.c000066400000000000000000000216441446575330000212520ustar00rootroot00000000000000#include #include #include #include #ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include "json.h" #include "printbuf.h" static void do_benchmark(json_object *src1); static const char *json_str1 = "{" " \"glossary\": {" " \"title\": \"example glossary\"," " \"GlossDiv\": {" " \"number\": 16446744073709551615," " \"title\": \"S\"," " \"null_obj\": null, " " \"exist\": false," " \"quantity\":20," " \"univalent\":19.8," " \"GlossList\": {" " \"GlossEntry\": {" " \"ID\": \"SGML\"," " \"SortAs\": \"SGML\"," " \"GlossTerm\": \"Standard Generalized Markup Language\"," " \"Acronym\": \"SGML\"," " \"Abbrev\": \"ISO 8879:1986\"," " \"GlossDef\": {" " \"para\": \"A meta-markup language, used to create markup languages " "such as DocBook.\"," " \"GlossSeeAlso\": [\"GML\", \"XML\"]" " }," " \"GlossSee\": \"markup\"" " }" " }" " }" " }" "}"; static const char *json_str2 = "{\"menu\": {" " \"header\": \"SVG Viewer\"," " \"items\": [" " {\"id\": \"Open\"}," " {\"id\": \"OpenNew\", \"label\": \"Open New\"}," " null," " {\"id\": \"ZoomIn\", \"label\": \"Zoom In\"}," " {\"id\": \"ZoomOut\", \"label\": \"Zoom Out\"}," " {\"id\": \"OriginalView\", \"label\": \"Original View\"}," " null," " {\"id\": \"Quality\", \"another_null\": null}," " {\"id\": \"Pause\"}," " {\"id\": \"Mute\"}," " null," " {\"id\": \"Find\", \"label\": \"Find...\"}," " {\"id\": \"FindAgain\", \"label\": \"Find Again\"}," " {\"id\": \"Copy\"}," " {\"id\": \"CopyAgain\", \"label\": \"Copy Again\"}," " {\"id\": \"CopySVG\", \"label\": \"Copy SVG\"}," " {\"id\": \"ViewSVG\", \"label\": \"View SVG\"}," " {\"id\": \"ViewSource\", \"label\": \"View Source\"}," " {\"id\": \"SaveAs\", \"label\": \"Save As\"}," " null," " {\"id\": \"Help\"}," " {\"id\": \"About\", \"label\": \"About Adobe CVG Viewer...\"}" " ]" "}}"; static const char *json_str3 = "{\"menu\": {" " \"id\": \"file\"," " \"value\": \"File\"," " \"popup\": {" " \"menuitem\": [" " {\"value\": \"New\", \"onclick\": \"CreateNewDoc()\"}," " {\"value\": \"Open\", \"onclick\": \"OpenDoc()\"}," " {\"value\": \"Close\", \"onclick\": \"CloseDoc()\"}" " ]" " }" "}}"; json_object_to_json_string_fn my_custom_serializer; int my_custom_serializer(struct json_object *jso, struct printbuf *pb, int level, int flags) { sprintbuf(pb, "OTHER"); return 0; } json_c_shallow_copy_fn my_shallow_copy; int my_shallow_copy(json_object *src, json_object *parent, const char *key, size_t index, json_object **dst) { int rc; rc = json_c_shallow_copy_default(src, parent, key, index, dst); if (rc < 0) return rc; if (key != NULL && strcmp(key, "with_serializer") == 0) { printf("CALLED: my_shallow_copy on with_serializer object\n"); void *userdata = json_object_get_userdata(src); json_object_set_serializer(*dst, my_custom_serializer, userdata, NULL); return 2; } return rc; } int main(int argc, char **argv) { struct json_object *src1, *src2, *src3; struct json_object *dst1 = NULL, *dst2 = NULL, *dst3 = NULL; int benchmark = 0; if (argc > 1 && strcmp(argv[1], "--benchmark") == 0) { benchmark = 1; } src1 = json_tokener_parse(json_str1); src2 = json_tokener_parse(json_str2); src3 = json_tokener_parse(json_str3); assert(src1 != NULL); assert(src2 != NULL); assert(src3 != NULL); printf("PASSED - loaded input data\n"); /* do this 3 times to make sure overwriting it works */ assert(0 == json_object_deep_copy(src1, &dst1, NULL)); assert(0 == json_object_deep_copy(src2, &dst2, NULL)); assert(0 == json_object_deep_copy(src3, &dst3, NULL)); printf("PASSED - all json_object_deep_copy() returned successful\n"); assert(-1 == json_object_deep_copy(src1, &dst1, NULL)); assert(errno == EINVAL); assert(-1 == json_object_deep_copy(src2, &dst2, NULL)); assert(errno == EINVAL); assert(-1 == json_object_deep_copy(src3, &dst3, NULL)); assert(errno == EINVAL); printf("PASSED - all json_object_deep_copy() returned EINVAL for non-null pointer\n"); assert(1 == json_object_equal(src1, dst1)); assert(1 == json_object_equal(src2, dst2)); assert(1 == json_object_equal(src3, dst3)); printf("PASSED - all json_object_equal() tests returned successful\n"); assert(0 == strcmp(json_object_to_json_string_ext(src1, JSON_C_TO_STRING_PRETTY), json_object_to_json_string_ext(dst1, JSON_C_TO_STRING_PRETTY))); assert(0 == strcmp(json_object_to_json_string_ext(src2, JSON_C_TO_STRING_PRETTY), json_object_to_json_string_ext(dst2, JSON_C_TO_STRING_PRETTY))); assert(0 == strcmp(json_object_to_json_string_ext(src3, JSON_C_TO_STRING_PRETTY), json_object_to_json_string_ext(dst3, JSON_C_TO_STRING_PRETTY))); printf("PASSED - comparison of string output\n"); json_object_get(dst1); assert(-1 == json_object_deep_copy(src1, &dst1, NULL)); assert(errno == EINVAL); json_object_put(dst1); printf("PASSED - trying to overrwrite an object that has refcount > 1"); printf("\nPrinting JSON objects for visual inspection\n"); printf("------------------------------------------------\n"); printf(" JSON1\n"); printf("%s\n", json_object_to_json_string_ext(dst1, JSON_C_TO_STRING_PRETTY)); printf("------------------------------------------------\n"); printf("------------------------------------------------\n"); printf(" JSON2\n"); printf("%s\n", json_object_to_json_string_ext(dst2, JSON_C_TO_STRING_PRETTY)); printf("------------------------------------------------\n"); printf("------------------------------------------------\n"); printf(" JSON3\n"); printf("------------------------------------------------\n"); printf("%s\n", json_object_to_json_string_ext(dst3, JSON_C_TO_STRING_PRETTY)); printf("------------------------------------------------\n"); json_object_put(dst1); json_object_put(dst2); json_object_put(dst3); printf("\nTesting deep_copy with a custom serializer set\n"); json_object *with_serializer = json_object_new_string("notemitted"); char udata[] = "dummy userdata"; json_object_set_serializer(with_serializer, my_custom_serializer, udata, NULL); json_object_object_add(src1, "with_serializer", with_serializer); dst1 = NULL; /* With a custom serializer in use, a custom shallow_copy function must also be used */ assert(-1 == json_object_deep_copy(src1, &dst1, NULL)); assert(0 == json_object_deep_copy(src1, &dst1, my_shallow_copy)); json_object *dest_with_serializer = json_object_object_get(dst1, "with_serializer"); assert(dest_with_serializer != NULL); char *dst_userdata = json_object_get_userdata(dest_with_serializer); assert(strcmp(dst_userdata, "dummy userdata") == 0); const char *special_output = json_object_to_json_string(dest_with_serializer); assert(strcmp(special_output, "OTHER") == 0); printf("\ndeep_copy with custom serializer worked OK.\n"); json_object_put(dst1); if (benchmark) { do_benchmark(src2); } json_object_put(src1); json_object_put(src2); json_object_put(src3); return 0; } static void do_benchmark(json_object *src2) { json_object *dst2 = NULL; int ii; /** * The numbers that I got are: * BENCHMARK - 1000000 iterations of 'dst2 = json_tokener_parse(json_object_get_string(src2))' took 71 seconds * BENCHMARK - 1000000 iterations of 'json_object_deep_copy(src2, &dst2, NULL)' took 29 seconds */ int iterations = 1000000; time_t start = time(NULL); start = time(NULL); for (ii = 0; ii < iterations; ii++) { dst2 = json_tokener_parse(json_object_get_string(src2)); json_object_put(dst2); } printf("BENCHMARK - %d iterations of 'dst2 = " "json_tokener_parse(json_object_get_string(src2))' took %d seconds\n", iterations, (int)(time(NULL) - start)); start = time(NULL); dst2 = NULL; for (ii = 0; ii < iterations; ii++) { json_object_deep_copy(src2, &dst2, NULL); json_object_put(dst2); dst2 = NULL; } printf("BENCHMARK - %d iterations of 'json_object_deep_copy(src2, &dst2, NULL)' took %d " "seconds\n", iterations, (int)(time(NULL) - start)); } json-c-json-c-0.17-20230812/tests/test_deep_copy.expected000066400000000000000000000060741446575330000226310ustar00rootroot00000000000000PASSED - loaded input data PASSED - all json_object_deep_copy() returned successful PASSED - all json_object_deep_copy() returned EINVAL for non-null pointer PASSED - all json_object_equal() tests returned successful PASSED - comparison of string output PASSED - trying to overrwrite an object that has refcount > 1 Printing JSON objects for visual inspection ------------------------------------------------ JSON1 { "glossary":{ "title":"example glossary", "GlossDiv":{ "number":16446744073709551615, "title":"S", "null_obj":null, "exist":false, "quantity":20, "univalent":19.8, "GlossList":{ "GlossEntry":{ "ID":"SGML", "SortAs":"SGML", "GlossTerm":"Standard Generalized Markup Language", "Acronym":"SGML", "Abbrev":"ISO 8879:1986", "GlossDef":{ "para":"A meta-markup language, used to create markup languages such as DocBook.", "GlossSeeAlso":[ "GML", "XML" ] }, "GlossSee":"markup" } } } } } ------------------------------------------------ ------------------------------------------------ JSON2 { "menu":{ "header":"SVG Viewer", "items":[ { "id":"Open" }, { "id":"OpenNew", "label":"Open New" }, null, { "id":"ZoomIn", "label":"Zoom In" }, { "id":"ZoomOut", "label":"Zoom Out" }, { "id":"OriginalView", "label":"Original View" }, null, { "id":"Quality", "another_null":null }, { "id":"Pause" }, { "id":"Mute" }, null, { "id":"Find", "label":"Find..." }, { "id":"FindAgain", "label":"Find Again" }, { "id":"Copy" }, { "id":"CopyAgain", "label":"Copy Again" }, { "id":"CopySVG", "label":"Copy SVG" }, { "id":"ViewSVG", "label":"View SVG" }, { "id":"ViewSource", "label":"View Source" }, { "id":"SaveAs", "label":"Save As" }, null, { "id":"Help" }, { "id":"About", "label":"About Adobe CVG Viewer..." } ] } } ------------------------------------------------ ------------------------------------------------ JSON3 ------------------------------------------------ { "menu":{ "id":"file", "value":"File", "popup":{ "menuitem":[ { "value":"New", "onclick":"CreateNewDoc()" }, { "value":"Open", "onclick":"OpenDoc()" }, { "value":"Close", "onclick":"CloseDoc()" } ] } } } ------------------------------------------------ Testing deep_copy with a custom serializer set CALLED: my_shallow_copy on with_serializer object deep_copy with custom serializer worked OK. json-c-json-c-0.17-20230812/tests/test_deep_copy.test000077700000000000000000000000001446575330000250142test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_double_serializer.c000066400000000000000000000111761446575330000230050ustar00rootroot00000000000000/* * Tests if the format string for double serialization is handled correctly */ #ifdef NDEBUG #undef NDEBUG #endif #include "config.h" #include #include "json_object.h" #include "json_object_private.h" /* Avoid compiler warnings about diving by constant zero */ double zero_dot_zero = 0.0; int main(int argc, char **argv) { struct json_object *obj = json_object_new_double(0.5); char udata[] = "test"; printf("Test default serializer:\n"); printf("obj.to_string(standard)=%s\n", json_object_to_json_string(obj)); printf("Test default serializer with custom userdata:\n"); obj->_userdata = udata; printf("obj.to_string(userdata)=%s\n", json_object_to_json_string(obj)); printf("Test explicit serializer with custom userdata:\n"); json_object_set_serializer(obj, json_object_double_to_json_string, udata, NULL); printf("obj.to_string(custom)=%s\n", json_object_to_json_string(obj)); printf("Test reset serializer:\n"); json_object_set_serializer(obj, NULL, NULL, NULL); printf("obj.to_string(reset)=%s\n", json_object_to_json_string(obj)); json_object_put(obj); printf("Test no zero reset serializer:\n"); obj = json_object_new_double(3.1415000); char data[] = "%.17g"; json_object_set_serializer(obj, json_object_double_to_json_string, data, NULL); printf("obj.to_string(reset)=%s\n", json_object_to_json_string_ext(obj, 4)); json_object_put(obj); obj = json_object_new_double(0.52381); printf("obj.to_string(default format)=%s\n", json_object_to_json_string(obj)); if (json_c_set_serialization_double_format("x%0.3fy", JSON_C_OPTION_GLOBAL) < 0) printf("ERROR: json_c_set_serialization_double_format() failed"); printf("obj.to_string(with global format)=%s\n", json_object_to_json_string(obj)); #ifdef HAVE___THREAD if (json_c_set_serialization_double_format("T%0.2fX", JSON_C_OPTION_THREAD) < 0) printf("ERROR: json_c_set_serialization_double_format() failed"); printf("obj.to_string(with thread format)=%s\n", json_object_to_json_string(obj)); if (json_c_set_serialization_double_format("Ttttttttttttt%0.2fxxxxxxxxxxxxxxxxxxX", JSON_C_OPTION_THREAD) < 0) printf("ERROR: json_c_set_serialization_double_format() failed"); printf("obj.to_string(long thread format)=%s\n", json_object_to_json_string(obj)); if (json_c_set_serialization_double_format(NULL, JSON_C_OPTION_THREAD) < 0) printf("ERROR: json_c_set_serialization_double_format() failed"); printf("obj.to_string(back to global format)=%s\n", json_object_to_json_string(obj)); #else // Just fake it up, so the output matches. printf("obj.to_string(with thread format)=%s\n", "T0.52X"); printf("obj.to_string(long thread format)=%s\n", "Ttttttttttttt0.52xxxxxxxxxxxxxxxxxxX"); printf("obj.to_string(back to global format)=%s\n", "x0.524y"); #endif if (json_c_set_serialization_double_format(NULL, JSON_C_OPTION_GLOBAL) < 0) printf("ERROR: json_c_set_serialization_double_format() failed"); printf("obj.to_string(back to default format)=%s\n", json_object_to_json_string(obj)); json_object_put(obj); obj = json_object_new_double(12.0); printf("obj(12.0).to_string(default format)=%s\n", json_object_to_json_string(obj)); if (json_c_set_serialization_double_format("%.0f", JSON_C_OPTION_GLOBAL) < 0) printf("ERROR: json_c_set_serialization_double_format() failed"); printf("obj(12.0).to_string(%%.0f)=%s\n", json_object_to_json_string(obj)); if (json_c_set_serialization_double_format("%.0g", JSON_C_OPTION_GLOBAL) < 0) printf("ERROR: json_c_set_serialization_double_format() failed"); printf("obj(12.0).to_string(%%.0g)=%s\n", json_object_to_json_string(obj)); if (json_c_set_serialization_double_format("%.2g", JSON_C_OPTION_GLOBAL) < 0) printf("ERROR: json_c_set_serialization_double_format() failed"); printf("obj(12.0).to_string(%%.1g)=%s\n", json_object_to_json_string(obj)); // Reset to default to free memory if (json_c_set_serialization_double_format(NULL, JSON_C_OPTION_GLOBAL) < 0) printf("ERROR: json_c_set_serialization_double_format() failed"); json_object_put(obj); obj = json_object_new_double(-12.0); printf("obj(-12.0).to_string(default format)=%s\n", json_object_to_json_string(obj)); json_object_put(obj); /* Test NaN handling */ obj = json_object_new_double(zero_dot_zero / zero_dot_zero); printf("obj(0.0/0.0)=%s\n", json_object_to_json_string(obj)); json_object_put(obj); /* Test Infinity and -Infinity handling */ obj = json_object_new_double(1.0 / zero_dot_zero); printf("obj(1.0/0.0)=%s\n", json_object_to_json_string(obj)); json_object_put(obj); obj = json_object_new_double(-1.0 / zero_dot_zero); printf("obj(-1.0/0.0)=%s\n", json_object_to_json_string(obj)); json_object_put(obj); return 0; } json-c-json-c-0.17-20230812/tests/test_double_serializer.expected000066400000000000000000000015121446575330000243550ustar00rootroot00000000000000Test default serializer: obj.to_string(standard)=0.5 Test default serializer with custom userdata: obj.to_string(userdata)=0.5 Test explicit serializer with custom userdata: obj.to_string(custom)=test Test reset serializer: obj.to_string(reset)=0.5 Test no zero reset serializer: obj.to_string(reset)=3.1415000000000002 obj.to_string(default format)=0.52381 obj.to_string(with global format)=x0.524y obj.to_string(with thread format)=T0.52X obj.to_string(long thread format)=Ttttttttttttt0.52xxxxxxxxxxxxxxxxxxX obj.to_string(back to global format)=x0.524y obj.to_string(back to default format)=0.52381 obj(12.0).to_string(default format)=12.0 obj(12.0).to_string(%.0f)=12 obj(12.0).to_string(%.0g)=1e+01 obj(12.0).to_string(%.1g)=12.0 obj(-12.0).to_string(default format)=-12.0 obj(0.0/0.0)=NaN obj(1.0/0.0)=Infinity obj(-1.0/0.0)=-Infinity json-c-json-c-0.17-20230812/tests/test_double_serializer.test000077700000000000000000000000001446575330000265502test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_float.c000066400000000000000000000017571446575330000204130ustar00rootroot00000000000000/* Copyright (C) 2016 by Rainer Gerhards * Released under ASL 2.0 */ #ifdef NDEBUG #undef NDEBUG #endif #include "config.h" #include "json_object.h" #include "json_tokener.h" #include int main(void) { json_object *json; json = json_object_new_double(1.0); printf("json = %s\n", json_object_to_json_string_ext(json, JSON_C_TO_STRING_PRETTY)); json_object_put(json); json = json_object_new_double(-1.0); printf("json = %s\n", json_object_to_json_string_ext(json, JSON_C_TO_STRING_PRETTY)); json_object_put(json); json = json_object_new_double(1.23); printf("json = %s\n", json_object_to_json_string_ext(json, JSON_C_TO_STRING_PRETTY)); json_object_put(json); json = json_object_new_double(123456789.0); printf("json = %s\n", json_object_to_json_string_ext(json, JSON_C_TO_STRING_PRETTY)); json_object_put(json); json = json_object_new_double(123456789.123); printf("json = %s\n", json_object_to_json_string_ext(json, JSON_C_TO_STRING_PRETTY)); json_object_put(json); return 0; } json-c-json-c-0.17-20230812/tests/test_float.expected000066400000000000000000000001131446575330000217530ustar00rootroot00000000000000json = 1.0 json = -1.0 json = 1.23 json = 123456789.0 json = 123456789.123 json-c-json-c-0.17-20230812/tests/test_float.test000077700000000000000000000000001446575330000241522test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_int_add.c000066400000000000000000000047341446575330000207060ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include #include #include "json.h" int main(int argc, char **argv) { json_object *tmp = json_object_new_int(123); json_object_int_inc(tmp, 123); assert(json_object_get_int(tmp) == 246); json_object_put(tmp); printf("INT ADD PASSED\n"); tmp = json_object_new_int(INT32_MAX); json_object_int_inc(tmp, 100); assert(json_object_get_int(tmp) == INT32_MAX); assert(json_object_get_int64(tmp) == (int64_t)INT32_MAX + 100L); json_object_put(tmp); printf("INT ADD OVERFLOW PASSED\n"); tmp = json_object_new_int(INT32_MIN); json_object_int_inc(tmp, -100); assert(json_object_get_int(tmp) == INT32_MIN); assert(json_object_get_int64(tmp) == (int64_t)INT32_MIN - 100L); json_object_put(tmp); printf("INT ADD UNDERFLOW PASSED\n"); tmp = json_object_new_int64(321321321); json_object_int_inc(tmp, 321321321); assert(json_object_get_int(tmp) == 642642642); json_object_put(tmp); printf("INT64 ADD PASSED\n"); tmp = json_object_new_int64(INT64_MAX); json_object_int_inc(tmp, 100); assert(json_object_get_int64(tmp) == INT64_MAX); assert(json_object_get_uint64(tmp) == (uint64_t)INT64_MAX + 100U); json_object_int_inc(tmp, -100); assert(json_object_get_int64(tmp) == INT64_MAX); assert(json_object_get_uint64(tmp) == (uint64_t)INT64_MAX); json_object_put(tmp); printf("INT64 ADD OVERFLOW PASSED\n"); tmp = json_object_new_int64(INT64_MIN); json_object_int_inc(tmp, -100); assert(json_object_get_int64(tmp) == INT64_MIN); json_object_int_inc(tmp, 100); assert(json_object_get_int64(tmp) != INT64_MIN); json_object_put(tmp); printf("INT64 ADD UNDERFLOW PASSED\n"); // uint64 + negative int64--> negative int64 tmp = json_object_new_uint64(400); json_object_int_inc(tmp, -200); assert(json_object_get_int64(tmp) == 200); assert(json_object_get_uint64(tmp) == 200); json_object_int_inc(tmp, 200); assert(json_object_get_int64(tmp) == 400); assert(json_object_get_uint64(tmp) == 400); json_object_put(tmp); printf("UINT64 ADD PASSED\n"); tmp = json_object_new_uint64(UINT64_MAX-50); json_object_int_inc(tmp, 100); assert(json_object_get_int64(tmp) == INT64_MAX); assert(json_object_get_uint64(tmp) == UINT64_MAX); json_object_put(tmp); printf("UINT64 ADD OVERFLOW PASSED\n"); tmp = json_object_new_uint64(100); json_object_int_inc(tmp, -200); assert(json_object_get_int64(tmp) == -100); assert(json_object_get_uint64(tmp) == 0); json_object_put(tmp); printf("UINT64 ADD UNDERFLOW PASSED\n"); printf("PASSED\n"); return 0; } json-c-json-c-0.17-20230812/tests/test_int_add.expected000066400000000000000000000003261446575330000222560ustar00rootroot00000000000000INT ADD PASSED INT ADD OVERFLOW PASSED INT ADD UNDERFLOW PASSED INT64 ADD PASSED INT64 ADD OVERFLOW PASSED INT64 ADD UNDERFLOW PASSED UINT64 ADD PASSED UINT64 ADD OVERFLOW PASSED UINT64 ADD UNDERFLOW PASSED PASSED json-c-json-c-0.17-20230812/tests/test_int_add.test000077700000000000000000000000001446575330000244472test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_int_get.c000066400000000000000000000050701446575330000207270ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include "json.h" #define I64_MAX_S "9223372036854775807" #define I64_OVER "9223372036854775808" #define I64_MIN_S "-9223372036854775808" #define I64_UNDER "-9223372036854775809" #define U64_MAX_S "18446744073709551615" #define U64_OUT_S "18446744073709551616" #define CHECK_GET(GET_F, J, EXPECTED) { struct json_object *jtmp = J; errno = 0; assert(GET_F(jtmp) == EXPECTED); json_object_put(jtmp); } #define CHECK_GET_INT(J, EXPECTED) CHECK_GET(json_object_get_int, J, EXPECTED) #define CHECK_GET_INT64(J, EXPECTED) CHECK_GET(json_object_get_int64, J, EXPECTED) #define CHECK_GET_UINT64(J, EXPECTED) CHECK_GET(json_object_get_uint64, J, EXPECTED) #define CHECK_BASE(J, EXPECTED) CHECK_GET_INT(J, EXPECTED); CHECK_GET_INT64(J, EXPECTED); CHECK_GET_UINT64(J, EXPECTED) #define N_INT json_object_new_int #define N_I64 json_object_new_int64 #define N_U64 json_object_new_uint64 #define N_STR json_object_new_string int main(int argc, char **argv) { CHECK_BASE(N_INT(5), 5); CHECK_BASE(N_INT(0), 0); CHECK_BASE(N_STR("0"), 0); CHECK_BASE(N_STR("00000"), 0); CHECK_BASE(N_STR("000004568789"), 4568789); CHECK_BASE(N_STR("0xFF"), 0 && errno == 0); // Hex-string values being parsed as 0 is the intended behavior CHECK_BASE(N_STR("333this_seems_a_valid_string"), 333); CHECK_BASE(N_STR("this_is_not_a_number"), 0 && errno == EINVAL); CHECK_BASE(N_STR("B0"), 0 && errno == EINVAL); printf("BASE CHECK PASSED\n"); CHECK_GET_INT(N_I64(INT32_MAX), INT32_MAX && errno == 0); CHECK_GET_INT(N_I64(INT32_MIN), INT32_MIN && errno == 0); CHECK_GET_INT(N_I64(INT64_MAX), INT32_MAX && errno == 0); CHECK_GET_INT(N_I64(INT64_MIN), INT32_MIN && errno == 0); CHECK_GET_INT(N_STR(I64_MAX_S), INT32_MAX && errno == 0); CHECK_GET_INT(N_STR(I64_MIN_S), INT32_MIN && errno == 0); printf("INT GET PASSED\n"); CHECK_GET_INT64(N_I64(INT64_MAX), INT64_MAX && errno == 0); CHECK_GET_INT64(N_I64(INT64_MIN), INT64_MIN && errno == 0); CHECK_GET_INT64(N_STR(I64_MAX_S), INT64_MAX && errno == 0); CHECK_GET_INT64(N_STR(I64_MIN_S), INT64_MIN && errno == 0); CHECK_GET_INT64(N_STR(I64_OVER), INT64_MAX && errno == ERANGE); CHECK_GET_INT64(N_STR(I64_UNDER), INT64_MIN && errno == ERANGE); printf("INT64 GET PASSED\n"); CHECK_GET_UINT64(N_U64(UINT64_MAX), UINT64_MAX && errno == 0); CHECK_GET_UINT64(N_U64(-1), UINT64_MAX && errno == 0); CHECK_GET_UINT64(N_STR(U64_OUT_S), UINT64_MAX && errno == ERANGE); printf("UINT64 GET PASSED\n"); printf("PASSED\n"); return 0; } json-c-json-c-0.17-20230812/tests/test_int_get.expected000066400000000000000000000001131446575330000222770ustar00rootroot00000000000000BASE CHECK PASSED INT GET PASSED INT64 GET PASSED UINT64 GET PASSED PASSED json-c-json-c-0.17-20230812/tests/test_int_get.test000077700000000000000000000000001446575330000244762test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_json_patch.c000066400000000000000000000073561446575330000214370ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include "strerror_override.h" #include #include #include #include #include #include "config.h" #include "json.h" #include "snprintf_compat.h" #ifndef PATH_MAX #define PATH_MAX 256 #endif void test_json_patch_op(struct json_object *jo) { const char *comment = json_object_get_string(json_object_object_get(jo, "comment")); struct json_object *doc = json_object_object_get(jo, "doc"); struct json_object *patch = json_object_object_get(jo, "patch"); struct json_object *expected = NULL; json_bool have_expected = json_object_object_get_ex(jo, "expected", &expected); struct json_object *error = json_object_object_get(jo, "error"); const char *error_s = json_object_get_string(error); struct json_object *res = NULL; int ret; printf("Testing '%s', doc '%s' patch '%s' : ", comment ? comment : error_s, json_object_get_string(doc), json_object_get_string(patch)); if (!error && !have_expected) { printf("BAD TEST - no expected or error conditions in test: %s\n", json_object_to_json_string(jo)); assert(0); } fflush(stdout); struct json_patch_error jperr; if (error) { assert(-1 == json_patch_apply(doc, patch, &res, &jperr)); assert(jperr.errno_code != 0); printf("OK\n"); printf(" => json_patch_apply failed as expected: %s at patch idx %zu: %s\n", strerror(jperr.errno_code), jperr.patch_failure_idx, jperr.errmsg); json_object_put(res); } else { ret = json_patch_apply(doc, patch, &res, &jperr); if (ret) { fprintf(stderr, "json_patch_apply() returned '%d'\n", ret); fprintf(stderr, "Expected: %s\n", json_object_get_string(expected)); fprintf(stderr, "Got: %s\n", res ? json_object_get_string(res) : "(null)"); fprintf(stderr, "json_patch_apply failed: %s at patch idx %zu: %s\n", strerror(jperr.errno_code), jperr.patch_failure_idx, jperr.errmsg); fflush(stderr); assert(0); } // Note: res might be NULL if the whole document was removed assert(jperr.errno_code == 0); ret = json_object_equal(expected, res); if (ret == 0) { fprintf(stderr, "json_object_equal() returned '%d'\n", ret); fprintf(stderr, "Expected: %s\n", json_object_get_string(expected)); fprintf(stderr, "Got: %s\n", json_object_get_string(res)); fflush(stderr); assert(0); } json_object_put(res); res = NULL; printf("OK\n"); } } void test_json_patch_using_file(const char *testdir, const char *filename) { char full_filename[PATH_MAX]; (void)snprintf(full_filename, sizeof(full_filename), "%s/%s", testdir, filename); size_t ii; printf("Testing using file %s\n", filename); json_object *jo = json_object_from_file(full_filename); if (!jo) { fprintf(stderr, "FAIL: unable to open %s: %s\n", full_filename, strerror(errno)); exit(EXIT_FAILURE); } for (ii = 0; ii < json_object_array_length(jo); ii++) { struct json_object *jo1 = json_object_array_get_idx(jo, ii); test_json_patch_op(jo1); } json_object_put(jo); } int main(int argc, char **argv) { const char *testdir; if (argc < 2) { fprintf(stderr, "Usage: %s \n" " is the location of input files\n", argv[0]); return EXIT_FAILURE; } testdir = argv[1]; // Test json_c_version.c if (strncmp(json_c_version(), JSON_C_VERSION, sizeof(JSON_C_VERSION))) { printf("FAIL: Output from json_c_version(): %s does not match %s", json_c_version(), JSON_C_VERSION); return EXIT_FAILURE; } if (json_c_version_num() != JSON_C_VERSION_NUM) { printf("FAIL: Output from json_c_version_num(): %d does not match %d", json_c_version_num(), JSON_C_VERSION_NUM); return EXIT_FAILURE; } test_json_patch_using_file(testdir, "json_patch_spec_tests.json"); test_json_patch_using_file(testdir, "json_patch_tests.json"); return 0; } json-c-json-c-0.17-20230812/tests/test_json_patch.expected000066400000000000000000000476421446575330000230200ustar00rootroot00000000000000Testing using file json_patch_spec_tests.json Testing '4.1. add with missing object', doc '{ "q": { "bar": 2 } }' patch '[ { "op": "add", "path": "\/a\/b", "value": 1 } ]' : OK => json_patch_apply failed as expected: ERRNO=ENOENT at patch idx 0: Failed to set value at path referenced by 'path' field Testing 'A.1. Adding an Object Member', doc '{ "foo": "bar" }' patch '[ { "op": "add", "path": "\/baz", "value": "qux" } ]' : OK Testing 'A.2. Adding an Array Element', doc '{ "foo": [ "bar", "baz" ] }' patch '[ { "op": "add", "path": "\/foo\/1", "value": "qux" } ]' : OK Testing 'A.3. Removing an Object Member', doc '{ "baz": "qux", "foo": "bar" }' patch '[ { "op": "remove", "path": "\/baz" } ]' : OK Testing 'A.4. Removing an Array Element', doc '{ "foo": [ "bar", "qux", "baz" ] }' patch '[ { "op": "remove", "path": "\/foo\/1" } ]' : OK Testing 'A.5. Replacing a Value', doc '{ "baz": "qux", "foo": "bar" }' patch '[ { "op": "replace", "path": "\/baz", "value": "boo" } ]' : OK Testing 'A.6. Moving a Value', doc '{ "foo": { "bar": "baz", "waldo": "fred" }, "qux": { "corge": "grault" } }' patch '[ { "op": "move", "from": "\/foo\/waldo", "path": "\/qux\/thud" } ]' : OK Testing 'A.7. Moving an Array Element', doc '{ "foo": [ "all", "grass", "cows", "eat" ] }' patch '[ { "op": "move", "from": "\/foo\/1", "path": "\/foo\/3" } ]' : OK Testing 'A.8. Testing a Value: Success', doc '{ "baz": "qux", "foo": [ "a", 2, "c" ] }' patch '[ { "op": "test", "path": "\/baz", "value": "qux" }, { "op": "test", "path": "\/foo\/1", "value": 2 } ]' : OK Testing 'A.9. Testing a Value: Error', doc '{ "baz": "qux" }' patch '[ { "op": "test", "path": "\/baz", "value": "bar" } ]' : OK => json_patch_apply failed as expected: ERRNO=ENOENT at patch idx 0: Value of element referenced by 'path' field did not match 'value' field Testing 'A.10. Adding a nested Member Object', doc '{ "foo": "bar" }' patch '[ { "op": "add", "path": "\/child", "value": { "grandchild": { } } } ]' : OK Testing 'A.11. Ignoring Unrecognized Elements', doc '{ "foo": "bar" }' patch '[ { "op": "add", "path": "\/baz", "value": "qux", "xyz": 123 } ]' : OK Testing 'A.12. Adding to a Non-existent Target', doc '{ "foo": "bar" }' patch '[ { "op": "add", "path": "\/baz\/bat", "value": "qux" } ]' : OK => json_patch_apply failed as expected: ERRNO=ENOENT at patch idx 0: Failed to set value at path referenced by 'path' field Testing 'A.13 Invalid JSON Patch Document', doc '{ "foo": "bar" }' patch '[ { "op": "remove", "path": "\/baz", "value": "qux" } ]' : OK => json_patch_apply failed as expected: ERRNO=ENOENT at patch idx 0: Did not find element referenced by path field Testing 'A.14. ~ Escape Ordering', doc '{ "\/": 9, "~1": 10 }' patch '[ { "op": "test", "path": "\/~01", "value": 10 } ]' : OK Testing 'A.15. Comparing Strings and Numbers', doc '{ "\/": 9, "~1": 10 }' patch '[ { "op": "test", "path": "\/~01", "value": "10" } ]' : OK => json_patch_apply failed as expected: ERRNO=ENOENT at patch idx 0: Value of element referenced by 'path' field did not match 'value' field Testing 'A.16. Adding an Array Value', doc '{ "foo": [ "bar" ] }' patch '[ { "op": "add", "path": "\/foo\/-", "value": [ "abc", "def" ] } ]' : OK Testing using file json_patch_tests.json Testing 'empty list, empty docs', doc '{ }' patch '[ ]' : OK Testing 'empty patch list', doc '{ "foo": 1 }' patch '[ ]' : OK Testing 'rearrangements OK?', doc '{ "foo": 1, "bar": 2 }' patch '[ ]' : OK Testing 'rearrangements OK? How about one level down ... array', doc '[ { "foo": 1, "bar": 2 } ]' patch '[ ]' : OK Testing 'rearrangements OK? How about one level down...', doc '{ "foo": { "foo": 1, "bar": 2 } }' patch '[ ]' : OK Testing 'add replaces any existing field', doc '{ "foo": null }' patch '[ { "op": "add", "path": "\/foo", "value": 1 } ]' : OK Testing 'toplevel array', doc '[ ]' patch '[ { "op": "add", "path": "\/0", "value": "foo" } ]' : OK Testing 'toplevel array, no change', doc '[ "foo" ]' patch '[ ]' : OK Testing 'toplevel object, numeric string', doc '{ }' patch '[ { "op": "add", "path": "\/foo", "value": "1" } ]' : OK Testing 'toplevel object, integer', doc '{ }' patch '[ { "op": "add", "path": "\/foo", "value": 1 } ]' : OK Testing 'Toplevel scalar values OK?', doc 'foo' patch '[ { "op": "replace", "path": "", "value": "bar" } ]' : OK Testing 'replace object document with array document?', doc '{ }' patch '[ { "op": "add", "path": "", "value": [ ] } ]' : OK Testing 'replace array document with object document?', doc '[ ]' patch '[ { "op": "add", "path": "", "value": { } } ]' : OK Testing 'append to root array document?', doc '[ ]' patch '[ { "op": "add", "path": "\/-", "value": "hi" } ]' : OK Testing 'Add, / target', doc '{ }' patch '[ { "op": "add", "path": "\/", "value": 1 } ]' : OK Testing 'Add, /foo/ deep target (trailing slash)', doc '{ "foo": { } }' patch '[ { "op": "add", "path": "\/foo\/", "value": 1 } ]' : OK Testing 'Add composite value at top level', doc '{ "foo": 1 }' patch '[ { "op": "add", "path": "\/bar", "value": [ 1, 2 ] } ]' : OK Testing 'Add into composite value', doc '{ "foo": 1, "baz": [ { "qux": "hello" } ] }' patch '[ { "op": "add", "path": "\/baz\/0\/foo", "value": "world" } ]' : OK Testing 'Out of bounds (upper)', doc '{ "bar": [ 1, 2 ] }' patch '[ { "op": "add", "path": "\/bar\/8", "value": "5" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Failed to set value at path referenced by 'path' field Testing 'Out of bounds (lower)', doc '{ "bar": [ 1, 2 ] }' patch '[ { "op": "add", "path": "\/bar\/-1", "value": "5" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Failed to set value at path referenced by 'path' field Testing '(null)', doc '{ "foo": 1 }' patch '[ { "op": "add", "path": "\/bar", "value": true } ]' : OK Testing '(null)', doc '{ "foo": 1 }' patch '[ { "op": "add", "path": "\/bar", "value": false } ]' : OK Testing '(null)', doc '{ "foo": 1 }' patch '[ { "op": "add", "path": "\/bar", "value": null } ]' : OK Testing '0 can be an array index or object element name', doc '{ "foo": 1 }' patch '[ { "op": "add", "path": "\/0", "value": "bar" } ]' : OK Testing '(null)', doc '[ "foo" ]' patch '[ { "op": "add", "path": "\/1", "value": "bar" } ]' : OK Testing '(null)', doc '[ "foo", "sil" ]' patch '[ { "op": "add", "path": "\/1", "value": "bar" } ]' : OK Testing '(null)', doc '[ "foo", "sil" ]' patch '[ { "op": "add", "path": "\/0", "value": "bar" } ]' : OK Testing 'push item to array via last index + 1', doc '[ "foo", "sil" ]' patch '[ { "op": "add", "path": "\/2", "value": "bar" } ]' : OK Testing 'add item to array at index > length should fail', doc '[ "foo", "sil" ]' patch '[ { "op": "add", "path": "\/3", "value": "bar" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Failed to set value at path referenced by 'path' field Testing 'test against implementation-specific numeric parsing', doc '{ "1e0": "foo" }' patch '[ { "op": "test", "path": "\/1e0", "value": "foo" } ]' : OK Testing 'test with bad number should fail', doc '[ "foo", "bar" ]' patch '[ { "op": "test", "path": "\/1e0", "value": "bar" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Invalid path field Testing 'Object operation on array target', doc '[ "foo", "sil" ]' patch '[ { "op": "add", "path": "\/bar", "value": 42 } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Failed to set value at path referenced by 'path' field Testing 'value in array add not flattened', doc '[ "foo", "sil" ]' patch '[ { "op": "add", "path": "\/1", "value": [ "bar", "baz" ] } ]' : OK Testing '(null)', doc '{ "foo": 1, "bar": [ 1, 2, 3, 4 ] }' patch '[ { "op": "remove", "path": "\/bar" } ]' : OK Testing '(null)', doc '{ "foo": 1, "baz": [ { "qux": "hello" } ] }' patch '[ { "op": "remove", "path": "\/baz\/0\/qux" } ]' : OK Testing '(null)', doc '{ "foo": 1, "baz": [ { "qux": "hello" } ] }' patch '[ { "op": "replace", "path": "\/foo", "value": [ 1, 2, 3, 4 ] } ]' : OK Testing '(null)', doc '{ "foo": [ 1, 2, 3, 4 ], "baz": [ { "qux": "hello" } ] }' patch '[ { "op": "replace", "path": "\/baz\/0\/qux", "value": "world" } ]' : OK Testing '(null)', doc '[ "foo" ]' patch '[ { "op": "replace", "path": "\/0", "value": "bar" } ]' : OK Testing '(null)', doc '[ "" ]' patch '[ { "op": "replace", "path": "\/0", "value": 0 } ]' : OK Testing '(null)', doc '[ "" ]' patch '[ { "op": "replace", "path": "\/0", "value": true } ]' : OK Testing '(null)', doc '[ "" ]' patch '[ { "op": "replace", "path": "\/0", "value": false } ]' : OK Testing '(null)', doc '[ "" ]' patch '[ { "op": "replace", "path": "\/0", "value": null } ]' : OK Testing 'value in array replace not flattened', doc '[ "foo", "sil" ]' patch '[ { "op": "replace", "path": "\/1", "value": [ "bar", "baz" ] } ]' : OK Testing 'replace whole document', doc '{ "foo": "bar" }' patch '[ { "op": "replace", "path": "", "value": { "baz": "qux" } } ]' : OK Testing 'add whole document, null', doc '{ }' patch '[ { "op": "remove", "path": "" }, { "op": "add", "path": "", "value": { "baz": "qux" } } ]' : OK Testing 'replace whole document, null', doc '{ }' patch '[ { "op": "remove", "path": "" }, { "op": "replace", "path": "", "value": { "baz": "qux" } } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 1: Invalid path field Testing 'remove whole document', doc '{ "foo": "bar" }' patch '[ { "op": "remove", "path": "" } ]' : OK Testing 'remove whole document', doc '{ "foo": "bar" }' patch '[ { "op": "remove", "path": "" } ]' : OK Testing 'remove whole document, array', doc '[ "foo", "bar" ]' patch '[ { "op": "remove", "path": "" } ]' : OK Testing 'remove whole document, string', doc 'foo' patch '[ { "op": "remove", "path": "" } ]' : OK Testing 'remove whole document, null', doc '{ }' patch '[ { "op": "remove", "path": "" }, { "op": "remove", "path": "" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 1: Invalid path field Testing 'test replace with missing parent key should fail', doc '{ "bar": "baz" }' patch '[ { "op": "replace", "path": "\/foo\/bar", "value": false } ]' : OK => json_patch_apply failed as expected: ERRNO=ENOENT at patch idx 0: Did not find element referenced by path field Testing 'spurious patch properties', doc '{ "foo": 1 }' patch '[ { "op": "test", "path": "\/foo", "value": 1, "spurious": 1 } ]' : OK Testing 'null value should be valid obj property', doc '{ "foo": null }' patch '[ { "op": "test", "path": "\/foo", "value": null } ]' : OK Testing 'null value should be valid obj property to be replaced with something truthy', doc '{ "foo": null }' patch '[ { "op": "replace", "path": "\/foo", "value": "truthy" } ]' : OK Testing 'null value should be valid obj property to be moved', doc '{ "foo": null }' patch '[ { "op": "move", "from": "\/foo", "path": "\/bar" } ]' : OK Testing 'null value should be valid obj property to be copied', doc '{ "foo": null }' patch '[ { "op": "copy", "from": "\/foo", "path": "\/bar" } ]' : OK Testing 'null value should be valid obj property to be removed', doc '{ "foo": null }' patch '[ { "op": "remove", "path": "\/foo" } ]' : OK Testing 'null value should still be valid obj property replace other value', doc '{ "foo": "bar" }' patch '[ { "op": "replace", "path": "\/foo", "value": null } ]' : OK Testing 'test should pass despite rearrangement', doc '{ "foo": { "foo": 1, "bar": 2 } }' patch '[ { "op": "test", "path": "\/foo", "value": { "bar": 2, "foo": 1 } } ]' : OK Testing 'test should pass despite (nested) rearrangement', doc '{ "foo": [ { "foo": 1, "bar": 2 } ] }' patch '[ { "op": "test", "path": "\/foo", "value": [ { "bar": 2, "foo": 1 } ] } ]' : OK Testing 'test should pass - no error', doc '{ "foo": { "bar": [ 1, 2, 5, 4 ] } }' patch '[ { "op": "test", "path": "\/foo", "value": { "bar": [ 1, 2, 5, 4 ] } } ]' : OK Testing 'test op should fail', doc '{ "foo": { "bar": [ 1, 2, 5, 4 ] } }' patch '[ { "op": "test", "path": "\/foo", "value": [ 1, 2 ] } ]' : OK => json_patch_apply failed as expected: ERRNO=ENOENT at patch idx 0: Value of element referenced by 'path' field did not match 'value' field Testing 'Test the whole document', doc '{ "foo": 1 }' patch '[ { "op": "test", "path": "", "value": { "foo": 1 } } ]' : OK Testing 'Test the whole document, no match', doc '{ "foo": 1 }' patch '[ { "op": "test", "path": "", "value": { "foo": 2 } } ]' : OK => json_patch_apply failed as expected: ERRNO=ENOENT at patch idx 0: Value of element referenced by 'path' field did not match 'value' field Testing 'Empty-string element', doc '{ "": 1 }' patch '[ { "op": "test", "path": "\/", "value": 1 } ]' : OK Testing '(null)', doc '{ "foo": [ "bar", "baz" ], "": 0, "a\/b": 1, "c%d": 2, "e^f": 3, "g|h": 4, "i\\j": 5, "k\"l": 6, " ": 7, "m~n": 8 }' patch '[ { "op": "test", "path": "\/foo", "value": [ "bar", "baz" ] }, { "op": "test", "path": "\/foo\/0", "value": "bar" }, { "op": "test", "path": "\/", "value": 0 }, { "op": "test", "path": "\/a~1b", "value": 1 }, { "op": "test", "path": "\/c%d", "value": 2 }, { "op": "test", "path": "\/e^f", "value": 3 }, { "op": "test", "path": "\/g|h", "value": 4 }, { "op": "test", "path": "\/i\\j", "value": 5 }, { "op": "test", "path": "\/k\"l", "value": 6 }, { "op": "test", "path": "\/ ", "value": 7 }, { "op": "test", "path": "\/m~0n", "value": 8 } ]' : OK Testing 'Move to same location has no effect', doc '{ "foo": 1 }' patch '[ { "op": "move", "from": "\/foo", "path": "\/foo" } ]' : OK Testing '(null)', doc '{ "foo": 1, "baz": [ { "qux": "hello" } ] }' patch '[ { "op": "move", "from": "\/foo", "path": "\/bar" } ]' : OK Testing '(null)', doc '{ "baz": [ { "qux": "hello" } ], "bar": 1 }' patch '[ { "op": "move", "from": "\/baz\/0\/qux", "path": "\/baz\/1" } ]' : OK Testing '(null)', doc '{ "baz": [ { "qux": "hello" } ], "bar": 1 }' patch '[ { "op": "copy", "from": "\/baz\/0", "path": "\/boo" } ]' : OK Testing 'replacing the root of the document is possible with add', doc '{ "foo": "bar" }' patch '[ { "op": "add", "path": "", "value": { "baz": "qux" } } ]' : OK Testing 'Adding to "/-" adds to the end of the array', doc '[ 1, 2 ]' patch '[ { "op": "add", "path": "\/-", "value": { "foo": [ "bar", "baz" ] } } ]' : OK Testing 'Adding to "/-" adds to the end of the array, even n levels down', doc '[ 1, 2, [ 3, [ 4, 5 ] ] ]' patch '[ { "op": "add", "path": "\/2\/1\/-", "value": { "foo": [ "bar", "baz" ] } } ]' : OK Testing 'test remove with bad number should fail', doc '{ "foo": 1, "baz": [ { "qux": "hello" } ] }' patch '[ { "op": "remove", "path": "\/baz\/1e0\/qux" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Invalid path field Testing 'test remove on array', doc '[ 1, 2, 3, 4 ]' patch '[ { "op": "remove", "path": "\/0" } ]' : OK Testing 'test repeated removes', doc '[ 1, 2, 3, 4 ]' patch '[ { "op": "remove", "path": "\/1" }, { "op": "remove", "path": "\/2" } ]' : OK Testing 'test remove with bad index should fail', doc '[ 1, 2, 3, 4 ]' patch '[ { "op": "remove", "path": "\/1e0" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Invalid path field Testing 'test replace with bad number should fail', doc '[ "" ]' patch '[ { "op": "replace", "path": "\/1e0", "value": false } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Invalid path field Testing 'test copy with bad number should fail', doc '{ "baz": [ 1, 2, 3 ], "bar": 1 }' patch '[ { "op": "copy", "from": "\/baz\/1e0", "path": "\/boo" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Invalid from field Testing 'test move with bad number should fail', doc '{ "foo": 1, "baz": [ 1, 2, 3, 4 ] }' patch '[ { "op": "move", "from": "\/baz\/1e0", "path": "\/foo" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Invalid from field Testing 'test add with bad number should fail', doc '[ "foo", "sil" ]' patch '[ { "op": "add", "path": "\/1e0", "value": "bar" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Failed to set value at path referenced by 'path' field Testing 'missing 'path' parameter', doc '{ }' patch '[ { "op": "add", "value": "bar" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Patch object does not contain 'path' field Testing ''path' parameter with null value', doc '{ }' patch '[ { "op": "add", "path": null, "value": "bar" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Failed to set value at path referenced by 'path' field Testing 'invalid JSON Pointer token', doc '{ }' patch '[ { "op": "add", "path": "foo", "value": "bar" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Failed to set value at path referenced by 'path' field Testing 'missing 'value' parameter to add', doc '[ 1 ]' patch '[ { "op": "add", "path": "\/-" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Patch object does not contain a 'value' field Testing 'missing 'value' parameter to replace', doc '[ 1 ]' patch '[ { "op": "replace", "path": "\/0" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Patch object does not contain a 'value' field Testing 'missing 'value' parameter to test', doc '[ null ]' patch '[ { "op": "test", "path": "\/0" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Patch object does not contain a 'value' field Testing 'missing value parameter to test - where undef is falsy', doc '[ false ]' patch '[ { "op": "test", "path": "\/0" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Patch object does not contain a 'value' field Testing 'missing from parameter to copy', doc '[ 1 ]' patch '[ { "op": "copy", "path": "\/-" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Patch does not contain a 'from' field Testing 'missing from location to copy', doc '{ "foo": 1 }' patch '[ { "op": "copy", "from": "\/bar", "path": "\/foo" } ]' : OK => json_patch_apply failed as expected: ERRNO=ENOENT at patch idx 0: Did not find element referenced by from field Testing 'missing from parameter to move', doc '{ "foo": 1 }' patch '[ { "op": "move", "path": "" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Patch does not contain a 'from' field Testing 'missing from location to move', doc '{ "foo": 1 }' patch '[ { "op": "move", "from": "\/bar", "path": "\/foo" } ]' : OK => json_patch_apply failed as expected: ERRNO=ENOENT at patch idx 0: Did not find element referenced by from field Testing 'duplicate ops, json-c parses this as op:move', doc '{ "foo": "bar" }' patch '[ { "op": "move", "path": "\/baz", "value": "qux", "from": "\/foo" } ]' : OK Testing 'unrecognized op should fail', doc '{ "foo": 1 }' patch '[ { "op": "spam", "path": "\/foo", "value": 1 } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Patch object has invalid 'op' field Testing 'test with bad array number that has leading zeros', doc '[ "foo", "bar" ]' patch '[ { "op": "test", "path": "\/00", "value": "foo" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Invalid path field Testing 'test with bad array number that has leading zeros', doc '[ "foo", "bar" ]' patch '[ { "op": "test", "path": "\/01", "value": "bar" } ]' : OK => json_patch_apply failed as expected: ERRNO=EINVAL at patch idx 0: Invalid path field Testing 'Removing nonexistent field', doc '{ "foo": "bar" }' patch '[ { "op": "remove", "path": "\/baz" } ]' : OK => json_patch_apply failed as expected: ERRNO=ENOENT at patch idx 0: Did not find element referenced by path field Testing 'Removing deep nonexistent path', doc '{ "foo": "bar" }' patch '[ { "op": "remove", "path": "\/missing1\/missing2" } ]' : OK => json_patch_apply failed as expected: ERRNO=ENOENT at patch idx 0: Did not find element referenced by path field Testing 'Removing nonexistent index', doc '[ "foo", "bar" ]' patch '[ { "op": "remove", "path": "\/2" } ]' : OK => json_patch_apply failed as expected: ERRNO=ENOENT at patch idx 0: Did not find element referenced by path field Testing 'Patch with different capitalisation than doc', doc '{ "foo": "bar" }' patch '[ { "op": "add", "path": "\/FOO", "value": "BAR" } ]' : OK json-c-json-c-0.17-20230812/tests/test_json_patch.test000077500000000000000000000004701446575330000221650ustar00rootroot00000000000000#!/bin/sh export _JSON_C_STRERROR_ENABLE=1 # Common definitions if test -z "$srcdir"; then srcdir="${0%/*}" test "$srcdir" = "$0" && srcdir=. test -z "$srcdir" && srcdir=. fi . "$srcdir/test-defs.sh" filename=$(basename "$0") filename="${filename%.*}" run_output_test $filename "$srcdir" exit $? json-c-json-c-0.17-20230812/tests/test_json_pointer.c000066400000000000000000000253041446575330000220110ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include #include "json.h" static void test_example_int(struct json_object *jo1, const char *json_pointer, int expected_int) { struct json_object *jo2 = NULL; assert(0 == json_pointer_get(jo1, json_pointer, NULL)); assert(0 == json_pointer_get(jo1, json_pointer, &jo2)); assert(json_object_is_type(jo2, json_type_int)); assert(expected_int == json_object_get_int(jo2)); printf("PASSED - GET - %s == %d\n", json_pointer, expected_int); } static const char *input_json_str = "{ " "'foo': ['bar', 'baz'], " "'': 0, " "'a/b': 1, " "'c%d': 2, " "'e^f': 3, " "'g|h': 4, " "'i\\\\j': 5, " "'k\\\"l': 6, " "' ': 7, " "'m~n': 8 " "}"; /* clang-format off */ static const char *rec_input_json_str = "{" "'arr' : [" "{" "'obj': [" "{},{}," "{" "'obj1': 0," "'obj2': \"1\"" "}" "]" "}" "]," "'obj' : {" "'obj': {" "'obj': [" "{" "'obj1': 0," "'obj2': \"1\"" "}" "]" "}" "}" "}"; /* clang-format on */ /* Example from RFC */ static void test_example_get(void) { int i; struct json_object *jo1, *jo2, *jo3; struct json_pointer_map_s_i { const char *s; int i; }; /* Create a map to iterate over for the ints */ /* clang-format off */ struct json_pointer_map_s_i json_pointers[] = { { "/", 0 }, { "/a~1b", 1 }, {"/c%d", 2 }, {"/e^f", 3 }, { "/g|h", 4 }, { "/i\\j", 5 }, { "/k\"l", 6 }, { "/ ", 7 }, { "/m~0n", 8 }, { NULL, 0} }; /* clang-format on */ jo1 = json_tokener_parse(input_json_str); assert(NULL != jo1); printf("PASSED - GET - LOADED TEST JSON\n"); printf("%s\n", json_object_get_string(jo1)); /* Test empty string returns entire object */ jo2 = NULL; /* For each test, we're trying to see that NULL **value works (does no segfault) */ assert(0 == json_pointer_get(jo1, "", NULL)); assert(0 == json_pointer_get(jo1, "", &jo2)); assert(json_object_equal(jo2, jo1)); printf("PASSED - GET - ENTIRE OBJECT WORKED\n"); /* Test /foo == ['bar', 'baz'] */ jo3 = json_object_new_array(); json_object_array_add(jo3, json_object_new_string("bar")); json_object_array_add(jo3, json_object_new_string("baz")); jo2 = NULL; assert(0 == json_pointer_get(jo1, "/foo", NULL)); assert(0 == json_pointer_get(jo1, "/foo", &jo2)); assert(NULL != jo2); assert(json_object_equal(jo2, jo3)); json_object_put(jo3); printf("PASSED - GET - /foo == ['bar', 'baz']\n"); /* Test /foo/0 == 'bar' */ jo2 = NULL; assert(0 == json_pointer_get(jo1, "/foo/0", NULL)); assert(0 == json_pointer_get(jo1, "/foo/0", &jo2)); assert(NULL != jo2); assert(0 == strcmp("bar", json_object_get_string(jo2))); printf("PASSED - GET - /foo/0 == 'bar'\n"); for (i = 0; json_pointers[i].s; i++) test_example_int(jo1, json_pointers[i].s, json_pointers[i].i); json_object_put(jo1); } /* I'm not too happy with the RFC example to test the recursion of the json_pointer_get() function */ static void test_recursion_get(void) { struct json_object *jo2, *jo1 = json_tokener_parse(rec_input_json_str); jo2 = NULL; assert(jo1 != NULL); printf("%s\n", json_object_get_string(jo1)); assert(0 == json_pointer_get(jo1, "/arr/0/obj/2/obj1", &jo2)); assert(json_object_is_type(jo2, json_type_int)); assert(0 == json_object_get_int(jo2)); assert(0 == json_pointer_get(jo1, "/arr/0/obj/2/obj2", &jo2)); assert(json_object_is_type(jo2, json_type_string)); assert(0 == strcmp("1", json_object_get_string(jo2))); assert(0 == json_pointer_getf(jo1, &jo2, "/%s/%d/%s/%d/%s", "arr", 0, "obj", 2, "obj2")); assert(json_object_is_type(jo2, json_type_string)); assert(0 == strcmp("1", json_object_get_string(jo2))); assert(jo1 != NULL); assert(0 == json_pointer_get(jo1, "/obj/obj/obj/0/obj1", &jo2)); assert(json_object_is_type(jo2, json_type_int)); assert(0 == json_object_get_int(jo2)); assert(0 == json_pointer_get(jo1, "/obj/obj/obj/0/obj2", &jo2)); assert(json_object_is_type(jo2, json_type_string)); assert(0 == strcmp("1", json_object_get_string(jo2))); assert(0 == json_pointer_getf(jo1, &jo2, "%s", "\0")); printf("PASSED - GET - RECURSION TEST\n"); json_object_put(jo1); } static void test_wrong_inputs_get(void) { struct json_object *jo2, *jo1 = json_tokener_parse(input_json_str); assert(NULL != jo1); printf("PASSED - GET - LOADED TEST JSON\n"); printf("%s\n", json_object_get_string(jo1)); /* Test leading '/' missing */ jo2 = NULL; errno = 0; assert(0 != json_pointer_get(jo1, "foo/bar", NULL)); assert(0 != json_pointer_get(jo1, "foo/bar", &jo2)); assert(errno == EINVAL); assert(jo2 == NULL); printf("PASSED - GET - MISSING /\n"); /* Test combinations of NULL params for input json & path */ errno = 0; assert(0 != json_pointer_get(NULL, "foo/bar", NULL)); assert(errno == EINVAL); errno = 0; assert(0 != json_pointer_get(NULL, NULL, NULL)); assert(errno == EINVAL); errno = 0; assert(0 != json_pointer_getf(NULL, NULL, NULL)); assert(errno == EINVAL); errno = 0; assert(0 != json_pointer_get(jo1, NULL, NULL)); assert(errno == EINVAL); errno = 0; assert(0 != json_pointer_getf(jo1, NULL, NULL)); assert(errno == EINVAL); printf("PASSED - GET - NULL INPUTS\n"); /* Test invalid indexes for array */ errno = 0; assert(0 != json_pointer_get(jo1, "/foo/a", NULL)); assert(errno == EINVAL); errno = 0; assert(0 != json_pointer_get(jo1, "/foo/01", NULL)); assert(errno == EINVAL); errno = 0; assert(0 != json_pointer_getf(jo1, NULL, "/%s/a", "foo")); assert(errno == EINVAL); errno = 0; assert(0 != json_pointer_get(jo1, "/foo/-", NULL)); assert(errno == EINVAL); errno = 0; /* Test optimized array path */ assert(0 != json_pointer_get(jo1, "/foo/4", NULL)); assert(errno == ENOENT); errno = 0; /* Test non-optimized array path */ assert(0 != json_pointer_getf(jo1, NULL, "%s", "/foo/22")); assert(errno == ENOENT); errno = 0; assert(0 != json_pointer_getf(jo1, NULL, "/%s/%d", "foo", 22)); assert(errno == ENOENT); errno = 0; assert(0 != json_pointer_get(jo1, "/foo/-1", NULL)); assert(errno == EINVAL); errno = 0; assert(0 != json_pointer_get(jo1, "/foo/10", NULL)); assert(errno == ENOENT); printf("PASSED - GET - INVALID INDEXES\n"); json_object_put(jo1); } static void test_example_set(void) { struct json_object *jo2, *jo1 = json_tokener_parse(input_json_str); assert(jo1 != NULL); printf("PASSED - SET - LOADED TEST JSON\n"); printf("%s\n", json_object_get_string(jo1)); assert(0 == json_pointer_set(&jo1, "/foo/1", json_object_new_string("cod"))); assert(0 == strcmp("cod", json_object_get_string(json_object_array_get_idx( json_object_object_get(jo1, "foo"), 1)))); printf("PASSED - SET - 'cod' in /foo/1\n"); assert(0 != json_pointer_set(&jo1, "/fud/gaw", (jo2 = json_tokener_parse("[1,2,3]")))); assert(errno == ENOENT); printf("PASSED - SET - non-existing /fud/gaw\n"); assert(0 == json_pointer_set(&jo1, "/fud", json_object_new_object())); printf("PASSED - SET - /fud == {}\n"); assert(0 == json_pointer_set(&jo1, "/fud/gaw", jo2)); /* re-using jo2 from above */ printf("PASSED - SET - /fug/gaw == [1,2,3]\n"); assert(0 == json_pointer_set(&jo1, "/fud/gaw/0", json_object_new_int(0))); assert(0 == json_pointer_setf(&jo1, json_object_new_int(0), "%s%s/%d", "/fud", "/gaw", 0)); printf("PASSED - SET - /fug/gaw == [0,2,3]\n"); assert(0 == json_pointer_set(&jo1, "/fud/gaw/-", json_object_new_int(4))); printf("PASSED - SET - /fug/gaw == [0,2,3,4]\n"); assert(0 == json_pointer_set(&jo1, "/", json_object_new_int(9))); printf("PASSED - SET - / == 9\n"); jo2 = json_tokener_parse( "{ 'foo': [ 'bar', 'cod' ], '': 9, 'a/b': 1, 'c%d': 2, 'e^f': 3, 'g|h': 4, 'i\\\\j': " "5, 'k\\\"l': 6, ' ': 7, 'm~n': 8, 'fud': { 'gaw': [ 0, 2, 3, 4 ] } }"); assert(json_object_equal(jo2, jo1)); printf("PASSED - SET - Final JSON is: %s\n", json_object_get_string(jo1)); json_object_put(jo2); assert(0 == json_pointer_set(&jo1, "", json_object_new_int(10))); assert(10 == json_object_get_int(jo1)); printf("%s\n", json_object_get_string(jo1)); json_object_put(jo1); jo1 = json_tokener_parse("[0, 1, 2, 3]"); jo2 = json_tokener_parse("[0, 1, 2, 3, null, null, null, 7]"); assert(0 == json_pointer_set(&jo1, "/7", json_object_new_int(7))); assert(1 == json_object_equal(jo1, jo2)); json_object_put(jo1); jo1 = json_tokener_parse("[0, 1, 2, 3]"); assert(0 == json_pointer_setf(&jo1, json_object_new_int(7), "/%u", 7)); assert(1 == json_object_equal(jo1, jo2)); json_object_put(jo1); json_object_put(jo2); } static void test_wrong_inputs_set(void) { struct json_object *jo2, *jo1 = json_tokener_parse(input_json_str); assert(jo1 != NULL); printf("PASSED - SET - LOADED TEST JSON\n"); printf("%s\n", json_object_get_string(jo1)); assert(0 != json_pointer_set(NULL, NULL, NULL)); assert(0 != json_pointer_setf(NULL, NULL, NULL)); assert(0 != json_pointer_set(&jo1, NULL, NULL)); assert(0 != json_pointer_setf(&jo1, NULL, NULL)); printf("PASSED - SET - failed with NULL params for input json & path\n"); assert(0 != json_pointer_set(&jo1, "foo/bar", (jo2 = json_object_new_string("cod")))); printf("PASSED - SET - failed 'cod' with path 'foo/bar'\n"); json_object_put(jo2); assert(0 != json_pointer_setf(&jo1, (jo2 = json_object_new_string("cod")), "%s", "foo/bar")); printf("PASSED - SET - failed 'cod' with path 'foo/bar'\n"); json_object_put(jo2); assert(0 != json_pointer_set(&jo1, "0", (jo2 = json_object_new_string("cod")))); printf("PASSED - SET - failed with invalid array index'\n"); json_object_put(jo2); jo2 = json_object_new_string("whatever"); assert(0 != json_pointer_set(&jo1, "/fud/gaw", jo2)); assert(0 == json_pointer_set(&jo1, "/fud", json_object_new_object())); assert(0 == json_pointer_set(&jo1, "/fud/gaw", jo2)); /* re-using jo2 from above */ // ownership of jo2 transferred into jo1 jo2 = json_object_new_int(0); assert(0 != json_pointer_set(&jo1, "/fud/gaw/0", jo2)); json_object_put(jo2); jo2 = json_object_new_int(0); assert(0 != json_pointer_set(&jo1, "/fud/gaw/", jo2)); json_object_put(jo2); printf("PASSED - SET - failed to set index to non-array\n"); assert(0 == json_pointer_setf(&jo1, json_object_new_string("cod"), "%s", "\0")); json_object_put(jo1); } int main(int argc, char **argv) { test_example_get(); test_recursion_get(); test_wrong_inputs_get(); test_example_set(); test_wrong_inputs_set(); return 0; } json-c-json-c-0.17-20230812/tests/test_json_pointer.expected000066400000000000000000000034441446575330000233710ustar00rootroot00000000000000PASSED - GET - LOADED TEST JSON { "foo": [ "bar", "baz" ], "": 0, "a\/b": 1, "c%d": 2, "e^f": 3, "g|h": 4, "i\\j": 5, "k\"l": 6, " ": 7, "m~n": 8 } PASSED - GET - ENTIRE OBJECT WORKED PASSED - GET - /foo == ['bar', 'baz'] PASSED - GET - /foo/0 == 'bar' PASSED - GET - / == 0 PASSED - GET - /a~1b == 1 PASSED - GET - /c%d == 2 PASSED - GET - /e^f == 3 PASSED - GET - /g|h == 4 PASSED - GET - /i\j == 5 PASSED - GET - /k"l == 6 PASSED - GET - / == 7 PASSED - GET - /m~0n == 8 { "arr": [ { "obj": [ { }, { }, { "obj1": 0, "obj2": "1" } ] } ], "obj": { "obj": { "obj": [ { "obj1": 0, "obj2": "1" } ] } } } PASSED - GET - RECURSION TEST PASSED - GET - LOADED TEST JSON { "foo": [ "bar", "baz" ], "": 0, "a\/b": 1, "c%d": 2, "e^f": 3, "g|h": 4, "i\\j": 5, "k\"l": 6, " ": 7, "m~n": 8 } PASSED - GET - MISSING / PASSED - GET - NULL INPUTS PASSED - GET - INVALID INDEXES PASSED - SET - LOADED TEST JSON { "foo": [ "bar", "baz" ], "": 0, "a\/b": 1, "c%d": 2, "e^f": 3, "g|h": 4, "i\\j": 5, "k\"l": 6, " ": 7, "m~n": 8 } PASSED - SET - 'cod' in /foo/1 PASSED - SET - non-existing /fud/gaw PASSED - SET - /fud == {} PASSED - SET - /fug/gaw == [1,2,3] PASSED - SET - /fug/gaw == [0,2,3] PASSED - SET - /fug/gaw == [0,2,3,4] PASSED - SET - / == 9 PASSED - SET - Final JSON is: { "foo": [ "bar", "cod" ], "": 9, "a\/b": 1, "c%d": 2, "e^f": 3, "g|h": 4, "i\\j": 5, "k\"l": 6, " ": 7, "m~n": 8, "fud": { "gaw": [ 0, 2, 3, 4 ] } } 10 PASSED - SET - LOADED TEST JSON { "foo": [ "bar", "baz" ], "": 0, "a\/b": 1, "c%d": 2, "e^f": 3, "g|h": 4, "i\\j": 5, "k\"l": 6, " ": 7, "m~n": 8 } PASSED - SET - failed with NULL params for input json & path PASSED - SET - failed 'cod' with path 'foo/bar' PASSED - SET - failed 'cod' with path 'foo/bar' PASSED - SET - failed with invalid array index' PASSED - SET - failed to set index to non-array json-c-json-c-0.17-20230812/tests/test_json_pointer.test000077700000000000000000000000001446575330000255562test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_locale.c000066400000000000000000000030701446575330000205330ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include #include #include "config.h" #include "json.h" #include "json_tokener.h" #include "snprintf_compat.h" #ifdef HAVE_LOCALE_H #include #endif /* HAVE_LOCALE_H */ #ifdef HAVE_XLOCALE_H #include #endif int main(int argc, char **argv) { json_object *new_obj; #ifdef HAVE_SETLOCALE setlocale(LC_NUMERIC, "de_DE"); #endif char buf1[10], buf2[10]; // Should result in "0,1", if the locale is installed. // Regardless of what it generates, we check that it's // consistent below. (void)snprintf(buf1, sizeof(buf1), "%f", 0.1); MC_SET_DEBUG(1); new_obj = json_tokener_parse("[1.2,3.4,123456.78,5.0,2.3e10]"); (void)snprintf(buf2, sizeof(buf2), "%f", 0.1); if (strcmp(buf1, buf2) != 0) printf("ERROR: Original locale not restored \"%s\" != \"%s\"", buf1, buf2); #ifdef HAVE_SETLOCALE setlocale(LC_NUMERIC, "C"); #endif // Explicitly print each value, to avoid having the "special" // serialization done for parsed doubles simply re-emit the original // string that was parsed. (see json_object_new_double_s()) printf("new_obj.to_string()=["); unsigned int ii; for (ii = 0; ii < json_object_array_length(new_obj); ii++) { json_object *val = json_object_array_get_idx(new_obj, ii); printf("%s%.2lf", (ii > 0) ? "," : "", json_object_get_double(val)); } printf("]\n"); printf("new_obj.to_string()=%s\n", json_object_to_json_string_ext(new_obj, JSON_C_TO_STRING_NOZERO)); json_object_put(new_obj); return 0; } json-c-json-c-0.17-20230812/tests/test_locale.expected000066400000000000000000000001611446575330000221100ustar00rootroot00000000000000new_obj.to_string()=[1.20,3.40,123456.78,5.00,23000000000.00] new_obj.to_string()=[1.2,3.4,123456.78,5.0,2.3e10] json-c-json-c-0.17-20230812/tests/test_locale.test000077700000000000000000000000001446575330000243042test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_null.c000066400000000000000000000025711446575330000202530ustar00rootroot00000000000000/* * Tests if binary strings are supported. */ #ifdef NDEBUG #undef NDEBUG #endif #include "config.h" #include #include #include "json_inttypes.h" #include "json_object.h" #include "json_tokener.h" int main(void) { /* this test has a space after the null character. check that it's still included */ const char *input = " \0 "; const char *expected = "\" \\u0000 \""; struct json_object *string = json_object_new_string_len(input, 3); const char *json = json_object_to_json_string(string); int strings_match = !strcmp(expected, json); int retval = 0; if (strings_match) { printf("JSON write result is correct: %s\n", json); puts("PASS"); } else { puts("JSON write result doesn't match expected string"); printf("expected string: "); puts(expected); printf("parsed string: "); puts(json); puts("FAIL"); retval = 1; } json_object_put(string); struct json_object *parsed_str = json_tokener_parse(expected); if (parsed_str) { int parsed_len = json_object_get_string_len(parsed_str); const char *parsed_cstr = json_object_get_string(parsed_str); int ii; printf("Re-parsed object string len=%d, chars=[", parsed_len); for (ii = 0; ii < parsed_len; ii++) { printf("%s%d", (ii ? ", " : ""), (int)parsed_cstr[ii]); } puts("]"); json_object_put(parsed_str); } else { puts("ERROR: failed to parse"); } return retval; } json-c-json-c-0.17-20230812/tests/test_null.expected000066400000000000000000000001371446575330000216260ustar00rootroot00000000000000JSON write result is correct: " \u0000 " PASS Re-parsed object string len=3, chars=[32, 0, 32] json-c-json-c-0.17-20230812/tests/test_null.test000077700000000000000000000000001446575330000240172test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_object_iterator.c000066400000000000000000000017431446575330000224600ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include "config.h" #include #include #include #include "json_object.h" #include "json_object_iterator.h" #include "json_tokener.h" int main(int atgc, char **argv) { const char *input = "{\n\ \"string_of_digits\": \"123\",\n\ \"regular_number\": 222,\n\ \"decimal_number\": 99.55,\n\ \"boolean_true\": true,\n\ \"boolean_false\": false,\n\ \"big_number\": 2147483649,\n\ \"a_null\": null,\n\ }"; struct json_object *new_obj; struct json_object_iterator it; struct json_object_iterator itEnd; it = json_object_iter_init_default(); new_obj = json_tokener_parse(input); it = json_object_iter_begin(new_obj); itEnd = json_object_iter_end(new_obj); while (!json_object_iter_equal(&it, &itEnd)) { printf("%s\n", json_object_iter_peek_name(&it)); printf("%s\n", json_object_to_json_string(json_object_iter_peek_value(&it))); json_object_iter_next(&it); } json_object_put(new_obj); return 0; } json-c-json-c-0.17-20230812/tests/test_object_iterator.expected000066400000000000000000000002071446575330000240310ustar00rootroot00000000000000string_of_digits "123" regular_number 222 decimal_number 99.55 boolean_true true boolean_false false big_number 2147483649 a_null null json-c-json-c-0.17-20230812/tests/test_object_iterator.test000077700000000000000000000000001446575330000262242test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_parse.c000066400000000000000000000660661446575330000204240ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include #include #include "json.h" #include "json_tokener.h" #include "json_visit.h" static void test_basic_parse(void); static void test_utf8_parse(void); static void test_verbose_parse(void); static void test_incremental_parse(void); int main(void) { MC_SET_DEBUG(1); static const char separator[] = "=================================="; test_basic_parse(); puts(separator); test_utf8_parse(); puts(separator); test_verbose_parse(); puts(separator); test_incremental_parse(); puts(separator); return 0; } static json_c_visit_userfunc clear_serializer; static void do_clear_serializer(json_object *jso); static void single_incremental_parse(const char *test_string, int clear_serializer) { size_t ii; int chunksize = atoi(getenv("TEST_PARSE_CHUNKSIZE")); struct json_tokener *tok; enum json_tokener_error jerr; json_object *all_at_once_obj, *new_obj; const char *all_at_once_str, *new_str; new_obj = NULL; assert(chunksize > 0); all_at_once_obj = json_tokener_parse(test_string); if (clear_serializer) do_clear_serializer(all_at_once_obj); all_at_once_str = json_object_to_json_string(all_at_once_obj); tok = json_tokener_new(); size_t test_string_len = strlen(test_string) + 1; // Including '\0' ! for (ii = 0; ii < test_string_len; ii += chunksize) { int len_to_parse = chunksize; if (ii + chunksize > test_string_len) len_to_parse = test_string_len - ii; if (getenv("TEST_PARSE_DEBUG") != NULL) printf(" chunk: %.*s\n", len_to_parse, &test_string[ii]); new_obj = json_tokener_parse_ex(tok, &test_string[ii], len_to_parse); jerr = json_tokener_get_error(tok); if (jerr != json_tokener_continue || new_obj) break; } if (clear_serializer && new_obj) do_clear_serializer(new_obj); new_str = json_object_to_json_string(new_obj); if (strcmp(all_at_once_str, new_str) != 0) { printf("ERROR: failed to parse (%s) in %d byte chunks: %s != %s\n", test_string, chunksize, all_at_once_str, new_str); } json_tokener_free(tok); if (all_at_once_obj) json_object_put(all_at_once_obj); if (new_obj) json_object_put(new_obj); } static void single_basic_parse(const char *test_string, int clear_serializer) { json_object *new_obj; new_obj = json_tokener_parse(test_string); if (clear_serializer) do_clear_serializer(new_obj); printf("new_obj.to_string(%s)=%s\n", test_string, json_object_to_json_string(new_obj)); json_object_put(new_obj); if (getenv("TEST_PARSE_CHUNKSIZE") != NULL) single_incremental_parse(test_string, clear_serializer); } static void test_basic_parse(void) { single_basic_parse("\"\003\"", 0); single_basic_parse("/* hello */\"foo\"", 0); single_basic_parse("// hello\n\"foo\"", 0); single_basic_parse("\"foo\"blue", 0); single_basic_parse("\'foo\'", 0); single_basic_parse("\"\\u0041\\u0042\\u0043\"", 0); single_basic_parse("\"\\u4e16\\u754c\\u00df\"", 0); single_basic_parse("\"\\u4E16\"", 0); single_basic_parse("\"\\u4e1\"", 0); single_basic_parse("\"\\u4e1@\"", 0); single_basic_parse("\"\\ud840\\u4e16\"", 0); single_basic_parse("\"\\ud840\"", 0); single_basic_parse("\"\\udd27\"", 0); // Test with a "short" high surrogate single_basic_parse("[9,'\\uDAD", 0); single_basic_parse("null", 0); single_basic_parse("NaN", 0); single_basic_parse("-NaN", 0); /* non-sensical, returns null */ single_basic_parse("Inf", 0); /* must use full string, returns null */ single_basic_parse("inf", 0); /* must use full string, returns null */ single_basic_parse("Infinity", 0); single_basic_parse("infinity", 0); single_basic_parse("-Infinity", 0); single_basic_parse("-infinity", 0); single_basic_parse("{ \"min\": Infinity, \"max\": -Infinity}", 0); single_basic_parse("Infinity!", 0); single_basic_parse("Infinitynull", 0); single_basic_parse("InfinityXXXX", 0); single_basic_parse("-Infinitynull", 0); single_basic_parse("-InfinityXXXX", 0); single_basic_parse("Infinoodle", 0); single_basic_parse("InfinAAA", 0); single_basic_parse("-Infinoodle", 0); single_basic_parse("-InfinAAA", 0); single_basic_parse("True", 0); single_basic_parse("False", 0); /* not case sensitive */ single_basic_parse("tRue", 0); single_basic_parse("fAlse", 0); single_basic_parse("nAn", 0); single_basic_parse("iNfinity", 0); single_basic_parse("12", 0); single_basic_parse("12.3", 0); /* Even though, when using json_tokener_parse() there's no way to * know when there is more data after the parsed object, * an object is successfully returned anyway (in some cases) */ single_basic_parse("12.3.4", 0); single_basic_parse("2015-01-15", 0); single_basic_parse("12.3xxx", 0); single_basic_parse("12.3{\"a\":123}", 0); single_basic_parse("12.3\n", 0); single_basic_parse("12.3 ", 0); single_basic_parse("{\"FoO\" : -12.3E512}", 0); single_basic_parse("{\"FoO\" : -12.3e512}", 0); single_basic_parse("{\"FoO\" : -12.3E51.2}", 0); /* non-sensical, returns null */ single_basic_parse("{\"FoO\" : -12.3E512E12}", 0); /* non-sensical, returns null */ single_basic_parse("[\"\\n\"]", 0); single_basic_parse("[\"\\nabc\\n\"]", 0); single_basic_parse("[null]", 0); single_basic_parse("[]", 0); single_basic_parse("[false]", 0); single_basic_parse("[\"abc\",null,\"def\",12]", 0); single_basic_parse("{}", 0); single_basic_parse("{ \"foo\": \"bar\" }", 0); single_basic_parse("{ \'foo\': \'bar\' }", 0); single_basic_parse("{ \"foo\": \"bar\", \"baz\": null, \"bool0\": true }", 0); single_basic_parse("{ \"foo\": [null, \"foo\"] }", 0); single_basic_parse("{ \"abc\": 12, \"foo\": \"bar\", \"bool0\": false, \"bool1\": true, " "\"arr\": [ 1, 2, 3, null, 5 ] }", 0); single_basic_parse("{ \"abc\": \"blue\nred\\ngreen\" }", 0); // Clear serializer for these tests so we see the actual parsed value. single_basic_parse("null", 1); single_basic_parse("false", 1); single_basic_parse("[0e]", 1); single_basic_parse("[0e+]", 1); single_basic_parse("[0e+-1]", 1); single_basic_parse("\"hello world!\"", 1); // uint64/int64 range test single_basic_parse("[9223372036854775806]", 1); single_basic_parse("[9223372036854775807]", 1); single_basic_parse("[9223372036854775808]", 1); single_basic_parse("[-9223372036854775807]", 1); single_basic_parse("[-9223372036854775808]", 1); single_basic_parse("[-9223372036854775809]", 1); single_basic_parse("[18446744073709551614]", 1); single_basic_parse("[18446744073709551615]", 1); single_basic_parse("[18446744073709551616]", 1); } static void test_utf8_parse(void) { // json_tokener_parse doesn't support checking for byte order marks. // It's the responsibility of the caller to detect and skip a BOM. // Both of these checks return null. const char *utf8_bom = "\xEF\xBB\xBF"; const char *utf8_bom_and_chars = "\xEF\xBB\xBF{}"; single_basic_parse(utf8_bom, 0); single_basic_parse(utf8_bom_and_chars, 0); } // Clear the re-serialization information that the tokener // saves to ensure that the output reflects the actual // values we parsed, rather than just the original input. static void do_clear_serializer(json_object *jso) { json_c_visit(jso, 0, clear_serializer, NULL); } static int clear_serializer(json_object *jso, int flags, json_object *parent_jso, const char *jso_key, size_t *jso_index, void *userarg) { if (jso) json_object_set_serializer(jso, NULL, NULL, NULL); return JSON_C_VISIT_RETURN_CONTINUE; } static void test_verbose_parse(void) { json_object *new_obj; enum json_tokener_error error = json_tokener_success; new_obj = json_tokener_parse_verbose("{ foo }", &error); assert(error == json_tokener_error_parse_object_key_name); assert(new_obj == NULL); new_obj = json_tokener_parse("{ foo }"); assert(new_obj == NULL); new_obj = json_tokener_parse("foo"); assert(new_obj == NULL); new_obj = json_tokener_parse_verbose("foo", &error); assert(new_obj == NULL); /* b/c the string starts with 'f' parsing return a boolean error */ assert(error == json_tokener_error_parse_boolean); puts("json_tokener_parse_verbose() OK"); } struct incremental_step { const char *string_to_parse; int length; int char_offset; enum json_tokener_error expected_error; int reset_tokener; /* Set to 1 to call json_tokener_reset() after parsing */ int tok_flags; /* JSON_TOKENER_* flags to pass to json_tokener_set_flags() */ } incremental_steps[] = { /* Check that full json messages can be parsed, both w/ and w/o a reset */ {"{ \"foo\": 123 }", -1, -1, json_tokener_success, 0, 0}, {"{ \"foo\": 456 }", -1, -1, json_tokener_success, 1, 0}, {"{ \"foo\": 789 }", -1, -1, json_tokener_success, 1, 0}, /* Check the comment parse*/ {"/* hello */{ \"foo\"", -1, -1, json_tokener_continue, 0, 0}, {"/* hello */:/* hello */", -1, -1, json_tokener_continue, 0, 0}, {"\"bar\"/* hello */", -1, -1, json_tokener_continue, 0, 0}, {"}/* hello */", -1, -1, json_tokener_success, 1, 0}, {"/ hello ", -1, 1, json_tokener_error_parse_comment, 1, 0}, {"/* hello\"foo\"", -1, -1, json_tokener_continue, 1, 0}, {"/* hello*\"foo\"", -1, -1, json_tokener_continue, 1, 0}, {"// hello\"foo\"", -1, -1, json_tokener_continue, 1, 0}, /* Check a basic incremental parse */ {"{ \"foo", -1, -1, json_tokener_continue, 0, 0}, {"\": {\"bar", -1, -1, json_tokener_continue, 0, 0}, {"\":13}}", -1, -1, json_tokener_success, 1, 0}, /* Check the UTF-16 surrogate pair handling in various ways. * Note: \ud843\udd1e is u+1D11E, Musical Symbol G Clef * Your terminal may not display these correctly, in particular * PuTTY doesn't currently show this character. */ /* parse one char at every time */ {"\"\\", -1, -1, json_tokener_continue, 0, 0}, {"u", -1, -1, json_tokener_continue, 0, 0}, {"d", -1, -1, json_tokener_continue, 0, 0}, {"8", -1, -1, json_tokener_continue, 0, 0}, {"3", -1, -1, json_tokener_continue, 0, 0}, {"4", -1, -1, json_tokener_continue, 0, 0}, {"\\", -1, -1, json_tokener_continue, 0, 0}, {"u", -1, -1, json_tokener_continue, 0, 0}, {"d", -1, -1, json_tokener_continue, 0, 0}, {"d", -1, -1, json_tokener_continue, 0, 0}, {"1", -1, -1, json_tokener_continue, 0, 0}, {"e\"", -1, -1, json_tokener_success, 1, 0}, /* parse two char at every time */ {"\"\\u", -1, -1, json_tokener_continue, 0, 0}, {"d8", -1, -1, json_tokener_continue, 0, 0}, {"34", -1, -1, json_tokener_continue, 0, 0}, {"\\u", -1, -1, json_tokener_continue, 0, 0}, {"dd", -1, -1, json_tokener_continue, 0, 0}, {"1e\"", -1, -1, json_tokener_success, 1, 0}, /* check the low surrogate pair */ {"\"\\ud834", -1, -1, json_tokener_continue, 0, 0}, {"\\udd1e\"", -1, -1, json_tokener_success, 1, 0}, {"\"\\ud834\\", -1, -1, json_tokener_continue, 0, 0}, {"udd1e\"", -1, -1, json_tokener_success, 1, 0}, {"\"\\ud834\\u", -1, -1, json_tokener_continue, 0, 0}, {"dd1e\"", -1, -1, json_tokener_success, 1, 0}, {"\"fff \\ud834\\ud", -1, -1, json_tokener_continue, 0, 0}, {"d1e bar\"", -1, -1, json_tokener_success, 1, 0}, {"\"fff \\ud834\\udd", -1, -1, json_tokener_continue, 0, 0}, {"1e bar\"", -1, -1, json_tokener_success, 1, 0}, /* \ud83d\ude00 is U+1F600, Grinning Face * Displays fine in PuTTY, though you may need "less -r" */ {"\"fff \\ud83d\\ude", -1, -1, json_tokener_continue, 0, 0}, {"00 bar\"", -1, -1, json_tokener_success, 1, 0}, /* Check that json_tokener_reset actually resets */ {"{ \"foo", -1, -1, json_tokener_continue, 1, 0}, {": \"bar\"}", -1, 0, json_tokener_error_parse_unexpected, 1, 0}, /* Check incremental parsing with trailing characters */ {"{ \"foo", -1, -1, json_tokener_continue, 0, 0}, {"\": {\"bar", -1, -1, json_tokener_continue, 0, 0}, {"\":13}}XXXX", 10, 6, json_tokener_success, 0, 0}, {"XXXX", 4, 0, json_tokener_error_parse_unexpected, 1, 0}, /* Check that trailing characters can change w/o a reset */ {"{\"x\": 123 }\"X\"", -1, 11, json_tokener_success, 0, 0}, {"\"Y\"", -1, -1, json_tokener_success, 1, 0}, /* Trailing characters should cause a failure in strict mode */ {"{\"foo\":9}{\"bar\":8}", -1, 9, json_tokener_error_parse_unexpected, 1, JSON_TOKENER_STRICT}, /* ... unless explicitly allowed. */ {"{\"foo\":9}{\"bar\":8}", -1, 9, json_tokener_success, 0, JSON_TOKENER_STRICT | JSON_TOKENER_ALLOW_TRAILING_CHARS}, {"{\"b\":8}ignored garbage", -1, 7, json_tokener_success, 1, JSON_TOKENER_STRICT | JSON_TOKENER_ALLOW_TRAILING_CHARS}, /* To stop parsing a number we need to reach a non-digit, e.g. a \0 */ {"1", 1, 1, json_tokener_continue, 0, 0}, /* This should parse as the number 12, since it continues the "1" */ {"2", 2, 1, json_tokener_success, 0, 0}, {"12{", 3, 2, json_tokener_success, 1, 0}, /* Parse number in strict mode */ {"[02]", -1, 3, json_tokener_error_parse_number, 1, JSON_TOKENER_STRICT}, {"0e+0", 5, 4, json_tokener_success, 1, 0}, {"[0e+0]", -1, -1, json_tokener_success, 1, 0}, /* The behavior when missing the exponent varies slightly */ {"0e", 2, 2, json_tokener_continue, 1, 0}, {"0e", 3, 2, json_tokener_success, 1, 0}, {"0e", 3, 2, json_tokener_error_parse_eof, 1, JSON_TOKENER_STRICT}, {"[0e]", -1, -1, json_tokener_success, 1, 0}, {"[0e]", -1, 3, json_tokener_error_parse_number, 1, JSON_TOKENER_STRICT}, {"0e+", 3, 3, json_tokener_continue, 1, 0}, {"0e+", 4, 3, json_tokener_success, 1, 0}, {"0e+", 4, 3, json_tokener_error_parse_eof, 1, JSON_TOKENER_STRICT}, {"[0e+]", -1, -1, json_tokener_success, 1, 0}, {"[0e+]", -1, 4, json_tokener_error_parse_number, 1, JSON_TOKENER_STRICT}, {"0e-", 3, 3, json_tokener_continue, 1, 0}, {"0e-", 4, 3, json_tokener_success, 1, 0}, {"0e-", 4, 3, json_tokener_error_parse_eof, 1, JSON_TOKENER_STRICT}, {"[0e-]", -1, -1, json_tokener_success, 1, 0}, {"[0e-]", -1, 4, json_tokener_error_parse_number, 1, JSON_TOKENER_STRICT}, /* You might expect this to fail, but it won't because it's a valid partial parse; note the char_offset: */ {"0e+-", 5, 3, json_tokener_success, 1, 0}, {"0e+-", 5, 3, json_tokener_error_parse_number, 1, JSON_TOKENER_STRICT}, {"[0e+-]", -1, 4, json_tokener_error_parse_number, 1, 0}, /* Similar tests for other kinds of objects: */ /* These could all return success immediately, since regardless of what follows the false/true/null token we *will* return a json object, but it currently doesn't work that way. hmm... */ {"false", 5, 5, json_tokener_continue, 1, 0}, {"false", 6, 5, json_tokener_success, 1, 0}, {"true", 4, 4, json_tokener_continue, 1, 0}, {"true", 5, 4, json_tokener_success, 1, 0}, {"null", 4, 4, json_tokener_continue, 1, 0}, {"null", 5, 4, json_tokener_success, 1, 0}, {"Infinity", 9, 8, json_tokener_success, 1, 0}, {"infinity", 9, 8, json_tokener_success, 1, 0}, {"-infinity", 10, 9, json_tokener_success, 1, 0}, {"infinity", 9, 0, json_tokener_error_parse_unexpected, 1, JSON_TOKENER_STRICT}, {"-infinity", 10, 1, json_tokener_error_parse_unexpected, 1, JSON_TOKENER_STRICT}, {"inf", 3, 3, json_tokener_continue, 0, 0}, {"inity", 6, 5, json_tokener_success, 1, 0}, {"-inf", 4, 4, json_tokener_continue, 0, 0}, {"inity", 6, 5, json_tokener_success, 1, 0}, {"i", 1, 1, json_tokener_continue, 0, 0}, {"n", 1, 1, json_tokener_continue, 0, 0}, {"f", 1, 1, json_tokener_continue, 0, 0}, {"i", 1, 1, json_tokener_continue, 0, 0}, {"n", 1, 1, json_tokener_continue, 0, 0}, {"i", 1, 1, json_tokener_continue, 0, 0}, {"t", 1, 1, json_tokener_continue, 0, 0}, {"y", 1, 1, json_tokener_continue, 0, 0}, {"", 1, 0, json_tokener_success, 1, 0}, {"-", 1, 1, json_tokener_continue, 0, 0}, {"inf", 3, 3, json_tokener_continue, 0, 0}, {"ini", 3, 3, json_tokener_continue, 0, 0}, {"ty", 3, 2, json_tokener_success, 1, 0}, {"-", 1, 1, json_tokener_continue, 0, 0}, {"i", 1, 1, json_tokener_continue, 0, 0}, {"nfini", 5, 5, json_tokener_continue, 0, 0}, {"ty", 3, 2, json_tokener_success, 1, 0}, {"-i", 2, 2, json_tokener_continue, 0, 0}, {"nfinity", 8, 7, json_tokener_success, 1, 0}, {"InfinityX", 10, 8, json_tokener_success, 0, 0}, {"X", 1, 0, json_tokener_error_parse_unexpected, 1, 0}, {"Infinity1234", 13, 8, json_tokener_success, 0, 0}, {"1234", 5, 4, json_tokener_success, 1, 0}, {"Infinity9999", 8, 8, json_tokener_continue, 0, 0}, /* returns the Infinity loaded up by the previous call: */ {"1234", 5, 0, json_tokener_success, 0, 0}, {"1234", 5, 4, json_tokener_success, 1, 0}, /* INT64_MAX */ {"[9223372036854775807]", 22, 21, json_tokener_success, 1, 0}, /* INT64_MAX+1 => parsed as uint64 */ {"[9223372036854775808]", 22, 21, json_tokener_success, 1, 0}, /* INT64_MIN */ {"[-9223372036854775808]", 23, 22, json_tokener_success, 1, 0}, /* INT64_MIN-1 => success, but value ends up capped */ {"[-9223372036854775809]", 23, 22, json_tokener_success, 1, 0}, /* INT64_MIN-1 => failure due to underflow detected */ {"[-9223372036854775809]", 23, 21, json_tokener_error_parse_number, 1, JSON_TOKENER_STRICT}, /* UINT64_MAX */ {"[18446744073709551615]", 23, 22, json_tokener_success, 1, 0}, /* UINT64_MAX+1 => success, but value ends up capped */ {"[18446744073709551616]", 23, 22, json_tokener_success, 1, 0}, /* UINT64_MAX+1 => failure due to overflow detected */ {"[18446744073709551616]", 23, 21, json_tokener_error_parse_number, 1, JSON_TOKENER_STRICT}, /* XXX this seems like a bug, should fail with _error_parse_number instead */ {"18446744073709551616", 21, 20, json_tokener_error_parse_eof, 1, JSON_TOKENER_STRICT}, /* Exceeding integer limits as double parse OK */ {"[9223372036854775808.0]", 24, 23, json_tokener_success, 1, 0}, {"[-9223372036854775809.0]", 25, 24, json_tokener_success, 1, JSON_TOKENER_STRICT}, {"[18446744073709551615.0]", 25, 24, json_tokener_success, 1, 0}, {"[18446744073709551616.0]", 25, 24, json_tokener_success, 1, JSON_TOKENER_STRICT}, /* offset=1 because "n" is the start of "null". hmm... */ {"noodle", 7, 1, json_tokener_error_parse_null, 1, 0}, /* offset=2 because "na" is the start of "nan". hmm... */ {"naodle", 7, 2, json_tokener_error_parse_null, 1, 0}, /* offset=2 because "tr" is the start of "true". hmm... */ {"track", 6, 2, json_tokener_error_parse_boolean, 1, 0}, {"fail", 5, 2, json_tokener_error_parse_boolean, 1, 0}, /* Although they may initially look like they should fail, * the next few tests check that parsing multiple sequential * json objects in the input works as expected */ {"null123", 8, 4, json_tokener_success, 0, 0}, {&"null123"[4], 4, 3, json_tokener_success, 1, 0}, {"nullx", 6, 4, json_tokener_success, 0, 0}, {&"nullx"[4], 2, 0, json_tokener_error_parse_unexpected, 1, 0}, {"{\"a\":1}{\"b\":2}", 15, 7, json_tokener_success, 0, 0}, {&"{\"a\":1}{\"b\":2}"[7], 8, 7, json_tokener_success, 1, 0}, /* * Though this may seem invalid at first glance, it * parses as three separate numbers, 2015, -1 and -15 * Of course, simply pasting together a stream of arbitrary * positive numbers won't work, since there'll be no way to * tell where in e.g. "2015015" the next number stats, so * a reliably parsable stream must not include json_type_int * or json_type_double objects without some other delimiter. * e.g. whitespace */ {&"2015-01-15"[0], 11, 4, json_tokener_success, 1, 0}, {&"2015-01-15"[4], 7, 3, json_tokener_success, 1, 0}, {&"2015-01-15"[7], 4, 3, json_tokener_success, 1, 0}, {&"2015 01 15"[0], 11, 5, json_tokener_success, 1, 0}, {&"2015 01 15"[4], 7, 4, json_tokener_success, 1, 0}, {&"2015 01 15"[7], 4, 3, json_tokener_success, 1, 0}, /* Strings have a well defined end point, so we can stop at the quote */ {"\"blue\"", -1, -1, json_tokener_success, 0, 0}, /* Check each of the escape sequences defined by the spec */ {"\"\\\"\"", -1, -1, json_tokener_success, 0, 0}, {"\"\\\\\"", -1, -1, json_tokener_success, 0, 0}, {"\"\\b\"", -1, -1, json_tokener_success, 0, 0}, {"\"\\f\"", -1, -1, json_tokener_success, 0, 0}, {"\"\\n\"", -1, -1, json_tokener_success, 0, 0}, {"\"\\r\"", -1, -1, json_tokener_success, 0, 0}, {"\"\\t\"", -1, -1, json_tokener_success, 0, 0}, {"\"\\/\"", -1, -1, json_tokener_success, 0, 0}, // Escaping a forward slash is optional {"\"/\"", -1, -1, json_tokener_success, 0, 0}, /* Check wrong escape sequences */ {"\"\\a\"", -1, 2, json_tokener_error_parse_string, 1, 0}, /* Check '\'' in strict model */ {"\'foo\'", -1, 0, json_tokener_error_parse_unexpected, 1, JSON_TOKENER_STRICT}, /* Parse array/object */ {"[1,2,3]", -1, -1, json_tokener_success, 0, 0}, {"[1,2,3}", -1, 6, json_tokener_error_parse_array, 1, 0}, {"{\"a\"}", -1, 4, json_tokener_error_parse_object_key_sep, 1, 0}, {"{\"a\":1]", -1, 6, json_tokener_error_parse_object_value_sep, 1, 0}, {"{\"a\"::1}", -1, 5, json_tokener_error_parse_unexpected, 1, 0}, {"{\"a\":}", -1, 5, json_tokener_error_parse_unexpected, 1, 0}, {"{\"a\":1,\"a\":2}", -1, -1, json_tokener_success, 1, 0}, {"\"a\":1}", -1, 3, json_tokener_success, 1, 0}, {"{\"a\":1", -1, -1, json_tokener_continue, 1, 0}, {"[,]", -1, 1, json_tokener_error_parse_unexpected, 1, 0}, {"[,1]", -1, 1, json_tokener_error_parse_unexpected, 1, 0}, /* This behaviour doesn't entirely follow the json spec, but until we have * a way to specify how strict to be we follow Postel's Law and be liberal * in what we accept (up to a point). */ {"[1,2,3,]", -1, -1, json_tokener_success, 0, 0}, {"[1,2,,3,]", -1, 5, json_tokener_error_parse_unexpected, 0, 0}, {"[1,2,3,]", -1, 7, json_tokener_error_parse_unexpected, 1, JSON_TOKENER_STRICT}, {"{\"a\":1,}", -1, 7, json_tokener_error_parse_unexpected, 1, JSON_TOKENER_STRICT}, // utf-8 test // acsll encoding {"\x22\x31\x32\x33\x61\x73\x63\x24\x25\x26\x22", -1, -1, json_tokener_success, 1, JSON_TOKENER_VALIDATE_UTF8}, {"\x22\x31\x32\x33\x61\x73\x63\x24\x25\x26\x22", -1, -1, json_tokener_success, 1, 0}, // utf-8 encoding {"\x22\xe4\xb8\x96\xe7\x95\x8c\x22", -1, -1, json_tokener_success, 1, JSON_TOKENER_VALIDATE_UTF8}, {"\x22\xe4\xb8", -1, 3, json_tokener_error_parse_utf8_string, 0, JSON_TOKENER_VALIDATE_UTF8}, {"\x96\xe7\x95\x8c\x22", -1, 0, json_tokener_error_parse_utf8_string, 1, JSON_TOKENER_VALIDATE_UTF8}, {"\x22\xe4\xb8\x96\xe7\x95\x8c\x22", -1, -1, json_tokener_success, 1, 0}, {"\x22\xcf\x80\xcf\x86\x22", -1, -1, json_tokener_success, 1, JSON_TOKENER_VALIDATE_UTF8}, {"\x22\xf0\xa5\x91\x95\x22", -1, -1, json_tokener_success, 1, JSON_TOKENER_VALIDATE_UTF8}, // wrong utf-8 encoding {"\x22\xe6\x9d\x4e\x22", -1, 3, json_tokener_error_parse_utf8_string, 1, JSON_TOKENER_VALIDATE_UTF8}, {"\x22\xe6\x9d\x4e\x22", -1, 5, json_tokener_success, 1, 0}, // GBK encoding {"\x22\xc0\xee\xc5\xf4\x22", -1, 2, json_tokener_error_parse_utf8_string, 1, JSON_TOKENER_VALIDATE_UTF8}, {"\x22\xc0\xee\xc5\xf4\x22", -1, 6, json_tokener_success, 1, 0}, // char after space {"\x20\x20\x22\xe4\xb8\x96\x22", -1, -1, json_tokener_success, 1, JSON_TOKENER_VALIDATE_UTF8}, {"\x20\x20\x81\x22\xe4\xb8\x96\x22", -1, 2, json_tokener_error_parse_utf8_string, 1, JSON_TOKENER_VALIDATE_UTF8}, {"\x5b\x20\x81\x31\x5d", -1, 2, json_tokener_error_parse_utf8_string, 1, JSON_TOKENER_VALIDATE_UTF8}, // char in state inf {"\x49\x6e\x66\x69\x6e\x69\x74\x79", 9, 8, json_tokener_success, 1, 0}, {"\x49\x6e\x66\x81\x6e\x69\x74\x79", -1, 3, json_tokener_error_parse_utf8_string, 1, JSON_TOKENER_VALIDATE_UTF8}, // char in escape unicode {"\x22\x5c\x75\x64\x38\x35\x35\x5c\x75\x64\x63\x35\x35\x22", 15, 14, json_tokener_success, 1, JSON_TOKENER_VALIDATE_UTF8}, {"\x22\x5c\x75\x64\x38\x35\x35\xc0\x75\x64\x63\x35\x35\x22", -1, 8, json_tokener_error_parse_utf8_string, 1, JSON_TOKENER_VALIDATE_UTF8}, {"\x22\x5c\x75\x64\x30\x30\x33\x31\xc0\x22", -1, 9, json_tokener_error_parse_utf8_string, 1, JSON_TOKENER_VALIDATE_UTF8}, // char in number {"\x31\x31\x81\x31\x31", -1, 2, json_tokener_error_parse_utf8_string, 1, JSON_TOKENER_VALIDATE_UTF8}, // char in object {"\x7b\x22\x31\x81\x22\x3a\x31\x7d", -1, 3, json_tokener_error_parse_utf8_string, 1, JSON_TOKENER_VALIDATE_UTF8}, {NULL, -1, -1, json_tokener_success, 0, 0}, }; static void test_incremental_parse(void) { json_object *new_obj; enum json_tokener_error jerr; struct json_tokener *tok; const char *string_to_parse; int ii; int num_ok, num_error; num_ok = 0; num_error = 0; printf("Starting incremental tests.\n"); printf("Note: quotes and backslashes seen in the output here are literal values passed\n"); printf(" to the parse functions. e.g. this is 4 characters: \"\\f\"\n"); string_to_parse = "{ \"foo"; /* } */ printf("json_tokener_parse(%s) ... ", string_to_parse); new_obj = json_tokener_parse(string_to_parse); if (new_obj == NULL) puts("got error as expected"); /* test incremental parsing in various forms */ tok = json_tokener_new(); for (ii = 0; incremental_steps[ii].string_to_parse != NULL; ii++) { int this_step_ok = 0; struct incremental_step *step = &incremental_steps[ii]; int length = step->length; size_t expected_char_offset; json_tokener_set_flags(tok, step->tok_flags); if (length == -1) length = (int)strlen(step->string_to_parse); if (step->char_offset == -1) expected_char_offset = length; else expected_char_offset = step->char_offset; printf("json_tokener_parse_ex(tok, %-12s, %3d) ... ", step->string_to_parse, length); new_obj = json_tokener_parse_ex(tok, step->string_to_parse, length); jerr = json_tokener_get_error(tok); if (step->expected_error != json_tokener_success) { if (new_obj != NULL) printf("ERROR: invalid object returned: %s\n", json_object_to_json_string(new_obj)); else if (jerr != step->expected_error) printf("ERROR: got wrong error: %s\n", json_tokener_error_desc(jerr)); else if (json_tokener_get_parse_end(tok) != expected_char_offset) printf("ERROR: wrong char_offset %zu != expected %zu\n", json_tokener_get_parse_end(tok), expected_char_offset); else { printf("OK: got correct error: %s\n", json_tokener_error_desc(jerr)); this_step_ok = 1; } } else { if (new_obj == NULL && !(step->length >= 4 && strncmp(step->string_to_parse, "null", 4) == 0)) printf("ERROR: expected valid object, instead: %s\n", json_tokener_error_desc(jerr)); else if (json_tokener_get_parse_end(tok) != expected_char_offset) printf("ERROR: wrong char_offset %zu != expected %zu\n", json_tokener_get_parse_end(tok), expected_char_offset); else { printf("OK: got object of type [%s]: %s\n", json_type_to_name(json_object_get_type(new_obj)), json_object_to_json_string(new_obj)); this_step_ok = 1; } } if (new_obj) json_object_put(new_obj); if (step->reset_tokener & 1) json_tokener_reset(tok); if (this_step_ok) num_ok++; else num_error++; } json_tokener_free(tok); printf("End Incremental Tests OK=%d ERROR=%d\n", num_ok, num_error); } json-c-json-c-0.17-20230812/tests/test_parse.expected000066400000000000000000000527411446575330000217760ustar00rootroot00000000000000new_obj.to_string("")="\u0003" new_obj.to_string(/* hello */"foo")="foo" new_obj.to_string(// hello "foo")="foo" new_obj.to_string("foo"blue)="foo" new_obj.to_string('foo')="foo" new_obj.to_string("\u0041\u0042\u0043")="ABC" new_obj.to_string("\u4e16\u754c\u00df")="世界ß" new_obj.to_string("\u4E16")="世" new_obj.to_string("\u4e1")=null new_obj.to_string("\u4e1@")=null new_obj.to_string("\ud840\u4e16")="�世" new_obj.to_string("\ud840")="�" new_obj.to_string("\udd27")="�" new_obj.to_string([9,'\uDAD)=null new_obj.to_string(null)=null new_obj.to_string(NaN)=NaN new_obj.to_string(-NaN)=null new_obj.to_string(Inf)=null new_obj.to_string(inf)=null new_obj.to_string(Infinity)=Infinity new_obj.to_string(infinity)=Infinity new_obj.to_string(-Infinity)=-Infinity new_obj.to_string(-infinity)=-Infinity new_obj.to_string({ "min": Infinity, "max": -Infinity})={ "min": Infinity, "max": -Infinity } new_obj.to_string(Infinity!)=Infinity new_obj.to_string(Infinitynull)=Infinity new_obj.to_string(InfinityXXXX)=Infinity new_obj.to_string(-Infinitynull)=-Infinity new_obj.to_string(-InfinityXXXX)=-Infinity new_obj.to_string(Infinoodle)=null new_obj.to_string(InfinAAA)=null new_obj.to_string(-Infinoodle)=null new_obj.to_string(-InfinAAA)=null new_obj.to_string(True)=true new_obj.to_string(False)=false new_obj.to_string(tRue)=true new_obj.to_string(fAlse)=false new_obj.to_string(nAn)=NaN new_obj.to_string(iNfinity)=Infinity new_obj.to_string(12)=12 new_obj.to_string(12.3)=12.3 new_obj.to_string(12.3.4)=12.3 new_obj.to_string(2015-01-15)=2015 new_obj.to_string(12.3xxx)=12.3 new_obj.to_string(12.3{"a":123})=12.3 new_obj.to_string(12.3 )=12.3 new_obj.to_string(12.3 )=12.3 new_obj.to_string({"FoO" : -12.3E512})={ "FoO": -12.3E512 } new_obj.to_string({"FoO" : -12.3e512})={ "FoO": -12.3e512 } new_obj.to_string({"FoO" : -12.3E51.2})=null new_obj.to_string({"FoO" : -12.3E512E12})=null new_obj.to_string(["\n"])=[ "\n" ] new_obj.to_string(["\nabc\n"])=[ "\nabc\n" ] new_obj.to_string([null])=[ null ] new_obj.to_string([])=[ ] new_obj.to_string([false])=[ false ] new_obj.to_string(["abc",null,"def",12])=[ "abc", null, "def", 12 ] new_obj.to_string({})={ } new_obj.to_string({ "foo": "bar" })={ "foo": "bar" } new_obj.to_string({ 'foo': 'bar' })={ "foo": "bar" } new_obj.to_string({ "foo": "bar", "baz": null, "bool0": true })={ "foo": "bar", "baz": null, "bool0": true } new_obj.to_string({ "foo": [null, "foo"] })={ "foo": [ null, "foo" ] } new_obj.to_string({ "abc": 12, "foo": "bar", "bool0": false, "bool1": true, "arr": [ 1, 2, 3, null, 5 ] })={ "abc": 12, "foo": "bar", "bool0": false, "bool1": true, "arr": [ 1, 2, 3, null, 5 ] } new_obj.to_string({ "abc": "blue red\ngreen" })={ "abc": "blue\nred\ngreen" } new_obj.to_string(null)=null new_obj.to_string(false)=false new_obj.to_string([0e])=[ 0.0 ] new_obj.to_string([0e+])=[ 0.0 ] new_obj.to_string([0e+-1])=null new_obj.to_string("hello world!")="hello world!" new_obj.to_string([9223372036854775806])=[ 9223372036854775806 ] new_obj.to_string([9223372036854775807])=[ 9223372036854775807 ] new_obj.to_string([9223372036854775808])=[ 9223372036854775808 ] new_obj.to_string([-9223372036854775807])=[ -9223372036854775807 ] new_obj.to_string([-9223372036854775808])=[ -9223372036854775808 ] new_obj.to_string([-9223372036854775809])=[ -9223372036854775808 ] new_obj.to_string([18446744073709551614])=[ 18446744073709551614 ] new_obj.to_string([18446744073709551615])=[ 18446744073709551615 ] new_obj.to_string([18446744073709551616])=[ 18446744073709551615 ] ================================== new_obj.to_string()=null new_obj.to_string({})=null ================================== json_tokener_parse_verbose() OK ================================== Starting incremental tests. Note: quotes and backslashes seen in the output here are literal values passed to the parse functions. e.g. this is 4 characters: "\f" json_tokener_parse({ "foo) ... got error as expected json_tokener_parse_ex(tok, { "foo": 123 }, 14) ... OK: got object of type [object]: { "foo": 123 } json_tokener_parse_ex(tok, { "foo": 456 }, 14) ... OK: got object of type [object]: { "foo": 456 } json_tokener_parse_ex(tok, { "foo": 789 }, 14) ... OK: got object of type [object]: { "foo": 789 } json_tokener_parse_ex(tok, /* hello */{ "foo", 18) ... OK: got correct error: continue json_tokener_parse_ex(tok, /* hello */:/* hello */, 23) ... OK: got correct error: continue json_tokener_parse_ex(tok, "bar"/* hello */, 16) ... OK: got correct error: continue json_tokener_parse_ex(tok, }/* hello */, 12) ... OK: got object of type [object]: { "foo": "bar" } json_tokener_parse_ex(tok, / hello , 8) ... OK: got correct error: expected comment json_tokener_parse_ex(tok, /* hello"foo", 13) ... OK: got correct error: continue json_tokener_parse_ex(tok, /* hello*"foo", 14) ... OK: got correct error: continue json_tokener_parse_ex(tok, // hello"foo", 13) ... OK: got correct error: continue json_tokener_parse_ex(tok, { "foo , 6) ... OK: got correct error: continue json_tokener_parse_ex(tok, ": {"bar , 8) ... OK: got correct error: continue json_tokener_parse_ex(tok, ":13}} , 6) ... OK: got object of type [object]: { "foo": { "bar": 13 } } json_tokener_parse_ex(tok, "\ , 2) ... OK: got correct error: continue json_tokener_parse_ex(tok, u , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, d , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, 8 , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, 3 , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, 4 , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, \ , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, u , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, d , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, d , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, 1 , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, e" , 2) ... OK: got object of type [string]: "𝄞" json_tokener_parse_ex(tok, "\u , 3) ... OK: got correct error: continue json_tokener_parse_ex(tok, d8 , 2) ... OK: got correct error: continue json_tokener_parse_ex(tok, 34 , 2) ... OK: got correct error: continue json_tokener_parse_ex(tok, \u , 2) ... OK: got correct error: continue json_tokener_parse_ex(tok, dd , 2) ... OK: got correct error: continue json_tokener_parse_ex(tok, 1e" , 3) ... OK: got object of type [string]: "𝄞" json_tokener_parse_ex(tok, "\ud834 , 7) ... OK: got correct error: continue json_tokener_parse_ex(tok, \udd1e" , 7) ... OK: got object of type [string]: "𝄞" json_tokener_parse_ex(tok, "\ud834\ , 8) ... OK: got correct error: continue json_tokener_parse_ex(tok, udd1e" , 6) ... OK: got object of type [string]: "𝄞" json_tokener_parse_ex(tok, "\ud834\u , 9) ... OK: got correct error: continue json_tokener_parse_ex(tok, dd1e" , 5) ... OK: got object of type [string]: "𝄞" json_tokener_parse_ex(tok, "fff \ud834\ud, 14) ... OK: got correct error: continue json_tokener_parse_ex(tok, d1e bar" , 8) ... OK: got object of type [string]: "fff 𝄞 bar" json_tokener_parse_ex(tok, "fff \ud834\udd, 15) ... OK: got correct error: continue json_tokener_parse_ex(tok, 1e bar" , 7) ... OK: got object of type [string]: "fff 𝄞 bar" json_tokener_parse_ex(tok, "fff \ud83d\ude, 15) ... OK: got correct error: continue json_tokener_parse_ex(tok, 00 bar" , 7) ... OK: got object of type [string]: "fff 😀 bar" json_tokener_parse_ex(tok, { "foo , 6) ... OK: got correct error: continue json_tokener_parse_ex(tok, : "bar"} , 8) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, { "foo , 6) ... OK: got correct error: continue json_tokener_parse_ex(tok, ": {"bar , 8) ... OK: got correct error: continue json_tokener_parse_ex(tok, ":13}}XXXX , 10) ... OK: got object of type [object]: { "foo": { "bar": 13 } } json_tokener_parse_ex(tok, XXXX , 4) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, {"x": 123 }"X", 14) ... OK: got object of type [object]: { "x": 123 } json_tokener_parse_ex(tok, "Y" , 3) ... OK: got object of type [string]: "Y" json_tokener_parse_ex(tok, {"foo":9}{"bar":8}, 18) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, {"foo":9}{"bar":8}, 18) ... OK: got object of type [object]: { "foo": 9 } json_tokener_parse_ex(tok, {"b":8}ignored garbage, 22) ... OK: got object of type [object]: { "b": 8 } json_tokener_parse_ex(tok, 1 , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, 2 , 2) ... OK: got object of type [int]: 12 json_tokener_parse_ex(tok, 12{ , 3) ... OK: got object of type [int]: 12 json_tokener_parse_ex(tok, [02] , 4) ... OK: got correct error: number expected json_tokener_parse_ex(tok, 0e+0 , 5) ... OK: got object of type [double]: 0e+0 json_tokener_parse_ex(tok, [0e+0] , 6) ... OK: got object of type [array]: [ 0e+0 ] json_tokener_parse_ex(tok, 0e , 2) ... OK: got correct error: continue json_tokener_parse_ex(tok, 0e , 3) ... OK: got object of type [double]: 0 json_tokener_parse_ex(tok, 0e , 3) ... OK: got correct error: unexpected end of data json_tokener_parse_ex(tok, [0e] , 4) ... OK: got object of type [array]: [ 0 ] json_tokener_parse_ex(tok, [0e] , 4) ... OK: got correct error: number expected json_tokener_parse_ex(tok, 0e+ , 3) ... OK: got correct error: continue json_tokener_parse_ex(tok, 0e+ , 4) ... OK: got object of type [double]: 0 json_tokener_parse_ex(tok, 0e+ , 4) ... OK: got correct error: unexpected end of data json_tokener_parse_ex(tok, [0e+] , 5) ... OK: got object of type [array]: [ 0 ] json_tokener_parse_ex(tok, [0e+] , 5) ... OK: got correct error: number expected json_tokener_parse_ex(tok, 0e- , 3) ... OK: got correct error: continue json_tokener_parse_ex(tok, 0e- , 4) ... OK: got object of type [double]: 0 json_tokener_parse_ex(tok, 0e- , 4) ... OK: got correct error: unexpected end of data json_tokener_parse_ex(tok, [0e-] , 5) ... OK: got object of type [array]: [ 0 ] json_tokener_parse_ex(tok, [0e-] , 5) ... OK: got correct error: number expected json_tokener_parse_ex(tok, 0e+- , 5) ... OK: got object of type [double]: 0 json_tokener_parse_ex(tok, 0e+- , 5) ... OK: got correct error: number expected json_tokener_parse_ex(tok, [0e+-] , 6) ... OK: got correct error: number expected json_tokener_parse_ex(tok, false , 5) ... OK: got correct error: continue json_tokener_parse_ex(tok, false , 6) ... OK: got object of type [boolean]: false json_tokener_parse_ex(tok, true , 4) ... OK: got correct error: continue json_tokener_parse_ex(tok, true , 5) ... OK: got object of type [boolean]: true json_tokener_parse_ex(tok, null , 4) ... OK: got correct error: continue json_tokener_parse_ex(tok, null , 5) ... OK: got object of type [null]: null json_tokener_parse_ex(tok, Infinity , 9) ... OK: got object of type [double]: Infinity json_tokener_parse_ex(tok, infinity , 9) ... OK: got object of type [double]: Infinity json_tokener_parse_ex(tok, -infinity , 10) ... OK: got object of type [double]: -Infinity json_tokener_parse_ex(tok, infinity , 9) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, -infinity , 10) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, inf , 3) ... OK: got correct error: continue json_tokener_parse_ex(tok, inity , 6) ... OK: got object of type [double]: Infinity json_tokener_parse_ex(tok, -inf , 4) ... OK: got correct error: continue json_tokener_parse_ex(tok, inity , 6) ... OK: got object of type [double]: -Infinity json_tokener_parse_ex(tok, i , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, n , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, f , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, i , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, n , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, i , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, t , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, y , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, , 1) ... OK: got object of type [double]: Infinity json_tokener_parse_ex(tok, - , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, inf , 3) ... OK: got correct error: continue json_tokener_parse_ex(tok, ini , 3) ... OK: got correct error: continue json_tokener_parse_ex(tok, ty , 3) ... OK: got object of type [double]: -Infinity json_tokener_parse_ex(tok, - , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, i , 1) ... OK: got correct error: continue json_tokener_parse_ex(tok, nfini , 5) ... OK: got correct error: continue json_tokener_parse_ex(tok, ty , 3) ... OK: got object of type [double]: -Infinity json_tokener_parse_ex(tok, -i , 2) ... OK: got correct error: continue json_tokener_parse_ex(tok, nfinity , 8) ... OK: got object of type [double]: -Infinity json_tokener_parse_ex(tok, InfinityX , 10) ... OK: got object of type [double]: Infinity json_tokener_parse_ex(tok, X , 1) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, Infinity1234, 13) ... OK: got object of type [double]: Infinity json_tokener_parse_ex(tok, 1234 , 5) ... OK: got object of type [int]: 1234 json_tokener_parse_ex(tok, Infinity9999, 8) ... OK: got correct error: continue json_tokener_parse_ex(tok, 1234 , 5) ... OK: got object of type [double]: Infinity json_tokener_parse_ex(tok, 1234 , 5) ... OK: got object of type [int]: 1234 json_tokener_parse_ex(tok, [9223372036854775807], 22) ... OK: got object of type [array]: [ 9223372036854775807 ] json_tokener_parse_ex(tok, [9223372036854775808], 22) ... OK: got object of type [array]: [ 9223372036854775808 ] json_tokener_parse_ex(tok, [-9223372036854775808], 23) ... OK: got object of type [array]: [ -9223372036854775808 ] json_tokener_parse_ex(tok, [-9223372036854775809], 23) ... OK: got object of type [array]: [ -9223372036854775808 ] json_tokener_parse_ex(tok, [-9223372036854775809], 23) ... OK: got correct error: number expected json_tokener_parse_ex(tok, [18446744073709551615], 23) ... OK: got object of type [array]: [ 18446744073709551615 ] json_tokener_parse_ex(tok, [18446744073709551616], 23) ... OK: got object of type [array]: [ 18446744073709551615 ] json_tokener_parse_ex(tok, [18446744073709551616], 23) ... OK: got correct error: number expected json_tokener_parse_ex(tok, 18446744073709551616, 21) ... OK: got correct error: unexpected end of data json_tokener_parse_ex(tok, [9223372036854775808.0], 24) ... OK: got object of type [array]: [ 9223372036854775808.0 ] json_tokener_parse_ex(tok, [-9223372036854775809.0], 25) ... OK: got object of type [array]: [ -9223372036854775809.0 ] json_tokener_parse_ex(tok, [18446744073709551615.0], 25) ... OK: got object of type [array]: [ 18446744073709551615.0 ] json_tokener_parse_ex(tok, [18446744073709551616.0], 25) ... OK: got object of type [array]: [ 18446744073709551616.0 ] json_tokener_parse_ex(tok, noodle , 7) ... OK: got correct error: null expected json_tokener_parse_ex(tok, naodle , 7) ... OK: got correct error: null expected json_tokener_parse_ex(tok, track , 6) ... OK: got correct error: boolean expected json_tokener_parse_ex(tok, fail , 5) ... OK: got correct error: boolean expected json_tokener_parse_ex(tok, null123 , 8) ... OK: got object of type [null]: null json_tokener_parse_ex(tok, 123 , 4) ... OK: got object of type [int]: 123 json_tokener_parse_ex(tok, nullx , 6) ... OK: got object of type [null]: null json_tokener_parse_ex(tok, x , 2) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, {"a":1}{"b":2}, 15) ... OK: got object of type [object]: { "a": 1 } json_tokener_parse_ex(tok, {"b":2} , 8) ... OK: got object of type [object]: { "b": 2 } json_tokener_parse_ex(tok, 2015-01-15 , 11) ... OK: got object of type [int]: 2015 json_tokener_parse_ex(tok, -01-15 , 7) ... OK: got object of type [int]: -1 json_tokener_parse_ex(tok, -15 , 4) ... OK: got object of type [int]: -15 json_tokener_parse_ex(tok, 2015 01 15 , 11) ... OK: got object of type [int]: 2015 json_tokener_parse_ex(tok, 01 15 , 7) ... OK: got object of type [int]: 1 json_tokener_parse_ex(tok, 15 , 4) ... OK: got object of type [int]: 15 json_tokener_parse_ex(tok, "blue" , 6) ... OK: got object of type [string]: "blue" json_tokener_parse_ex(tok, "\"" , 4) ... OK: got object of type [string]: "\"" json_tokener_parse_ex(tok, "\\" , 4) ... OK: got object of type [string]: "\\" json_tokener_parse_ex(tok, "\b" , 4) ... OK: got object of type [string]: "\b" json_tokener_parse_ex(tok, "\f" , 4) ... OK: got object of type [string]: "\f" json_tokener_parse_ex(tok, "\n" , 4) ... OK: got object of type [string]: "\n" json_tokener_parse_ex(tok, "\r" , 4) ... OK: got object of type [string]: "\r" json_tokener_parse_ex(tok, "\t" , 4) ... OK: got object of type [string]: "\t" json_tokener_parse_ex(tok, "\/" , 4) ... OK: got object of type [string]: "\/" json_tokener_parse_ex(tok, "/" , 3) ... OK: got object of type [string]: "\/" json_tokener_parse_ex(tok, "\a" , 4) ... OK: got correct error: invalid string sequence json_tokener_parse_ex(tok, 'foo' , 5) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, [1,2,3] , 7) ... OK: got object of type [array]: [ 1, 2, 3 ] json_tokener_parse_ex(tok, [1,2,3} , 7) ... OK: got correct error: array value separator ',' expected json_tokener_parse_ex(tok, {"a"} , 5) ... OK: got correct error: object property name separator ':' expected json_tokener_parse_ex(tok, {"a":1] , 7) ... OK: got correct error: object value separator ',' expected json_tokener_parse_ex(tok, {"a"::1} , 8) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, {"a":} , 6) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, {"a":1,"a":2}, 13) ... OK: got object of type [object]: { "a": 2 } json_tokener_parse_ex(tok, "a":1} , 6) ... OK: got object of type [string]: "a" json_tokener_parse_ex(tok, {"a":1 , 6) ... OK: got correct error: continue json_tokener_parse_ex(tok, [,] , 3) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, [,1] , 4) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, [1,2,3,] , 8) ... OK: got object of type [array]: [ 1, 2, 3 ] json_tokener_parse_ex(tok, [1,2,,3,] , 9) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, [1,2,3,] , 8) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, {"a":1,} , 8) ... OK: got correct error: unexpected character json_tokener_parse_ex(tok, "123asc$%&" , 11) ... OK: got object of type [string]: "123asc$%&" json_tokener_parse_ex(tok, "123asc$%&" , 11) ... OK: got object of type [string]: "123asc$%&" json_tokener_parse_ex(tok, "世界" , 8) ... OK: got object of type [string]: "世界" json_tokener_parse_ex(tok, " , 3) ... OK: got correct error: invalid utf-8 string json_tokener_parse_ex(tok, 界" , 5) ... OK: got correct error: invalid utf-8 string json_tokener_parse_ex(tok, "世界" , 8) ... OK: got object of type [string]: "世界" json_tokener_parse_ex(tok, "πφ" , 6) ... OK: got object of type [string]: "πφ" json_tokener_parse_ex(tok, "𥑕" , 6) ... OK: got object of type [string]: "𥑕" json_tokener_parse_ex(tok, "N" , 5) ... OK: got correct error: invalid utf-8 string json_tokener_parse_ex(tok, "N" , 5) ... OK: got object of type [string]: "N" json_tokener_parse_ex(tok, "" , 6) ... OK: got correct error: invalid utf-8 string json_tokener_parse_ex(tok, "" , 6) ... OK: got object of type [string]: "" json_tokener_parse_ex(tok, "世" , 7) ... OK: got object of type [string]: "世" json_tokener_parse_ex(tok, "世" , 8) ... OK: got correct error: invalid utf-8 string json_tokener_parse_ex(tok, [ 1] , 5) ... OK: got correct error: invalid utf-8 string json_tokener_parse_ex(tok, Infinity , 9) ... OK: got object of type [double]: Infinity json_tokener_parse_ex(tok, Infnity , 8) ... OK: got correct error: invalid utf-8 string json_tokener_parse_ex(tok, "\ud855\udc55", 15) ... OK: got object of type [string]: "𥑕" json_tokener_parse_ex(tok, "\ud855udc55", 14) ... OK: got correct error: invalid utf-8 string json_tokener_parse_ex(tok, "\ud0031" , 10) ... OK: got correct error: invalid utf-8 string json_tokener_parse_ex(tok, 1111 , 5) ... OK: got correct error: invalid utf-8 string json_tokener_parse_ex(tok, {"1":1} , 8) ... OK: got correct error: invalid utf-8 string End Incremental Tests OK=198 ERROR=0 ================================== json-c-json-c-0.17-20230812/tests/test_parse.test000077700000000000000000000000001446575330000241572test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_parse_int64.c000066400000000000000000000076541446575330000214460ustar00rootroot00000000000000 #ifdef NDEBUG #undef NDEBUG #endif #include #include #include "config.h" #include "json_inttypes.h" #include "json_util.h" void checkit(const char *buf) { int64_t cint64 = -666; int retval = json_parse_int64(buf, &cint64); printf("buf=%s parseit=%d, value=%" PRId64 " \n", buf, retval, cint64); } void checkit_uint(const char *buf) { uint64_t cuint64 = 666; int retval = json_parse_uint64(buf, &cuint64); printf("buf=%s parseit=%d, value=%" PRIu64 " \n", buf, retval, cuint64); } /** * This test calls json_parse_int64 and json_parse_int64 with a variety * of different strings. It's purpose is to ensure that the results are * consistent across all different environments that it might be executed in. * * This always exits with a 0 exit value. The output should be compared * against previously saved expected output. */ int main(int argc, char **argv) { char buf[100]; printf("==========json_parse_int64() test===========\n"); checkit("x"); checkit("0"); checkit("-0"); checkit("00000000"); checkit("-00000000"); checkit("1"); strcpy(buf, "2147483647"); // aka INT32_MAX checkit(buf); strcpy(buf, "-1"); checkit(buf); strcpy(buf, " -1"); checkit(buf); strcpy(buf, "00001234"); checkit(buf); strcpy(buf, "0001234x"); checkit(buf); strcpy(buf, "-00001234"); checkit(buf); strcpy(buf, "-00001234x"); checkit(buf); strcpy(buf, "4294967295"); // aka UINT32_MAX checkit(buf); strcpy(buf, "4294967296"); // aka UINT32_MAX + 1 checkit(buf); strcpy(buf, "21474836470"); // INT32_MAX * 10 checkit(buf); strcpy(buf, "31474836470"); // INT32_MAX * 10 + a bunch checkit(buf); strcpy(buf, "-2147483647"); // INT32_MIN + 1 checkit(buf); strcpy(buf, "-2147483648"); // INT32_MIN checkit(buf); strcpy(buf, "-2147483649"); // INT32_MIN - 1 checkit(buf); strcpy(buf, "-21474836480"); // INT32_MIN * 10 checkit(buf); strcpy(buf, "9223372036854775806"); // INT64_MAX - 1 checkit(buf); strcpy(buf, "9223372036854775807"); // INT64_MAX checkit(buf); strcpy(buf, "9223372036854775808"); // INT64_MAX + 1 checkit(buf); strcpy(buf, "-9223372036854775808"); // INT64_MIN checkit(buf); strcpy(buf, "-9223372036854775809"); // INT64_MIN - 1 checkit(buf); strcpy(buf, "18446744073709551614"); // UINT64_MAX - 1 checkit(buf); strcpy(buf, "18446744073709551615"); // UINT64_MAX checkit(buf); strcpy(buf, "18446744073709551616"); // UINT64_MAX + 1 checkit(buf); strcpy(buf, "-18446744073709551616"); // -UINT64_MAX checkit(buf); // Ensure we can still parse valid numbers after parsing out of range ones. strcpy(buf, "123"); checkit(buf); printf("\n==========json_parse_uint64() test===========\n"); checkit_uint("x"); checkit_uint("0"); checkit_uint("-0"); checkit_uint("00000000"); checkit_uint("-00000000"); checkit_uint("1"); strcpy(buf, "2147483647"); // aka INT32_MAX checkit_uint(buf); strcpy(buf, "-1"); checkit_uint(buf); strcpy(buf, "-9223372036854775808"); checkit_uint(buf); strcpy(buf, " 1"); checkit_uint(buf); strcpy(buf, "00001234"); checkit_uint(buf); strcpy(buf, "0001234x"); checkit_uint(buf); strcpy(buf, "4294967295"); // aka UINT32_MAX checkit_uint(buf); strcpy(buf, "4294967296"); // aka UINT32_MAX + 1 checkit_uint(buf); strcpy(buf, "21474836470"); // INT32_MAX * 10 checkit_uint(buf); strcpy(buf, "31474836470"); // INT32_MAX * 10 + a bunch checkit_uint(buf); strcpy(buf, "9223372036854775806"); // INT64_MAX - 1 checkit_uint(buf); strcpy(buf, "9223372036854775807"); // INT64_MAX checkit_uint(buf); strcpy(buf, "9223372036854775808"); // INT64_MAX + 1 checkit_uint(buf); strcpy(buf, "18446744073709551614"); // UINT64_MAX - 1 checkit_uint(buf); strcpy(buf, "18446744073709551615"); // UINT64_MAX checkit_uint(buf); strcpy(buf, "18446744073709551616"); // UINT64_MAX + 1 checkit_uint(buf); // Ensure we can still parse valid numbers after parsing out of range ones. strcpy(buf, "123"); checkit_uint(buf); return 0; } json-c-json-c-0.17-20230812/tests/test_parse_int64.expected000066400000000000000000000046461446575330000230230ustar00rootroot00000000000000==========json_parse_int64() test=========== buf=x parseit=1, value=-666 buf=0 parseit=0, value=0 buf=-0 parseit=0, value=0 buf=00000000 parseit=0, value=0 buf=-00000000 parseit=0, value=0 buf=1 parseit=0, value=1 buf=2147483647 parseit=0, value=2147483647 buf=-1 parseit=0, value=-1 buf= -1 parseit=0, value=-1 buf=00001234 parseit=0, value=1234 buf=0001234x parseit=0, value=1234 buf=-00001234 parseit=0, value=-1234 buf=-00001234x parseit=0, value=-1234 buf=4294967295 parseit=0, value=4294967295 buf=4294967296 parseit=0, value=4294967296 buf=21474836470 parseit=0, value=21474836470 buf=31474836470 parseit=0, value=31474836470 buf=-2147483647 parseit=0, value=-2147483647 buf=-2147483648 parseit=0, value=-2147483648 buf=-2147483649 parseit=0, value=-2147483649 buf=-21474836480 parseit=0, value=-21474836480 buf=9223372036854775806 parseit=0, value=9223372036854775806 buf=9223372036854775807 parseit=0, value=9223372036854775807 buf=9223372036854775808 parseit=0, value=9223372036854775807 buf=-9223372036854775808 parseit=0, value=-9223372036854775808 buf=-9223372036854775809 parseit=0, value=-9223372036854775808 buf=18446744073709551614 parseit=0, value=9223372036854775807 buf=18446744073709551615 parseit=0, value=9223372036854775807 buf=18446744073709551616 parseit=0, value=9223372036854775807 buf=-18446744073709551616 parseit=0, value=-9223372036854775808 buf=123 parseit=0, value=123 ==========json_parse_uint64() test=========== buf=x parseit=1, value=666 buf=0 parseit=0, value=0 buf=-0 parseit=1, value=666 buf=00000000 parseit=0, value=0 buf=-00000000 parseit=1, value=666 buf=1 parseit=0, value=1 buf=2147483647 parseit=0, value=2147483647 buf=-1 parseit=1, value=666 buf=-9223372036854775808 parseit=1, value=666 buf= 1 parseit=0, value=1 buf=00001234 parseit=0, value=1234 buf=0001234x parseit=0, value=1234 buf=4294967295 parseit=0, value=4294967295 buf=4294967296 parseit=0, value=4294967296 buf=21474836470 parseit=0, value=21474836470 buf=31474836470 parseit=0, value=31474836470 buf=9223372036854775806 parseit=0, value=9223372036854775806 buf=9223372036854775807 parseit=0, value=9223372036854775807 buf=9223372036854775808 parseit=0, value=9223372036854775808 buf=18446744073709551614 parseit=0, value=18446744073709551614 buf=18446744073709551615 parseit=0, value=18446744073709551615 buf=18446744073709551616 parseit=0, value=18446744073709551615 buf=123 parseit=0, value=123 json-c-json-c-0.17-20230812/tests/test_parse_int64.test000077700000000000000000000000001446575330000252032test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_printbuf.c000066400000000000000000000124401446575330000211260ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include #include #include #include "debug.h" #include "printbuf.h" static void test_basic_printbuf_memset(void); static void test_printbuf_memset_length(void); #ifndef __func__ /* VC++ compat */ #define __func__ __FUNCTION__ #endif static void test_basic_printbuf_memset(void) { struct printbuf *pb; printf("%s: starting test\n", __func__); pb = printbuf_new(); sprintbuf(pb, "blue:%d", 1); printbuf_memset(pb, -1, 'x', 52); printf("Buffer contents:%.*s\n", printbuf_length(pb), pb->buf); printbuf_free(pb); printf("%s: end test\n", __func__); } static void test_printbuf_memset_length(void) { struct printbuf *pb; printf("%s: starting test\n", __func__); pb = printbuf_new(); printbuf_memset(pb, -1, ' ', 0); printbuf_memset(pb, -1, ' ', 0); printbuf_memset(pb, -1, ' ', 0); printbuf_memset(pb, -1, ' ', 0); printbuf_memset(pb, -1, ' ', 0); printf("Buffer length: %d\n", printbuf_length(pb)); printbuf_memset(pb, -1, ' ', 2); printbuf_memset(pb, -1, ' ', 4); printbuf_memset(pb, -1, ' ', 6); printf("Buffer length: %d\n", printbuf_length(pb)); printbuf_memset(pb, -1, ' ', 6); printf("Buffer length: %d\n", printbuf_length(pb)); printbuf_memset(pb, -1, ' ', 8); printbuf_memset(pb, -1, ' ', 10); printbuf_memset(pb, -1, ' ', 10); printbuf_memset(pb, -1, ' ', 10); printbuf_memset(pb, -1, ' ', 20); printf("Buffer length: %d\n", printbuf_length(pb)); // No length change should occur printbuf_memset(pb, 0, 'x', 30); printf("Buffer length: %d\n", printbuf_length(pb)); // This should extend it by one. printbuf_memset(pb, 0, 'x', printbuf_length(pb) + 1); printf("Buffer length: %d\n", printbuf_length(pb)); printbuf_free(pb); printf("%s: end test\n", __func__); } static void test_printbuf_memappend(int *before_resize); static void test_printbuf_memappend(int *before_resize) { struct printbuf *pb; int initial_size; printf("%s: starting test\n", __func__); pb = printbuf_new(); printf("Buffer length: %d\n", printbuf_length(pb)); initial_size = pb->size; while (pb->size == initial_size) { printbuf_memappend_fast(pb, "x", 1); } *before_resize = printbuf_length(pb) - 1; printf("Appended %d bytes for resize: [%s]\n", *before_resize + 1, pb->buf); printbuf_reset(pb); printbuf_memappend_fast(pb, "bluexyz123", 3); printf("Partial append: %d, [%s]\n", printbuf_length(pb), pb->buf); char with_nulls[] = {'a', 'b', '\0', 'c'}; printbuf_reset(pb); printbuf_memappend_fast(pb, with_nulls, (int)sizeof(with_nulls)); printf("With embedded \\0 character: %d, [%s]\n", printbuf_length(pb), pb->buf); printbuf_free(pb); pb = printbuf_new(); char *data = malloc(*before_resize); memset(data, 'X', *before_resize); printbuf_memappend_fast(pb, data, *before_resize); printf("Append to just before resize: %d, [%s]\n", printbuf_length(pb), pb->buf); free(data); printbuf_free(pb); pb = printbuf_new(); data = malloc(*before_resize + 1); memset(data, 'X', *before_resize + 1); printbuf_memappend_fast(pb, data, *before_resize + 1); printf("Append to just after resize: %d, [%s]\n", printbuf_length(pb), pb->buf); free(data); printbuf_free(pb); #define SA_TEST_STR "XXXXXXXXXXXXXXXX" pb = printbuf_new(); printbuf_strappend(pb, SA_TEST_STR); printf("Buffer size after printbuf_strappend(): %d, [%s]\n", printbuf_length(pb), pb->buf); printbuf_free(pb); #undef SA_TEST_STR printf("%s: end test\n", __func__); } static void test_sprintbuf(int before_resize); static void test_sprintbuf(int before_resize) { struct printbuf *pb; const char *max_char = "if string is greater than stack buffer, then use dynamic string" " with vasprintf. Note: some implementation of vsnprintf return -1 " " if output is truncated whereas some return the number of bytes that " " would have been written - this code handles both cases."; printf("%s: starting test\n", __func__); pb = printbuf_new(); printf("Buffer length: %d\n", printbuf_length(pb)); char *data = malloc(before_resize + 1 + 1); memset(data, 'X', before_resize + 1 + 1); data[before_resize + 1] = '\0'; sprintbuf(pb, "%s", data); free(data); printf("sprintbuf to just after resize(%d+1): %d, [%s], strlen(buf)=%d\n", before_resize, printbuf_length(pb), pb->buf, (int)strlen(pb->buf)); printbuf_reset(pb); sprintbuf(pb, "plain"); printf("%d, [%s]\n", printbuf_length(pb), pb->buf); sprintbuf(pb, "%d", 1); printf("%d, [%s]\n", printbuf_length(pb), pb->buf); sprintbuf(pb, "%d", INT_MAX); printf("%d, [%s]\n", printbuf_length(pb), pb->buf); sprintbuf(pb, "%d", INT_MIN); printf("%d, [%s]\n", printbuf_length(pb), pb->buf); sprintbuf(pb, "%s", "%s"); printf("%d, [%s]\n", printbuf_length(pb), pb->buf); sprintbuf(pb, max_char); printf("%d, [%s]\n", printbuf_length(pb), pb->buf); printbuf_free(pb); printf("%s: end test\n", __func__); } int main(int argc, char **argv) { int before_resize = 0; MC_SET_DEBUG(1); test_basic_printbuf_memset(); printf("========================================\n"); test_printbuf_memset_length(); printf("========================================\n"); test_printbuf_memappend(&before_resize); printf("========================================\n"); test_sprintbuf(before_resize); printf("========================================\n"); return 0; } json-c-json-c-0.17-20230812/tests/test_printbuf.expected000066400000000000000000000027261446575330000225130ustar00rootroot00000000000000test_basic_printbuf_memset: starting test Buffer contents:blue:1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx test_basic_printbuf_memset: end test ======================================== test_printbuf_memset_length: starting test Buffer length: 0 Buffer length: 12 Buffer length: 18 Buffer length: 76 Buffer length: 76 Buffer length: 77 test_printbuf_memset_length: end test ======================================== test_printbuf_memappend: starting test Buffer length: 0 Appended 32 bytes for resize: [xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx] Partial append: 3, [blu] With embedded \0 character: 4, [ab] Append to just before resize: 31, [XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX] Append to just after resize: 32, [XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX] Buffer size after printbuf_strappend(): 16, [XXXXXXXXXXXXXXXX] test_printbuf_memappend: end test ======================================== test_sprintbuf: starting test Buffer length: 0 sprintbuf to just after resize(31+1): 32, [XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX], strlen(buf)=32 5, [plain] 6, [plain1] 16, [plain12147483647] 27, [plain12147483647-2147483648] 29, [plain12147483647-2147483648%s] 284, [plain12147483647-2147483648%sif string is greater than stack buffer, then use dynamic string with vasprintf. Note: some implementation of vsnprintf return -1 if output is truncated whereas some return the number of bytes that would have been written - this code handles both cases.] test_sprintbuf: end test ======================================== json-c-json-c-0.17-20230812/tests/test_printbuf.test000077700000000000000000000000001446575330000246762test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_set_serializer.c000066400000000000000000000052431446575330000223240ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include "json.h" #include "printbuf.h" struct myinfo { int value; }; static int freeit_was_called = 0; static void freeit(json_object *jso, void *userdata) { struct myinfo *info = userdata; printf("freeit, value=%d\n", info->value); // Don't actually free anything here, the userdata is stack allocated. freeit_was_called = 1; } static int custom_serializer(struct json_object *o, struct printbuf *pb, int level, int flags) { sprintbuf(pb, "Custom Output"); return 0; } int main(int argc, char **argv) { json_object *my_object, *my_sub_object; MC_SET_DEBUG(1); printf("Test setting, then resetting a custom serializer:\n"); my_object = json_object_new_object(); json_object_object_add(my_object, "abc", json_object_new_int(12)); json_object_object_add(my_object, "foo", json_object_new_string("bar")); printf("my_object.to_string(standard)=%s\n", json_object_to_json_string(my_object)); struct myinfo userdata = {.value = 123}; json_object_set_serializer(my_object, custom_serializer, &userdata, freeit); printf("my_object.to_string(custom serializer)=%s\n", json_object_to_json_string(my_object)); printf("Next line of output should be from the custom freeit function:\n"); freeit_was_called = 0; json_object_set_serializer(my_object, NULL, NULL, NULL); assert(freeit_was_called); printf("my_object.to_string(standard)=%s\n", json_object_to_json_string(my_object)); json_object_put(my_object); // ============================================ my_object = json_object_new_object(); printf("Check that the custom serializer isn't free'd until the last json_object_put:\n"); json_object_set_serializer(my_object, custom_serializer, &userdata, freeit); json_object_get(my_object); json_object_put(my_object); printf("my_object.to_string(custom serializer)=%s\n", json_object_to_json_string(my_object)); printf("Next line of output should be from the custom freeit function:\n"); freeit_was_called = 0; json_object_put(my_object); assert(freeit_was_called); // ============================================ my_object = json_object_new_object(); my_sub_object = json_object_new_double(1.0); json_object_object_add(my_object, "double", my_sub_object); printf("Check that the custom serializer does not include nul byte:\n"); #define UNCONST(a) ((void *)(uintptr_t)(const void *)(a)) json_object_set_serializer(my_sub_object, json_object_double_to_json_string, UNCONST("%125.0f"), NULL); printf("my_object.to_string(custom serializer)=%s\n", json_object_to_json_string_ext(my_object, JSON_C_TO_STRING_NOZERO)); json_object_put(my_object); return 0; } json-c-json-c-0.17-20230812/tests/test_set_serializer.expected000066400000000000000000000013541446575330000237020ustar00rootroot00000000000000Test setting, then resetting a custom serializer: my_object.to_string(standard)={ "abc": 12, "foo": "bar" } my_object.to_string(custom serializer)=Custom Output Next line of output should be from the custom freeit function: freeit, value=123 my_object.to_string(standard)={ "abc": 12, "foo": "bar" } Check that the custom serializer isn't free'd until the last json_object_put: my_object.to_string(custom serializer)=Custom Output Next line of output should be from the custom freeit function: freeit, value=123 Check that the custom serializer does not include nul byte: my_object.to_string(custom serializer)={"double": 1} json-c-json-c-0.17-20230812/tests/test_set_serializer.test000077700000000000000000000000001446575330000260712test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_set_value.c000066400000000000000000000102001446575330000212540ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include "json.h" int main(int argc, char **argv) { json_object *tmp = json_object_new_int(123); assert(json_object_get_int(tmp) == 123); json_object_set_int(tmp, 321); assert(json_object_get_int(tmp) == 321); printf("INT PASSED\n"); json_object_set_int64(tmp, (int64_t)321321321); assert(json_object_get_int64(tmp) == 321321321); json_object_put(tmp); printf("INT64 PASSED\n"); tmp = json_object_new_uint64(123); assert(json_object_get_boolean(tmp) == 1); assert(json_object_get_int(tmp) == 123); assert(json_object_get_int64(tmp) == 123); assert(json_object_get_uint64(tmp) == 123); assert(json_object_get_double(tmp) == 123.000000); json_object_set_uint64(tmp, (uint64_t)321321321); assert(json_object_get_uint64(tmp) == 321321321); json_object_set_uint64(tmp, 9223372036854775808U); assert(json_object_get_int(tmp) == INT32_MAX); assert(json_object_get_uint64(tmp) == 9223372036854775808U); json_object_put(tmp); printf("UINT64 PASSED\n"); tmp = json_object_new_boolean(1); assert(json_object_get_boolean(tmp) == 1); json_object_set_boolean(tmp, 0); assert(json_object_get_boolean(tmp) == 0); json_object_set_boolean(tmp, 1); assert(json_object_get_boolean(tmp) == 1); json_object_put(tmp); printf("BOOL PASSED\n"); tmp = json_object_new_double(12.34); assert(json_object_get_double(tmp) == 12.34); json_object_set_double(tmp, 34.56); assert(json_object_get_double(tmp) == 34.56); json_object_set_double(tmp, 6435.34); assert(json_object_get_double(tmp) == 6435.34); json_object_set_double(tmp, 2e21); assert(json_object_get_int(tmp) == INT32_MAX); assert(json_object_get_int64(tmp) == INT64_MAX); assert(json_object_get_uint64(tmp) == UINT64_MAX); json_object_set_double(tmp, -2e21); assert(json_object_get_int(tmp) == INT32_MIN); assert(json_object_get_int64(tmp) == INT64_MIN); assert(json_object_get_uint64(tmp) == 0); json_object_put(tmp); printf("DOUBLE PASSED\n"); #define SHORT "SHORT" #define MID "A MID STRING" // 12345678901234567890123456789012.... #define HUGE "A string longer than 32 chars as to check non local buf codepath" tmp = json_object_new_string(MID); assert(strcmp(json_object_get_string(tmp), MID) == 0); assert(strcmp(json_object_to_json_string(tmp), "\"" MID "\"") == 0); json_object_set_string(tmp, SHORT); assert(strcmp(json_object_get_string(tmp), SHORT) == 0); assert(strcmp(json_object_to_json_string(tmp), "\"" SHORT "\"") == 0); json_object_set_string(tmp, HUGE); assert(strcmp(json_object_get_string(tmp), HUGE) == 0); assert(strcmp(json_object_to_json_string(tmp), "\"" HUGE "\"") == 0); json_object_set_string(tmp, SHORT); assert(strcmp(json_object_get_string(tmp), SHORT) == 0); assert(strcmp(json_object_to_json_string(tmp), "\"" SHORT "\"") == 0); // Set an empty string a couple times to try to trigger // a case that used to leak memory. json_object_set_string(tmp, ""); json_object_set_string(tmp, HUGE); json_object_set_string(tmp, ""); json_object_set_string(tmp, HUGE); json_object_put(tmp); printf("STRING PASSED\n"); #define STR "STR" #define DOUBLE "123.123" #define DOUBLE_E "12E+3" #define DOUBLE_STR "123.123STR" #define DOUBLE_OVER "1.8E+308" #define DOUBLE_OVER_NEGATIVE "-1.8E+308" tmp = json_object_new_string(STR); assert(json_object_get_double(tmp) == 0.0); json_object_set_string(tmp, DOUBLE); assert(json_object_get_double(tmp) == 123.123000); json_object_set_string(tmp, DOUBLE_E); assert(json_object_get_double(tmp) == 12000.000000); json_object_set_string(tmp, DOUBLE_STR); assert(json_object_get_double(tmp) == 0.0); json_object_set_string(tmp, DOUBLE_OVER); assert(json_object_get_double(tmp) == 0.0); json_object_set_string(tmp, DOUBLE_OVER_NEGATIVE); assert(json_object_get_double(tmp) == 0.0); json_object_put(tmp); printf("STRINGTODOUBLE PASSED\n"); tmp = json_tokener_parse("1.234"); json_object_set_double(tmp, 12.3); const char *serialized = json_object_to_json_string(tmp); fprintf(stderr, "%s\n", serialized); assert(strncmp(serialized, "12.3", 4) == 0); json_object_put(tmp); printf("PARSE AND SET PASSED\n"); printf("PASSED\n"); return 0; } json-c-json-c-0.17-20230812/tests/test_set_value.expected000066400000000000000000000002001446575330000226320ustar00rootroot00000000000000INT PASSED INT64 PASSED UINT64 PASSED BOOL PASSED DOUBLE PASSED STRING PASSED STRINGTODOUBLE PASSED PARSE AND SET PASSED PASSED json-c-json-c-0.17-20230812/tests/test_set_value.test000077700000000000000000000000001446575330000250342test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_strerror.c000066400000000000000000000002641446575330000211600ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include "strerror_override.h" #include int main(int argc, char **argv) { puts(strerror(10000)); puts(strerror(999)); return 0; } json-c-json-c-0.17-20230812/tests/test_strerror.expected000066400000000000000000000000261446575330000225330ustar00rootroot00000000000000ERRNO=10000 ERRNO=999 json-c-json-c-0.17-20230812/tests/test_strerror.test000077700000000000000000000000001446575330000247272test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_util_file.c000066400000000000000000000176401446575330000212600ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include "strerror_override.h" #ifdef WIN32 #define WIN32_LEAN_AND_MEAN #include #include #endif /* defined(WIN32) */ #include #include #include #include #include #include #if HAVE_UNISTD_H #include #endif /* HAVE_UNISTD_H */ #include #include #include #include "json.h" #include "json_util.h" #include "snprintf_compat.h" static void test_read_valid_with_fd(const char *testdir); static void test_read_valid_nested_with_fd(const char *testdir); static void test_read_nonexistant(void); static void test_read_closed(void); static void test_write_to_file(void); static void stat_and_cat(const char *file); static void test_read_fd_equal(const char *testdir); #ifndef PATH_MAX #define PATH_MAX 256 #endif static void test_write_to_file(void) { json_object *jso; jso = json_tokener_parse("{" "\"foo\":1234," "\"foo1\":\"abcdefghijklmnopqrstuvwxyz\"," "\"foo2\":\"abcdefghijklmnopqrstuvwxyz\"," "\"foo3\":\"abcdefghijklmnopqrstuvwxyz\"," "\"foo4\":\"abcdefghijklmnopqrstuvwxyz\"," "\"foo5\":\"abcdefghijklmnopqrstuvwxyz\"," "\"foo6\":\"abcdefghijklmnopqrstuvwxyz\"," "\"foo7\":\"abcdefghijklmnopqrstuvwxyz\"," "\"foo8\":\"abcdefghijklmnopqrstuvwxyz\"," "\"foo9\":\"abcdefghijklmnopqrstuvwxyz\"" "}"); const char *outfile = "json.out"; int rv = json_object_to_file(outfile, jso); printf("%s: json_object_to_file(%s, jso)=%d\n", (rv == 0) ? "OK" : "FAIL", outfile, rv); if (rv == 0) stat_and_cat(outfile); putchar('\n'); const char *outfile2 = "json2.out"; rv = json_object_to_file_ext(outfile2, jso, JSON_C_TO_STRING_PRETTY); printf("%s: json_object_to_file_ext(%s, jso, JSON_C_TO_STRING_PRETTY)=%d\n", (rv == 0) ? "OK" : "FAIL", outfile2, rv); if (rv == 0) stat_and_cat(outfile2); const char *outfile3 = "json3.out"; int d = open(outfile3, O_WRONLY | O_CREAT, 0600); if (d < 0) { printf("FAIL: unable to open %s %s\n", outfile3, strerror(errno)); return; } rv = json_object_to_fd(d, jso, JSON_C_TO_STRING_PRETTY); printf("%s: json_object_to_fd(%s, jso, JSON_C_TO_STRING_PRETTY)=%d\n", (rv == 0) ? "OK" : "FAIL", outfile3, rv); // Write the same object twice rv = json_object_to_fd(d, jso, JSON_C_TO_STRING_PLAIN); printf("%s: json_object_to_fd(%s, jso, JSON_C_TO_STRING_PLAIN)=%d\n", (rv == 0) ? "OK" : "FAIL", outfile3, rv); close(d); if (rv == 0) stat_and_cat(outfile3); json_object_put(jso); } static void stat_and_cat(const char *file) { struct stat sb; int d = open(file, O_RDONLY); if (d < 0) { printf("FAIL: unable to open %s: %s\n", file, strerror(errno)); return; } if (fstat(d, &sb) < 0) { printf("FAIL: unable to stat %s: %s\n", file, strerror(errno)); close(d); return; } char *buf = malloc(sb.st_size + 1); if (!buf) { printf("FAIL: unable to allocate memory\n"); close(d); return; } if (read(d, buf, sb.st_size) < sb.st_size) { printf("FAIL: unable to read all of %s: %s\n", file, strerror(errno)); free(buf); close(d); return; } buf[sb.st_size] = '\0'; printf("file[%s], size=%d, contents=%s\n", file, (int)sb.st_size, buf); free(buf); close(d); } int main(int argc, char **argv) { // json_object_to_file(file, obj); // json_object_to_file_ext(file, obj, flags); const char *testdir; if (argc < 2) { fprintf(stderr, "Usage: %s \n" " is the location of input files\n", argv[0]); return EXIT_FAILURE; } testdir = argv[1]; // Test json_c_version.c if (strncmp(json_c_version(), JSON_C_VERSION, sizeof(JSON_C_VERSION))) { printf("FAIL: Output from json_c_version(): %s " "does not match %s", json_c_version(), JSON_C_VERSION); return EXIT_FAILURE; } if (json_c_version_num() != JSON_C_VERSION_NUM) { printf("FAIL: Output from json_c_version_num(): %d " "does not match %d", json_c_version_num(), JSON_C_VERSION_NUM); return EXIT_FAILURE; } test_read_valid_with_fd(testdir); test_read_valid_nested_with_fd(testdir); test_read_nonexistant(); test_read_closed(); test_write_to_file(); test_read_fd_equal(testdir); return EXIT_SUCCESS; } static void test_read_valid_with_fd(const char *testdir) { char filename[PATH_MAX]; (void)snprintf(filename, sizeof(filename), "%s/valid.json", testdir); int d = open(filename, O_RDONLY); if (d < 0) { fprintf(stderr, "FAIL: unable to open %s: %s\n", filename, strerror(errno)); exit(EXIT_FAILURE); } json_object *jso = json_object_from_fd(d); if (jso != NULL) { printf("OK: json_object_from_fd(valid.json)=%s\n", json_object_to_json_string(jso)); json_object_put(jso); } else { fprintf(stderr, "FAIL: unable to parse contents of %s: %s\n", filename, json_util_get_last_err()); } close(d); } static void test_read_valid_nested_with_fd(const char *testdir) { char filename[PATH_MAX]; (void)snprintf(filename, sizeof(filename), "%s/valid_nested.json", testdir); int d = open(filename, O_RDONLY); if (d < 0) { fprintf(stderr, "FAIL: unable to open %s: %s\n", filename, strerror(errno)); exit(EXIT_FAILURE); } assert(NULL == json_object_from_fd_ex(d, -2)); json_object *jso = json_object_from_fd_ex(d, 20); if (jso != NULL) { printf("OK: json_object_from_fd_ex(valid_nested.json, 20)=%s\n", json_object_to_json_string(jso)); json_object_put(jso); } else { fprintf(stderr, "FAIL: unable to parse contents of %s: %s\n", filename, json_util_get_last_err()); } (void)lseek(d, SEEK_SET, 0); jso = json_object_from_fd_ex(d, 3); if (jso != NULL) { printf("FAIL: json_object_from_fd_ex(%s, 3)=%s\n", filename, json_object_to_json_string(jso)); json_object_put(jso); } else { printf("OK: correctly unable to parse contents of valid_nested.json with low max " "depth: %s\n", json_util_get_last_err()); } close(d); } static void test_read_nonexistant(void) { const char *filename = "./not_present.json"; json_object *jso = json_object_from_file(filename); if (jso != NULL) { printf("FAIL: json_object_from_file(%s) returned %p when NULL expected\n", filename, (void *)jso); json_object_put(jso); } else { printf("OK: json_object_from_file(%s) correctly returned NULL: %s\n", filename, json_util_get_last_err()); } } static void test_read_closed(void) { // Test reading from a closed fd int d = open("/dev/null", O_RDONLY); if (d < 0) { puts("FAIL: unable to open"); } // Copy over to a fixed fd number so test output is consistent. int fixed_d = 10; if (dup2(d, fixed_d) < 0) { printf("FAIL: unable to dup to fd %d", fixed_d); } close(d); close(fixed_d); json_object *jso = json_object_from_fd(fixed_d); if (jso != NULL) { printf("FAIL: read from closed fd returning non-NULL: %p\n", (void *)jso); fflush(stdout); printf(" jso=%s\n", json_object_to_json_string(jso)); json_object_put(jso); return; } printf("OK: json_object_from_fd(closed_fd), " "expecting NULL, EBADF, got:NULL, %s\n", json_util_get_last_err()); } static void test_read_fd_equal(const char *testdir) { char filename[PATH_MAX]; (void)snprintf(filename, sizeof(filename), "%s/valid_nested.json", testdir); json_object *jso = json_object_from_file(filename); int d = open(filename, O_RDONLY); if (d < 0) { fprintf(stderr, "FAIL: unable to open %s: %s\n", filename, strerror(errno)); exit(EXIT_FAILURE); } json_object *new_jso = json_object_from_fd(d); close(d); printf("OK: json_object_from_file(valid.json)=%s\n", json_object_to_json_string(jso)); printf("OK: json_object_from_fd(valid.json)=%s\n", json_object_to_json_string(new_jso)); json_object_put(jso); json_object_put(new_jso); } json-c-json-c-0.17-20230812/tests/test_util_file.expected000066400000000000000000000047341446575330000226370ustar00rootroot00000000000000OK: json_object_from_fd(valid.json)={ "foo": 123 } OK: json_object_from_fd_ex(valid_nested.json, 20)={ "foo": 123, "obj2": { "obj3": { "obj4": { "foo": 999 } } } } OK: correctly unable to parse contents of valid_nested.json with low max depth: json_tokener_parse_ex failed: nesting too deep OK: json_object_from_file(./not_present.json) correctly returned NULL: json_object_from_file: error opening file ./not_present.json: ERRNO=ENOENT OK: json_object_from_fd(closed_fd), expecting NULL, EBADF, got:NULL, json_object_from_fd_ex: error reading fd 10: ERRNO=EBADF OK: json_object_to_file(json.out, jso)=0 file[json.out], size=336, contents={"foo":1234,"foo1":"abcdefghijklmnopqrstuvwxyz","foo2":"abcdefghijklmnopqrstuvwxyz","foo3":"abcdefghijklmnopqrstuvwxyz","foo4":"abcdefghijklmnopqrstuvwxyz","foo5":"abcdefghijklmnopqrstuvwxyz","foo6":"abcdefghijklmnopqrstuvwxyz","foo7":"abcdefghijklmnopqrstuvwxyz","foo8":"abcdefghijklmnopqrstuvwxyz","foo9":"abcdefghijklmnopqrstuvwxyz"} OK: json_object_to_file_ext(json2.out, jso, JSON_C_TO_STRING_PRETTY)=0 file[json2.out], size=367, contents={ "foo":1234, "foo1":"abcdefghijklmnopqrstuvwxyz", "foo2":"abcdefghijklmnopqrstuvwxyz", "foo3":"abcdefghijklmnopqrstuvwxyz", "foo4":"abcdefghijklmnopqrstuvwxyz", "foo5":"abcdefghijklmnopqrstuvwxyz", "foo6":"abcdefghijklmnopqrstuvwxyz", "foo7":"abcdefghijklmnopqrstuvwxyz", "foo8":"abcdefghijklmnopqrstuvwxyz", "foo9":"abcdefghijklmnopqrstuvwxyz" } OK: json_object_to_fd(json3.out, jso, JSON_C_TO_STRING_PRETTY)=0 OK: json_object_to_fd(json3.out, jso, JSON_C_TO_STRING_PLAIN)=0 file[json3.out], size=703, contents={ "foo":1234, "foo1":"abcdefghijklmnopqrstuvwxyz", "foo2":"abcdefghijklmnopqrstuvwxyz", "foo3":"abcdefghijklmnopqrstuvwxyz", "foo4":"abcdefghijklmnopqrstuvwxyz", "foo5":"abcdefghijklmnopqrstuvwxyz", "foo6":"abcdefghijklmnopqrstuvwxyz", "foo7":"abcdefghijklmnopqrstuvwxyz", "foo8":"abcdefghijklmnopqrstuvwxyz", "foo9":"abcdefghijklmnopqrstuvwxyz" }{"foo":1234,"foo1":"abcdefghijklmnopqrstuvwxyz","foo2":"abcdefghijklmnopqrstuvwxyz","foo3":"abcdefghijklmnopqrstuvwxyz","foo4":"abcdefghijklmnopqrstuvwxyz","foo5":"abcdefghijklmnopqrstuvwxyz","foo6":"abcdefghijklmnopqrstuvwxyz","foo7":"abcdefghijklmnopqrstuvwxyz","foo8":"abcdefghijklmnopqrstuvwxyz","foo9":"abcdefghijklmnopqrstuvwxyz"} OK: json_object_from_file(valid.json)={ "foo": 123, "obj2": { "obj3": { "obj4": { "foo": 999 } } } } OK: json_object_from_fd(valid.json)={ "foo": 123, "obj2": { "obj3": { "obj4": { "foo": 999 } } } } json-c-json-c-0.17-20230812/tests/test_util_file.test000077700000000000000000000000001446575330000250212test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/test_visit.c000066400000000000000000000112601446575330000204320ustar00rootroot00000000000000#ifdef NDEBUG #undef NDEBUG #endif #include #include #include #include #include #include "json.h" #include "json_tokener.h" #include "json_visit.h" static json_c_visit_userfunc emit_object; static json_c_visit_userfunc skip_arrays; static json_c_visit_userfunc pop_and_stop; static json_c_visit_userfunc err_on_subobj2; static json_c_visit_userfunc pop_array; static json_c_visit_userfunc stop_array; static json_c_visit_userfunc err_return; int main(void) { MC_SET_DEBUG(1); const char *input = "{\ \"obj1\": 123,\ \"obj2\": {\ \"subobj1\": \"aaa\",\ \"subobj2\": \"bbb\",\ \"subobj3\": [ \"elem1\", \"elem2\", true ],\ },\ \"obj3\": 1.234,\ \"obj4\": [ true, false, null ]\ }"; json_object *jso = json_tokener_parse(input); printf("jso.to_string()=%s\n", json_object_to_json_string(jso)); int rv; rv = json_c_visit(jso, 0, emit_object, NULL); printf("json_c_visit(emit_object)=%d\n", rv); printf("================================\n\n"); rv = json_c_visit(jso, 0, skip_arrays, NULL); printf("json_c_visit(skip_arrays)=%d\n", rv); printf("================================\n\n"); rv = json_c_visit(jso, 0, pop_and_stop, NULL); printf("json_c_visit(pop_and_stop)=%d\n", rv); printf("================================\n\n"); rv = json_c_visit(jso, 0, err_on_subobj2, NULL); printf("json_c_visit(err_on_subobj2)=%d\n", rv); printf("================================\n\n"); rv = json_c_visit(jso, 0, pop_array, NULL); printf("json_c_visit(pop_array)=%d\n", rv); printf("================================\n\n"); rv = json_c_visit(jso, 0, stop_array, NULL); printf("json_c_visit(stop_array)=%d\n", rv); printf("================================\n\n"); rv = json_c_visit(jso, 0, err_return, NULL); printf("json_c_visit(err_return)=%d\n", rv); printf("================================\n\n"); json_object_put(jso); return 0; } static int emit_object(json_object *jso, int flags, json_object *parent_jso, const char *jso_key, size_t *jso_index, void *userarg) { printf("flags: 0x%x, key: %s, index: %ld, value: %s\n", flags, (jso_key ? jso_key : "(null)"), (jso_index ? (long)*jso_index : -1L), json_object_to_json_string(jso)); return JSON_C_VISIT_RETURN_CONTINUE; } static int skip_arrays(json_object *jso, int flags, json_object *parent_jso, const char *jso_key, size_t *jso_index, void *userarg) { (void)emit_object(jso, flags, parent_jso, jso_key, jso_index, userarg); if (json_object_get_type(jso) == json_type_array) return JSON_C_VISIT_RETURN_SKIP; return JSON_C_VISIT_RETURN_CONTINUE; } static int pop_and_stop(json_object *jso, int flags, json_object *parent_jso, const char *jso_key, size_t *jso_index, void *userarg) { (void)emit_object(jso, flags, parent_jso, jso_key, jso_index, userarg); if (jso_key != NULL && strcmp(jso_key, "subobj1") == 0) { printf("POP after handling subobj1\n"); return JSON_C_VISIT_RETURN_POP; } if (jso_key != NULL && strcmp(jso_key, "obj3") == 0) { printf("STOP after handling obj3\n"); return JSON_C_VISIT_RETURN_STOP; } return JSON_C_VISIT_RETURN_CONTINUE; } static int err_on_subobj2(json_object *jso, int flags, json_object *parent_jso, const char *jso_key, size_t *jso_index, void *userarg) { (void)emit_object(jso, flags, parent_jso, jso_key, jso_index, userarg); if (jso_key != NULL && strcmp(jso_key, "subobj2") == 0) { printf("ERROR after handling subobj1\n"); return JSON_C_VISIT_RETURN_ERROR; } return JSON_C_VISIT_RETURN_CONTINUE; } static int pop_array(json_object *jso, int flags, json_object *parent_jso, const char *jso_key, size_t *jso_index, void *userarg) { (void)emit_object(jso, flags, parent_jso, jso_key, jso_index, userarg); if (jso_index != NULL && (*jso_index == 0)) { printf("POP after handling array[0]\n"); return JSON_C_VISIT_RETURN_POP; } return JSON_C_VISIT_RETURN_CONTINUE; } static int stop_array(json_object *jso, int flags, json_object *parent_jso, const char *jso_key, size_t *jso_index, void *userarg) { (void)emit_object(jso, flags, parent_jso, jso_key, jso_index, userarg); if (jso_index != NULL && (*jso_index == 0)) { printf("STOP after handling array[1]\n"); return JSON_C_VISIT_RETURN_STOP; } return JSON_C_VISIT_RETURN_CONTINUE; } static int err_return(json_object *jso, int flags, json_object *parent_jso, const char *jso_key, size_t *jso_index, void *userarg) { printf("flags: 0x%x, key: %s, index: %ld, value: %s\n", flags, (jso_key ? jso_key : "(null)"), (jso_index ? (long)*jso_index : -1L), json_object_to_json_string(jso)); return 100; } json-c-json-c-0.17-20230812/tests/test_visit.expected000066400000000000000000000136561446575330000220240ustar00rootroot00000000000000jso.to_string()={ "obj1": 123, "obj2": { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] }, "obj3": 1.234, "obj4": [ true, false, null ] } flags: 0x0, key: (null), index: -1, value: { "obj1": 123, "obj2": { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] }, "obj3": 1.234, "obj4": [ true, false, null ] } flags: 0x0, key: obj1, index: -1, value: 123 flags: 0x0, key: obj2, index: -1, value: { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] } flags: 0x0, key: subobj1, index: -1, value: "aaa" flags: 0x0, key: subobj2, index: -1, value: "bbb" flags: 0x0, key: subobj3, index: -1, value: [ "elem1", "elem2", true ] flags: 0x0, key: (null), index: 0, value: "elem1" flags: 0x0, key: (null), index: 1, value: "elem2" flags: 0x0, key: (null), index: 2, value: true flags: 0x2, key: subobj3, index: -1, value: [ "elem1", "elem2", true ] flags: 0x2, key: obj2, index: -1, value: { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] } flags: 0x0, key: obj3, index: -1, value: 1.234 flags: 0x0, key: obj4, index: -1, value: [ true, false, null ] flags: 0x0, key: (null), index: 0, value: true flags: 0x0, key: (null), index: 1, value: false flags: 0x0, key: (null), index: 2, value: null flags: 0x2, key: obj4, index: -1, value: [ true, false, null ] flags: 0x2, key: (null), index: -1, value: { "obj1": 123, "obj2": { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] }, "obj3": 1.234, "obj4": [ true, false, null ] } json_c_visit(emit_object)=0 ================================ flags: 0x0, key: (null), index: -1, value: { "obj1": 123, "obj2": { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] }, "obj3": 1.234, "obj4": [ true, false, null ] } flags: 0x0, key: obj1, index: -1, value: 123 flags: 0x0, key: obj2, index: -1, value: { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] } flags: 0x0, key: subobj1, index: -1, value: "aaa" flags: 0x0, key: subobj2, index: -1, value: "bbb" flags: 0x0, key: subobj3, index: -1, value: [ "elem1", "elem2", true ] flags: 0x2, key: obj2, index: -1, value: { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] } flags: 0x0, key: obj3, index: -1, value: 1.234 flags: 0x0, key: obj4, index: -1, value: [ true, false, null ] flags: 0x2, key: (null), index: -1, value: { "obj1": 123, "obj2": { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] }, "obj3": 1.234, "obj4": [ true, false, null ] } json_c_visit(skip_arrays)=0 ================================ flags: 0x0, key: (null), index: -1, value: { "obj1": 123, "obj2": { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] }, "obj3": 1.234, "obj4": [ true, false, null ] } flags: 0x0, key: obj1, index: -1, value: 123 flags: 0x0, key: obj2, index: -1, value: { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] } flags: 0x0, key: subobj1, index: -1, value: "aaa" POP after handling subobj1 flags: 0x2, key: obj2, index: -1, value: { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] } flags: 0x0, key: obj3, index: -1, value: 1.234 STOP after handling obj3 json_c_visit(pop_and_stop)=0 ================================ flags: 0x0, key: (null), index: -1, value: { "obj1": 123, "obj2": { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] }, "obj3": 1.234, "obj4": [ true, false, null ] } flags: 0x0, key: obj1, index: -1, value: 123 flags: 0x0, key: obj2, index: -1, value: { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] } flags: 0x0, key: subobj1, index: -1, value: "aaa" flags: 0x0, key: subobj2, index: -1, value: "bbb" ERROR after handling subobj1 json_c_visit(err_on_subobj2)=-1 ================================ flags: 0x0, key: (null), index: -1, value: { "obj1": 123, "obj2": { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] }, "obj3": 1.234, "obj4": [ true, false, null ] } flags: 0x0, key: obj1, index: -1, value: 123 flags: 0x0, key: obj2, index: -1, value: { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] } flags: 0x0, key: subobj1, index: -1, value: "aaa" flags: 0x0, key: subobj2, index: -1, value: "bbb" flags: 0x0, key: subobj3, index: -1, value: [ "elem1", "elem2", true ] flags: 0x0, key: (null), index: 0, value: "elem1" POP after handling array[0] flags: 0x2, key: subobj3, index: -1, value: [ "elem1", "elem2", true ] flags: 0x2, key: obj2, index: -1, value: { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] } flags: 0x0, key: obj3, index: -1, value: 1.234 flags: 0x0, key: obj4, index: -1, value: [ true, false, null ] flags: 0x0, key: (null), index: 0, value: true POP after handling array[0] flags: 0x2, key: obj4, index: -1, value: [ true, false, null ] flags: 0x2, key: (null), index: -1, value: { "obj1": 123, "obj2": { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] }, "obj3": 1.234, "obj4": [ true, false, null ] } json_c_visit(pop_array)=0 ================================ flags: 0x0, key: (null), index: -1, value: { "obj1": 123, "obj2": { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] }, "obj3": 1.234, "obj4": [ true, false, null ] } flags: 0x0, key: obj1, index: -1, value: 123 flags: 0x0, key: obj2, index: -1, value: { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] } flags: 0x0, key: subobj1, index: -1, value: "aaa" flags: 0x0, key: subobj2, index: -1, value: "bbb" flags: 0x0, key: subobj3, index: -1, value: [ "elem1", "elem2", true ] flags: 0x0, key: (null), index: 0, value: "elem1" STOP after handling array[1] json_c_visit(stop_array)=0 ================================ flags: 0x0, key: (null), index: -1, value: { "obj1": 123, "obj2": { "subobj1": "aaa", "subobj2": "bbb", "subobj3": [ "elem1", "elem2", true ] }, "obj3": 1.234, "obj4": [ true, false, null ] } json_c_visit(err_return)=-1 ================================ json-c-json-c-0.17-20230812/tests/test_visit.test000077700000000000000000000000001446575330000242032test_basic.testustar00rootroot00000000000000json-c-json-c-0.17-20230812/tests/valid.json000066400000000000000000000000141446575330000200560ustar00rootroot00000000000000{"foo":123} json-c-json-c-0.17-20230812/tests/valid_nested.json000066400000000000000000000000751446575330000214270ustar00rootroot00000000000000{"foo":123, "obj2": { "obj3": { "obj4": { "foo": 999 } } } } json-c-json-c-0.17-20230812/vasprintf_compat.h000066400000000000000000000023371446575330000204640ustar00rootroot00000000000000#ifndef __vasprintf_compat_h #define __vasprintf_compat_h /** * @file * @brief Do not use, json-c internal, may be changed or removed at any time. */ #include "snprintf_compat.h" #ifndef WIN32 #include #endif /* !defined(WIN32) */ #include #include #if !defined(HAVE_VASPRINTF) /* CAW: compliant version of vasprintf */ static int vasprintf(char **buf, const char *fmt, va_list ap) { #ifndef WIN32 static char _T_emptybuffer = '\0'; va_list ap2; #endif /* !defined(WIN32) */ int chars; char *b; if (!buf) { return -1; } #ifdef WIN32 chars = _vscprintf(fmt, ap); #else /* !defined(WIN32) */ /* CAW: RAWR! We have to hope to god here that vsnprintf doesn't overwrite * our buffer like on some 64bit sun systems... but hey, it's time to move on */ va_copy(ap2, ap); chars = vsnprintf(&_T_emptybuffer, 0, fmt, ap2); va_end(ap2); #endif /* defined(WIN32) */ if (chars < 0 || (size_t)chars + 1 > SIZE_MAX / sizeof(char)) { return -1; } b = (char *)malloc(sizeof(char) * ((size_t)chars + 1)); if (!b) { return -1; } if ((chars = vsprintf(b, fmt, ap)) < 0) { free(b); } else { *buf = b; } return chars; } #endif /* !HAVE_VASPRINTF */ #endif /* __vasprintf_compat_h */