mozilla
/
releases-comm-central
зеркало из https://github.com/mozilla/releases-comm-central.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1752069 - Update json-c to 0.15. r=kaie 

Differential Revision: https://phabricator.services.mozilla.com/D136983
This commit is contained in:
Rob Lemley 2022-01-25 19:43:06 +00:00
Родитель 7ab8ea84b8
Коммит 7e6cee7574
49 изменённых файлов: 4841 добавлений и 3406 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

32
third_party/README.json-c поставляемый
Просмотреть файл

@ -1,41 +1,33 @@
Directory ./json-c contains a copy of version 0.13.1 of the json-c library,
which has been obtained from https://s3.amazonaws.com/json-c_releases/releases/json-c-0.13.1-nodoc.tar.gz .
Directory ./json-c contains a copy of version 0.15 of the json-c library,
which has been obtained from https://s3.amazonaws.com/json-c_releases/releases/json-c-0.15-nodoc.tar.gz .
(Link at https://github.com/json-c/json-c/wiki).
For licensing information, please refer to the included documentation.
The SHA256SUM of the imported file is:
94a26340c0785fcff4f46ff38609cf84ebcd670df0c8efd75d039cc951d80132 json-c-0.13.1-nodoc.tar.gz
99bca4f944b8ced8ae0bbc6310d6a3528ca715e69541793a1ef51f8c5b4b0878 json-c-0.15-nodoc.tar.gz
The following files and directories were removed from the source distribution's root:
autoconf-archive/
.github/
apps/
bench/
cmake/
fuzz/
tests/
.clang-format
.editorconfig
.gitignore
.travis.yml
Android.configure.mk
CMakeLists.txt
Doxyfile
Makefile.am
Makefile.in
README
aclocal.m4
appveyor.yml
autogen.sh
compile
config.guess
config.sub
configure
configure.ac
depcomp
install-sh
json-c-uninstalled.pc.in
cmake-configure
json-c.pc.in
ltmain.sh
missing
test-driver
json-c.sym
The following files were added to the source's root by MZLA Technologies:
config.h.in (modified copy from cmake/config.h.in)
moz.build

33
third_party/json-c/AUTHORS поставляемый
Просмотреть файл

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

167
third_party/json-c/ChangeLog поставляемый
Просмотреть файл

@ -1,8 +1,154 @@
Next Release 0.15
=====================
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 creaed 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
* 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()
@ -12,6 +158,7 @@
* 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)
=================================
@ -26,7 +173,7 @@ See issues_closed_for_0.13.md for a complete list.
Deprecated and removed features:
--------------------------------
* All internal use of bits.h has been eliminated. The file will be removed.
Do not use: hexdigit(), error_ptr(), error_descrition() and it_error()
Do not use: hexdigit(), error_ptr(), error_descrition() and it_error()
* lh_abort() is deprecated. It will be removed.
Behavior changes:
@ -169,11 +316,11 @@ List of new functions added:
* Make the json_tokener_errors array local. It has been deprecated for
a while, and json_tokener_error_desc() should be used instead.
* change the floating point output format to %.17g so values with
* change the floating point output format to %.17g so values with
more than 6 digits show up in the output.
* Remove the old libjson.so name compatibility support. The library is
only created as libjson-c.so now and headers are only installed
only created as libjson-c.so now and headers are only installed
into the ${prefix}/json-c directory.
* When supported by the linker, add the -Bsymbolic-functions flag.
@ -239,7 +386,7 @@ List of new functions added:
* Allow json_tokener_parse_ex() to be re-used to parse multiple object.
Also, fix some parsing issues with capitalized hexadecimal numbers and
number in E notation.
* Add json_tokener_get_error() and json_tokener_error_desc() to better
* Add json_tokener_get_error() and json_tokener_error_desc() to better
encapsulate the process of retrieving errors while parsing.
* Various improvements to the documentation of many functions.
* Add new json_object_array_sort() function.
@ -286,7 +433,7 @@ List of new functions added:
Brent Miller, bdmiller at yahoo dash inc dot com
* Disable REFCOUNT_DEBUG by default in json_object.c
* Don't use this as a variable, so we can compile with a C++ compiler
* Add casts from void* to type of assignment when using malloc
* Add casts from void* to type of assignment when using malloc
* Add #ifdef __cplusplus guards to all of the headers
* Add typedefs for json_object, json_tokener, array_list, printbuf, lh_table
Michael Clark, <michael@metaparadigm.com>
@ -322,7 +469,7 @@ List of new functions added:
0.6
===
* Fix bug in escaping of control characters
Johan Björklund, johbjo09 at kth dot se
Johan Björklund, johbjo09 at kth dot se
* Remove include "config.h" from headers (should only
be included from .c files)
Michael Clark <michael@metaparadigm.com>
@ -370,13 +517,13 @@ List of new functions added:
Added a Win32/Win64 compliant implementation of strndup
* json_util.c - C. Watford (christopher.watford@gmail.com)
Added cast and mask to suffice size_t v. unsigned int conversion
correctness
correctness
* json_tokener.c - sign reversal issue on error info for nested object parse
spotted by Johan Björklund (johbjo09 at kth.se)
spotted by Johan Björklund (johbjo09 at kth.se)
* json_object.c - escape " in json_escape_str
* Change to automake and libtool to build shared and static library
Michael Clark <michael@metaparadigm.com>
0.1
===
* initial release

1
third_party/json-c/INSTALL поставляемый
Просмотреть файл

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

7
third_party/json-c/README.html поставляемый
Просмотреть файл

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

269
third_party/json-c/README.md поставляемый
Просмотреть файл

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

182
third_party/json-c/RELEASE_CHECKLIST.txt поставляемый
Просмотреть файл

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

30
third_party/json-c/STYLE.txt поставляемый Executable file → Normal file
Просмотреть файл

@ -4,22 +4,22 @@ When changing the style, commit that separately from other changes.
For new code and major changes to a function, switch to the official json-c style.
Official json-c style:
Aim for readability, not strict conformance to fixed style rules.
These rules are not comprehensive. Look to existing code for guidelines.
Indentation is tab based, with continuations of long lines starting with tabs then spaces for alignment.
Try to line up components of continuation lines with corresponding part of the line above (i.e. "indent -lp" effect), but avoid excessive identation tha causes extra line wraps.
e.g. (T=tab, S=space):
TTTTsome_long_func_call(arg1, arg2,
TTTTSSSSSSSSSSSSSSSSSSSarg3, arg4);
TTTTsome_reallly_really_long_func_name(arg1,
TTTTTarg2, arg3, arg4);
There should be a space between "if"/"while" and the following parenthesis.
"case" lines are indented at the same level as the "switch" statement.
Commas are followed by a single space.
Include spaces around most non-unary, non-postfix operators, "=", "==', "&", "||", etc...
Function calls have no space between the name and the parenthesis.
Curly braces go on their own line.
Curly braces may be omitted.
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.

203
third_party/json-c/arraylist.c поставляемый
Просмотреть файл

@ -14,12 +14,12 @@
#include <limits.h>
#ifdef STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#include <stdlib.h>
#include <string.h>
#endif /* STDC_HEADERS */
#if defined(HAVE_STRINGS_H) && !defined(_STRING_H) && !defined(__USE_BSD)
# include <strings.h>
#include <strings.h>
#endif /* HAVE_STRINGS_H */
#ifndef SIZE_T_MAX
@ -36,111 +36,166 @@
#include "arraylist.h"
struct array_list*
array_list_new(array_list_free_fn *free_fn)
struct array_list *array_list_new(array_list_free_fn *free_fn)
{
struct array_list *arr;
arr = (struct array_list*)calloc(1, sizeof(struct array_list));
if(!arr) return NULL;
arr->size = ARRAY_LIST_DEFAULT_SIZE;
arr->length = 0;
arr->free_fn = free_fn;
if(!(arr->array = (void**)calloc(sizeof(void*), arr->size))) {
free(arr);
return NULL;
}
return arr;
return array_list_new2(free_fn, ARRAY_LIST_DEFAULT_SIZE);
}
extern void
array_list_free(struct array_list *arr)
struct array_list *array_list_new2(array_list_free_fn *free_fn, int initial_size)
{
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);
struct array_list *arr;
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;
}
void*
array_list_get_idx(struct array_list *arr, size_t i)
extern void array_list_free(struct array_list *arr)
{
if(i >= arr->length) return NULL;
return arr->array[i];
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;
void *t;
size_t new_size;
if(max < arr->size) return 0;
/* Avoid undefined behaviour on size_t overflow */
if( arr->size >= SIZE_T_MAX / 2 )
new_size = max;
else
{
new_size = arr->size << 1;
if (new_size < max)
new_size = max;
}
if (new_size > (~((size_t)0)) / sizeof(void*)) return -1;
if (!(t = realloc(arr->array, new_size*sizeof(void*)))) return -1;
arr->array = (void**)t;
(void)memset(arr->array + arr->size, 0, (new_size-arr->size)*sizeof(void*));
arr->size = new_size;
return 0;
if (max < arr->size)
return 0;
/* Avoid undefined behaviour on size_t overflow */
if (arr->size >= SIZE_T_MAX / 2)
new_size = max;
else
{
new_size = arr->size << 1;
if (new_size < max)
new_size = max;
}
if (new_size > (~((size_t)0)) / sizeof(void *))
return -1;
if (!(t = realloc(arr->array, new_size * sizeof(void *))))
return -1;
arr->array = (void **)t;
arr->size = new_size;
return 0;
}
int
array_list_put_idx(struct array_list *arr, size_t idx, void *data)
int array_list_shrink(struct array_list *arr, size_t empty_slots)
{
if (idx > SIZE_T_MAX - 1 ) return -1;
if(array_list_expand_internal(arr, idx+1)) return -1;
if(idx < arr->length && arr->array[idx])
arr->free_fn(arr->array[idx]);
arr->array[idx] = data;
if(arr->length <= idx) arr->length = idx + 1;
return 0;
void *t;
size_t new_size;
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_add(struct array_list *arr, void *data)
//static inline int _array_list_put_idx(struct array_list *arr, size_t idx, void *data)
int array_list_put_idx(struct array_list *arr, size_t idx, void *data)
{
return array_list_put_idx(arr, arr->length, 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;
}
void
array_list_sort(struct array_list *arr, int(*sort_fn)(const void *, const void *))
int array_list_add(struct array_list *arr, void *data)
{
qsort(arr->array, arr->length, sizeof(arr->array[0]), sort_fn);
/* 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_bsearch(const void **key, struct array_list *arr,
int (*sort_fn)(const void *, const void *))
void array_list_sort(struct array_list *arr, int (*compar)(const void *, const void *))
{
return bsearch(key, arr->array, arr->length, sizeof(arr->array[0]),
sort_fn);
qsort(arr->array, arr->length, sizeof(arr->array[0]), compar);
}
size_t
array_list_length(struct array_list *arr)
void *array_list_bsearch(const void **key, struct array_list *arr,
int (*compar)(const void *, const void *))
{
return arr->length;
return bsearch(key, arr->array, arr->length, sizeof(arr->array[0]), compar);
}
int
array_list_del_idx( struct array_list *arr, size_t idx, size_t count )
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 ) {
if ( arr->array[i] ) arr->free_fn( arr->array[i] );
if (idx >= arr->length || stop > arr->length)
return -1;
for (i = idx; i < stop; ++i)
{
// 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*) );
memmove(arr->array + idx, arr->array + stop, (arr->length - stop) * sizeof(void *));
arr->length -= count;
return 0;
}

66
third_party/json-c/arraylist.h поставляемый
Просмотреть файл

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

36
third_party/json-c/bits.h поставляемый
Просмотреть файл

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

135
third_party/json-c/config.h.in поставляемый
Просмотреть файл

@ -1,14 +1,80 @@
/* config.h.in. Generated from configure.ac by autoheader. */
/* config.h.in. Modified for moz.build from cmake/config.h.in. */
/* Enable RDRAND Hardware RNG Hash Seed */
#undef ENABLE_RDRAND
/* Override json_c_get_random_seed() with custom code */
#undef OVERRIDE_GET_RANDOM_SEED
/* Enable partial threading support */
#undef ENABLE_THREADING
/* Define if .gnu.warning accepts long strings. */
#undef HAS_GNU_WARNING_LONG
/* Define to 1 if you have the <dlfcn.h> header file. */
#undef HAVE_DLFCN_H
/* Define to 1 if you have the <endian.h> header file. */
#undef HAVE_ENDIAN_H
/* Define to 1 if you have the <fcntl.h> header file. */
#undef HAVE_FCNTL_H
/* Define to 1 if you have the <inttypes.h> header file. */
#undef HAVE_INTTYPES_H
/* Define to 1 if you have the <limits.h> header file. */
#undef HAVE_LIMITS_H
/* Define to 1 if you have the <locale.h> header file. */
#undef HAVE_LOCALE_H
/* Define to 1 if you have the <memory.h> header file. */
#undef HAVE_MEMORY_H
/* Define to 1 if you have the <stdarg.h> header file. */
#undef HAVE_STDARG_H
/* Define to 1 if you have the <stdint.h> header file. */
#undef HAVE_STDINT_H
/* Define to 1 if you have the <stdlib.h> header file. */
#undef HAVE_STDLIB_H
/* Define to 1 if you have the <strings.h> header file. */
#undef HAVE_STRINGS_H
/* Define to 1 if you have the <string.h> header file. */
#undef HAVE_STRING_H
/* Define to 1 if you have the <syslog.h> header file. */
#undef HAVE_SYSLOG_H
/* Define to 1 if you have the <sys/cdefs.h> header file. */
#undef HAVE_SYS_CDEFS_H
/* Define to 1 if you have the <sys/param.h> header file. */
#undef HAVE_SYS_PARAM_H
/* Define to 1 if you have the <sys/resource.h> header file. */
#undef HAVE_SYS_RESOURCE_H
/* Define to 1 if you have the <sys/stat.h> header file. */
#undef HAVE_SYS_STAT_H
/* Define to 1 if you have the <sys/types.h> header file. */
#undef HAVE_SYS_TYPES_H
/* Define to 1 if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H
/* Define to 1 if you have the <xlocale.h> header file. */
#undef HAVE_XLOCALE_H
/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */
#undef HAVE_DOPRNT
/* Has atomic builtins */
#undef HAVE_ATOMIC_BUILTINS
@ -35,30 +101,6 @@
*/
#undef HAVE_DECL__ISNAN
/* Define to 1 if you have the <dlfcn.h> header file. */
#undef HAVE_DLFCN_H
/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */
#undef HAVE_DOPRNT
/* Define to 1 if you have the <endian.h> header file. */
#undef HAVE_ENDIAN_H
/* Define to 1 if you have the <fcntl.h> header file. */
#undef HAVE_FCNTL_H
/* Define to 1 if you have the <inttypes.h> header file. */
#undef HAVE_INTTYPES_H
/* Define to 1 if you have the <limits.h> header file. */
#undef HAVE_LIMITS_H
/* Define to 1 if you have the <locale.h> header file. */
#undef HAVE_LOCALE_H
/* Define to 1 if you have the <memory.h> header file. */
#undef HAVE_MEMORY_H
/* Define to 1 if you have the `open' function. */
#undef HAVE_OPEN
@ -71,14 +113,6 @@
/* Define to 1 if you have the `snprintf' function. */
#undef HAVE_SNPRINTF
/* Define to 1 if you have the <stdarg.h> header file. */
#undef HAVE_STDARG_H
/* Define to 1 if you have the <stdint.h> header file. */
#undef HAVE_STDINT_H
/* Define to 1 if you have the <stdlib.h> header file. */
#undef HAVE_STDLIB_H
/* Define to 1 if you have the `strcasecmp' function. */
#undef HAVE_STRCASECMP
@ -89,33 +123,9 @@
/* Define to 1 if you have the `strerror' function. */
#undef HAVE_STRERROR
/* Define to 1 if you have the <strings.h> header file. */
#undef HAVE_STRINGS_H
/* Define to 1 if you have the <string.h> header file. */
#undef HAVE_STRING_H
/* Define to 1 if you have the `strncasecmp' function. */
#undef HAVE_STRNCASECMP
/* Define to 1 if you have the <syslog.h> header file. */
#undef HAVE_SYSLOG_H
/* Define to 1 if you have the <sys/cdefs.h> header file. */
#undef HAVE_SYS_CDEFS_H
/* Define to 1 if you have the <sys/param.h> header file. */
#undef HAVE_SYS_PARAM_H
/* Define to 1 if you have the <sys/stat.h> header file. */
#undef HAVE_SYS_STAT_H
/* Define to 1 if you have the <sys/types.h> header file. */
#undef HAVE_SYS_TYPES_H
/* Define to 1 if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H
/* Define to 1 if you have the `uselocale' function. */
#undef HAVE_USELOCALE
@ -131,8 +141,8 @@
/* Define to 1 if you have the `vsyslog' function. */
#undef HAVE_VSYSLOG
/* Define to 1 if you have the <xlocale.h> header file. */
#undef HAVE_XLOCALE_H
/* Define if you have the `getrusage' function. */
#undef HAVE_GETRUSAGE
/* Have __thread */
#undef HAVE___THREAD
@ -140,10 +150,6 @@
/* Public define for json_inttypes.h */
#undef JSON_C_HAVE_INTTYPES_H
/* Define to the sub-directory in which libtool stores uninstalled libraries.
*/
#undef LT_OBJDIR
/* Name of package */
#undef PACKAGE
@ -180,6 +186,9 @@
/* The number of bytes in type size_t */
#undef SIZEOF_SIZE_T
/* The number of bytes in type ssize_t */
#undef SIZEOF_SSIZE_T
/* Specifier for __thread */
#undef SPEC___THREAD

205
third_party/json-c/config.h.win32 поставляемый
Просмотреть файл

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

63
third_party/json-c/debug.c поставляемый
Просмотреть файл

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

59
third_party/json-c/debug.h поставляемый
Просмотреть файл

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

507
third_party/json-c/issues_closed_for_0.13.md поставляемый
Просмотреть файл

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

202
third_party/json-c/issues_closed_for_0.14.md поставляемый Normal file
Просмотреть файл

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

10
third_party/json-c/json.h поставляемый
Просмотреть файл

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

1
third_party/json-c/json_c_version.c поставляемый
Просмотреть файл

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

33
third_party/json-c/json_c_version.h поставляемый
Просмотреть файл

@ -1,5 +1,5 @@
/*
* Copyright (c) 2012,2017 Eric Haszlakiewicz
* Copyright (c) 2012,2017,2019,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.
@ -12,19 +12,30 @@
#ifndef _json_c_version_h_
#define _json_c_version_h_
#ifdef __cplusplus
extern "C" {
#endif
#define JSON_C_MAJOR_VERSION 0
#define JSON_C_MINOR_VERSION 13
#define JSON_C_MICRO_VERSION 01
#define JSON_C_VERSION_NUM ((JSON_C_MAJOR_VERSION << 16) | \
(JSON_C_MINOR_VERSION << 8) | \
JSON_C_MICRO_VERSION)
#define JSON_C_VERSION "0.13.1"
#define JSON_C_MINOR_VERSION 15
#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.15"
#ifndef JSON_EXPORT
#if defined(_MSC_VER)
#define JSON_EXPORT __declspec(dllexport)
#else
#define JSON_EXPORT extern
#endif
#endif
/**
* @see JSON_C_VERSION
* @return the version of the json-c library as a string
*/
const char *json_c_version(void); /* Returns JSON_C_VERSION */
JSON_EXPORT const char *json_c_version(void); /* Returns JSON_C_VERSION */
/**
* The json-c version encoded into an int, with the low order 8 bits
@ -35,6 +46,10 @@ const char *json_c_version(void); /* Returns JSON_C_VERSION */
* @see JSON_C_VERSION_NUM
* @return the version of the json-c library as an int
*/
int json_c_version_num(void); /* Returns JSON_C_VERSION_NUM */
JSON_EXPORT int json_c_version_num(void); /* Returns JSON_C_VERSION_NUM */
#ifdef __cplusplus
}
#endif
#endif

1
third_party/json-c/json_inttypes.h поставляемый
Просмотреть файл

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

1372
third_party/json-c/json_object.c поставляемый
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

472
third_party/json-c/json_object.h поставляемый
Просмотреть файл

@ -17,31 +17,17 @@
#ifndef _json_object_h_
#define _json_object_h_
#ifdef __GNUC__
#define THIS_FUNCTION_IS_DEPRECATED(func) func __attribute__ ((deprecated))
#elif defined(_MSC_VER)
#define THIS_FUNCTION_IS_DEPRECATED(func) __declspec(deprecated) func
#elif defined(__clang__)
#define THIS_FUNCTION_IS_DEPRECATED(func) func __deprecated
#else
#define THIS_FUNCTION_IS_DEPRECATED(func) func
#endif
#ifdef __GNUC__
#define JSON_C_CONST_FUNCTION(func) func __attribute__((const))
#else
#define JSON_C_CONST_FUNCTION(func) func
#endif
#if defined(_MSC_VER)
#define JSON_EXPORT __declspec(dllexport)
#else
#define JSON_EXPORT extern
#endif
#include "json_inttypes.h"
#include "json_types.h"
#include "printbuf.h"
#include <stddef.h>
#include "json_inttypes.h"
#include "printbuf.h"
#ifdef __cplusplus
extern "C" {
@ -54,13 +40,13 @@ extern "C" {
* json_object_to_file_ext() functions which causes the output
* to have no extra whitespace or formatting applied.
*/
#define JSON_C_TO_STRING_PLAIN 0
#define JSON_C_TO_STRING_PLAIN 0
/**
* A flag for the json_object_to_json_string_ext() and
* json_object_to_file_ext() functions which causes the output to have
* minimal whitespace inserted to make things slightly more readable.
*/
#define JSON_C_TO_STRING_SPACED (1<<0)
#define JSON_C_TO_STRING_SPACED (1 << 0)
/**
* A flag for the json_object_to_json_string_ext() and
* json_object_to_file_ext() functions which causes
@ -69,7 +55,7 @@ extern "C" {
* See the "Two Space Tab" option at http://jsonformatter.curiousconcept.com/
* for an example of the format.
*/
#define JSON_C_TO_STRING_PRETTY (1<<1)
#define JSON_C_TO_STRING_PRETTY (1 << 1)
/**
* A flag for the json_object_to_json_string_ext() and
* json_object_to_file_ext() functions which causes
@ -77,28 +63,28 @@ extern "C" {
*
* Instead of a "Two Space Tab" this gives a single tab character.
*/
#define JSON_C_TO_STRING_PRETTY_TAB (1<<3)
#define JSON_C_TO_STRING_PRETTY_TAB (1 << 3)
/**
* A flag to drop trailing zero for float values
*/
#define JSON_C_TO_STRING_NOZERO (1<<2)
#define JSON_C_TO_STRING_NOZERO (1 << 2)
/**
* Don't escape forward slashes.
*/
#define JSON_C_TO_STRING_NOSLASHESCAPE (1<<4)
#define JSON_C_TO_STRING_NOSLASHESCAPE (1 << 4)
/**
* A flag for the json_object_object_add_ex function which
* causes the value to be added without a check if it already exists.
* Note: it is the responsibilty of the caller to ensure that no
* Note: it is the responsibility of the caller to ensure that no
* key is added multiple times. If this is done, results are
* unpredictable. While this option is somewhat dangerous, it
* permits potentially large performance savings in code that
* knows for sure the key values are unique (e.g. because the
* code adds a well-known set of constant key values).
*/
#define JSON_C_OBJECT_ADD_KEY_IS_NEW (1<<1)
#define JSON_C_OBJECT_ADD_KEY_IS_NEW (1 << 1)
/**
* A flag for the json_object_object_add_ex function which
* flags the key as being constant memory. This means that
@ -116,13 +102,7 @@ extern "C" {
* json_object_object_add_ex(obj, "ip", json,
* JSON_C_OBJECT_KEY_IS_CONSTANT);
*/
#define JSON_C_OBJECT_KEY_IS_CONSTANT (1<<2)
#undef FALSE
#define FALSE ((json_bool)0)
#undef TRUE
#define TRUE ((json_bool)1)
#define JSON_C_OBJECT_KEY_IS_CONSTANT (1 << 2)
/**
* Set the global value of an option, which will apply to all
@ -140,68 +120,46 @@ extern "C" {
*/
#define JSON_C_OPTION_THREAD (1)
/**
* A structure to use with json_object_object_foreachC() loops.
* Contains key, val and entry members.
*/
struct json_object_iter
{
char *key;
struct json_object *val;
struct lh_entry *entry;
};
typedef struct json_object_iter json_object_iter;
typedef int json_bool;
/**
* @brief The core type for all type of JSON objects handled by json-c
*/
typedef struct json_object json_object;
/**
* Type of custom user delete functions. See json_object_set_serializer.
*/
typedef void (json_object_delete_fn)(struct json_object *jso, void *userdata);
/**
* Type of a custom serialization function. See json_object_set_serializer.
*/
typedef int (json_object_to_json_string_fn)(struct json_object *jso,
struct printbuf *pb,
int level,
int flags);
/* supported object types */
typedef enum json_type {
/* If you change this, be sure to update json_type_to_name() too */
json_type_null,
json_type_boolean,
json_type_double,
json_type_int,
json_type_object,
json_type_array,
json_type_string
} json_type;
/* reference counting functions */
/**
* Increment the reference count of json_object, thereby grabbing shared
* ownership of obj.
* 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 necesarily 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);
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.
* 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);
@ -235,7 +193,6 @@ JSON_EXPORT int json_object_is_type(const struct json_object *obj, enum json_typ
*/
JSON_EXPORT enum json_type json_object_get_type(const struct json_object *obj);
/** Stringify object to json format.
* Equivalent to json_object_to_json_string_ext(obj, JSON_C_TO_STRING_SPACED)
* The pointer you get is an internal of your json object. You don't
@ -245,7 +202,7 @@ JSON_EXPORT enum json_type json_object_get_type(const struct json_object *obj);
* @param obj the json_object instance
* @returns a string in JSON format
*/
JSON_EXPORT const char* json_object_to_json_string(struct json_object *obj);
JSON_EXPORT const char *json_object_to_json_string(struct json_object *obj);
/** Stringify object to json format
* @see json_object_to_json_string() for details on how to free string.
@ -253,8 +210,7 @@ JSON_EXPORT const char* json_object_to_json_string(struct json_object *obj);
* @param flags formatting options, see JSON_C_TO_STRING_PRETTY and other constants
* @returns a string in JSON format
*/
JSON_EXPORT const char* json_object_to_json_string_ext(struct json_object *obj, int
flags);
JSON_EXPORT const char *json_object_to_json_string_ext(struct json_object *obj, int flags);
/** Stringify object to json format
* @see json_object_to_json_string() for details on how to free string.
@ -263,8 +219,8 @@ flags);
* @param length a pointer where, if not NULL, the length (without null) is stored
* @returns a string in JSON format and the length if not NULL
*/
JSON_EXPORT const char* json_object_to_json_string_length(struct json_object *obj, int
flags, size_t *length);
JSON_EXPORT const char *json_object_to_json_string_length(struct json_object *obj, int flags,
size_t *length);
/**
* Returns the userdata set by json_object_set_userdata() or
@ -272,7 +228,7 @@ flags, size_t *length);
*
* @param jso the object to return the userdata for
*/
JSON_EXPORT void* json_object_get_userdata(json_object *jso);
JSON_EXPORT void *json_object_get_userdata(json_object *jso);
/**
* Set an opaque userdata value for an object
@ -300,7 +256,7 @@ JSON_EXPORT void* json_object_get_userdata(json_object *jso);
* @param user_delete an optional function from freeing userdata
*/
JSON_EXPORT void json_object_set_userdata(json_object *jso, void *userdata,
json_object_delete_fn *user_delete);
json_object_delete_fn *user_delete);
/**
* Set a custom serialization function to be used when this particular object
@ -333,9 +289,8 @@ JSON_EXPORT void json_object_set_userdata(json_object *jso, void *userdata,
* @param user_delete an optional function from freeing userdata
*/
JSON_EXPORT void json_object_set_serializer(json_object *jso,
json_object_to_json_string_fn *to_string_func,
void *userdata,
json_object_delete_fn *user_delete);
json_object_to_json_string_fn *to_string_func,
void *userdata, json_object_delete_fn *user_delete);
#ifdef __clang__
/*
@ -354,7 +309,7 @@ JSON_EXPORT void json_object_set_serializer(json_object *jso,
* @param jso unused
* @param userdata the pointer that is passed to free().
*/
json_object_delete_fn json_object_free_userdata;
JSON_EXPORT json_object_delete_fn json_object_free_userdata;
/**
* Copy the jso->_userdata string over to pb as-is.
@ -365,14 +320,13 @@ json_object_delete_fn json_object_free_userdata;
* @param level Ignored.
* @param flags Ignored.
*/
json_object_to_json_string_fn json_object_userdata_to_json_string;
JSON_EXPORT json_object_to_json_string_fn json_object_userdata_to_json_string;
#ifdef __clang__
/* } */
#pragma clang diagnostic pop
#endif
/* object type methods */
/** Create a new empty object with a reference count of 1. The caller of
@ -385,18 +339,18 @@ json_object_to_json_string_fn json_object_userdata_to_json_string;
*
* @returns a json_object of type json_type_object
*/
JSON_EXPORT struct json_object* json_object_new_object(void);
JSON_EXPORT struct json_object *json_object_new_object(void);
/** Get the hashtable of a json_object of type json_type_object
* @param obj the json_object instance
* @returns a linkhash
*/
JSON_EXPORT struct lh_table* json_object_get_object(const struct json_object *obj);
JSON_EXPORT struct lh_table *json_object_get_object(const struct json_object *obj);
/** Get the size of an object in terms of the number of fields it has.
* @param obj the json_object whose length to return
*/
JSON_EXPORT int json_object_object_length(const struct json_object* obj);
JSON_EXPORT int json_object_object_length(const struct json_object *obj);
/** Get the sizeof (struct json_object).
* @returns a size_t with the sizeof (struct json_object)
@ -405,15 +359,21 @@ 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 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, independent of the lifetime of obj, you must wrap the
* passed object with json_object_get.
* 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)`)
*
* Upon calling this, the ownership of val transfers to obj. Thus you must
* make sure that you do in fact have ownership over this object. For instance,
* json_object_new_object will give you ownership until you transfer it,
* whereas json_object_object_get does not.
* 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)
@ -422,8 +382,8 @@ JSON_C_CONST_FUNCTION(JSON_EXPORT size_t json_c_object_sizeof(void));
* @return On success, <code>0</code> is returned.
* On error, a negative value is returned.
*/
JSON_EXPORT int json_object_object_add(struct json_object* obj, const char *key,
struct json_object *val);
JSON_EXPORT int json_object_object_add(struct json_object *obj, const char *key,
struct json_object *val);
/** Add an object field to a json_object of type json_type_object
*
@ -435,20 +395,18 @@ JSON_EXPORT int json_object_object_add(struct json_object* obj, const char *key,
* @param obj the json_object instance
* @param key the object field name (a private copy will be duplicated)
* @param val a json_object or NULL member to associate with the given field
* @param opts process-modifying options. To specify multiple options, use
* arithmetic or (OPT1|OPT2)
* @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);
JSON_EXPORT int json_object_object_add_ex(struct json_object *obj, const char *const key,
struct json_object *const val, const unsigned opts);
/** Get the json_object associate with a given object field.
* Deprecated/discouraged: used json_object_object_get_ex instead.
*
* This returns NULL if the field is found but its value is null, or if
* the field is not found, or if obj is not a json_type_object. If you
* need to distinguis between these cases, use json_object_object_get_ex().
* need to distinguish between these cases, use json_object_object_get_ex().
*
* *No* reference counts will be changed. There is no need to manually adjust
* reference counts through the json_object_put/json_object_get methods unless
@ -464,8 +422,8 @@ JSON_EXPORT int json_object_object_add_ex(struct json_object* obj,
* @param key the object field name
* @returns the json_object associated with the given field name
*/
JSON_EXPORT struct json_object* json_object_object_get(const struct json_object* obj,
const char *key);
JSON_EXPORT struct json_object *json_object_object_get(const struct json_object *obj,
const char *key);
/** Get the json_object associated with a given object field.
*
@ -485,9 +443,8 @@ JSON_EXPORT struct json_object* json_object_object_get(const struct json_object*
* It is safe to pass a NULL value.
* @returns whether or not the key exists
*/
JSON_EXPORT json_bool json_object_object_get_ex(const struct json_object* obj,
const char *key,
struct json_object **value);
JSON_EXPORT json_bool json_object_object_get_ex(const struct json_object *obj, const char *key,
struct json_object **value);
/** Delete the given json_object field
*
@ -498,7 +455,7 @@ JSON_EXPORT json_bool json_object_object_get_ex(const struct json_object* obj,
* @param obj the json_object instance
* @param key the object field name
*/
JSON_EXPORT void json_object_object_del(struct json_object* obj, const char *key);
JSON_EXPORT void json_object_object_del(struct json_object *obj, const char *key);
/**
* Iterate through all keys and values of an object.
@ -515,31 +472,35 @@ JSON_EXPORT void json_object_object_del(struct json_object* obj, const char *key
*/
#if defined(__GNUC__) && !defined(__STRICT_ANSI__) && __STDC_VERSION__ >= 199901L
# define json_object_object_foreach(obj,key,val) \
char *key = NULL; \
struct json_object *val __attribute__((__unused__)) = NULL; \
for(struct lh_entry *entry ## key = json_object_get_object(obj)->head, *entry_next ## key = NULL; \
({ if(entry ## key) { \
key = (char*)lh_entry_k(entry ## key); \
val = (struct json_object*)lh_entry_v(entry ## key); \
entry_next ## key = entry ## key->next; \
} ; entry ## key; }); \
entry ## key = entry_next ## key )
#define json_object_object_foreach(obj, key, val) \
char *key = NULL; \
struct json_object *val __attribute__((__unused__)) = NULL; \
for (struct lh_entry *entry##key = json_object_get_object(obj)->head, \
*entry_next##key = NULL; \
({ \
if (entry##key) \
{ \
key = (char *)lh_entry_k(entry##key); \
val = (struct json_object *)lh_entry_v(entry##key); \
entry_next##key = entry##key->next; \
}; \
entry##key; \
}); \
entry##key = entry_next##key)
#else /* ANSI C or MSC */
# define json_object_object_foreach(obj,key,val) \
char *key = NULL;\
struct json_object *val = NULL; \
struct lh_entry *entry ## key; \
struct lh_entry *entry_next ## key = NULL; \
for(entry ## key = json_object_get_object(obj)->head; \
(entry ## key ? ( \
key = (char*)lh_entry_k(entry ## key), \
val = (struct json_object*)lh_entry_v(entry ## key), \
entry_next ## key = entry ## key->next, \
entry ## key) : 0); \
entry ## key = entry_next ## key)
#define json_object_object_foreach(obj, key, val) \
char *key = NULL; \
struct json_object *val = NULL; \
struct lh_entry *entry##key; \
struct lh_entry *entry_next##key = NULL; \
for (entry##key = json_object_get_object(obj)->head; \
(entry##key ? (key = (char *)lh_entry_k(entry##key), \
val = (struct json_object *)lh_entry_v(entry##key), \
entry_next##key = entry##key->next, entry##key) \
: 0); \
entry##key = entry_next##key)
#endif /* defined(__GNUC__) && !defined(__STRICT_ANSI__) && __STDC_VERSION__ >= 199901L */
@ -547,23 +508,38 @@ JSON_EXPORT void json_object_object_del(struct json_object* obj, const char *key
* @param obj the json_object instance
* @param iter the object iterator, use type json_object_iter
*/
#define json_object_object_foreachC(obj,iter) \
for(iter.entry = json_object_get_object(obj)->head; \
(iter.entry ? (iter.key = (char*)lh_entry_k(iter.entry), iter.val = (struct json_object*)lh_entry_v(iter.entry), iter.entry) : 0); \
iter.entry = iter.entry->next)
#define json_object_object_foreachC(obj, iter) \
for (iter.entry = json_object_get_object(obj)->head; \
(iter.entry ? (iter.key = (char *)lh_entry_k(iter.entry), \
iter.val = (struct json_object *)lh_entry_v(iter.entry), iter.entry) \
: 0); \
iter.entry = iter.entry->next)
/* Array type methods */
/** Create a new empty json_object of type json_type_array
* 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);
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);
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
@ -579,7 +555,8 @@ JSON_EXPORT size_t json_object_array_length(const struct json_object *obj);
* @param jso the json_object instance
* @param sort_fn a sorting function
*/
JSON_EXPORT void json_object_array_sort(struct json_object *jso, int(*sort_fn)(const void *, const void *));
JSON_EXPORT void json_object_array_sort(struct json_object *jso,
int (*sort_fn)(const void *, const void *));
/** Binary search a sorted array for a specified key object.
*
@ -595,10 +572,9 @@ JSON_EXPORT void json_object_array_sort(struct json_object *jso, int(*sort_fn)(c
*
* @return the wanted json_object instance
*/
JSON_EXPORT struct json_object* json_object_array_bsearch(
const struct json_object *key,
const struct json_object *jso,
int (*sort_fn)(const void *, const void *));
JSON_EXPORT struct json_object *
json_object_array_bsearch(const struct json_object *key, const struct json_object *jso,
int (*sort_fn)(const void *, const void *));
/** Add an element to the end of a json_object of type json_type_array
*
@ -609,8 +585,7 @@ JSON_EXPORT struct json_object* json_object_array_bsearch(
* @param obj the json_object instance
* @param val the json_object to be added
*/
JSON_EXPORT int json_object_array_add(struct json_object *obj,
struct json_object *val);
JSON_EXPORT int json_object_array_add(struct json_object *obj, struct json_object *val);
/** Insert or replace an element at a specified index in an array (a json_object of type json_type_array)
*
@ -628,20 +603,28 @@ JSON_EXPORT int json_object_array_add(struct json_object *obj,
* @param val the json_object to be added
*/
JSON_EXPORT int json_object_array_put_idx(struct json_object *obj, size_t idx,
struct json_object *val);
struct json_object *val);
/** Get the element at specificed index of the array (a json_object of type json_type_array)
/** Get the element at specified index of 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);
JSON_EXPORT struct json_object *json_object_array_get_idx(const struct json_object *obj,
size_t idx);
/** Delete an elements from a specified index in an array (a json_object of type json_type_array)
*
* The reference count will be decremented for each of the deleted objects. If there
* are no more owners of an element that is being deleted, then the value is
* are no more owners of an element that is being deleted, then the value is
* freed. Otherwise, the reference to the value will remain in memory.
*
* @param obj the json_object instance
@ -651,40 +634,47 @@ JSON_EXPORT struct json_object* json_object_array_get_idx(const struct json_obje
*/
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 TRUE or FALSE (1 or 0)
* @param b a json_bool 1 or 0
* @returns a json_object of type json_type_boolean
*/
JSON_EXPORT struct json_object* json_object_new_boolean(json_bool b);
JSON_EXPORT struct json_object *json_object_new_boolean(json_bool b);
/** Get the json_bool value of a json_object
*
* The type is coerced to a json_bool if the passed object is not a json_bool.
* integer and double objects will return FALSE if there value is zero
* or TRUE otherwise. If the passed object is a string it will return
* TRUE if it has a non zero length. If any other object type is passed
* TRUE will be returned if the object is not NULL.
* integer and double objects will return 0 if there value is zero
* or 1 otherwise. If the passed object is a string it will return
* 1 if it has a non zero length. If any other object type is passed
* 1 will be returned if the object is not NULL.
*
* @param obj the json_object instance
* @returns a json_bool
*/
JSON_EXPORT json_bool json_object_get_boolean(const struct json_object *obj);
/** Set the json_bool value of a json_object
*
* The type of obj is checked to be a json_type_boolean and 0 is returned
*
* The type of obj is checked to be a json_type_boolean and 0 is returned
* if it is not without any further actions. If type of obj is json_type_boolean
* the obect value is chaned to new_value
* the object value is changed to new_value
*
* @param obj the json_object instance
* @param new_value the value to be set
* @returns 1 if value is set correctly, 0 otherwise
*/
JSON_EXPORT int json_object_set_boolean(struct json_object *obj,json_bool new_value);
JSON_EXPORT int json_object_set_boolean(struct json_object *obj, json_bool new_value);
/* int type methods */
@ -694,15 +684,19 @@ JSON_EXPORT int json_object_set_boolean(struct json_object *obj,json_bool new_va
* @param i the integer
* @returns a json_object of type json_type_int
*/
JSON_EXPORT struct json_object* json_object_new_int(int32_t i);
JSON_EXPORT struct json_object *json_object_new_int(int32_t i);
/** Create a new empty json_object of type json_type_int
* @param i the integer
* @returns a json_object of type json_type_int
*/
JSON_EXPORT struct json_object* json_object_new_int64(int64_t i);
JSON_EXPORT struct json_object *json_object_new_int64(int64_t i);
/** Create a new empty json_object of type json_type_uint
* @param i the integer
* @returns a json_object of type json_type_uint
*/
JSON_EXPORT struct json_object *json_object_new_uint64(uint64_t i);
/** Get the int value of a json_object
*
@ -721,16 +715,16 @@ JSON_EXPORT struct json_object* json_object_new_int64(int64_t i);
JSON_EXPORT int32_t json_object_get_int(const struct json_object *obj);
/** Set the int value of a json_object
*
* The type of obj is checked to be a json_type_int and 0 is returned
*
* The type of obj is checked to be a json_type_int and 0 is returned
* if it is not without any further actions. If type of obj is json_type_int
* the obect value is changed to new_value
* the object value is changed to new_value
*
* @param obj the json_object instance
* @param new_value the value to be set
* @returns 1 if value is set correctly, 0 otherwise
*/
JSON_EXPORT int json_object_set_int(struct json_object *obj,int new_value);
JSON_EXPORT int json_object_set_int(struct json_object *obj, int new_value);
/** Increment a json_type_int object by the given amount, which may be negative.
*
@ -748,7 +742,6 @@ JSON_EXPORT int json_object_set_int(struct json_object *obj,int new_value);
*/
JSON_EXPORT int json_object_int_inc(struct json_object *obj, int64_t val);
/** Get the int value of a json_object
*
* The type is coerced to a int64 if the passed object is not a int64.
@ -764,18 +757,44 @@ JSON_EXPORT int json_object_int_inc(struct json_object *obj, int64_t val);
*/
JSON_EXPORT int64_t json_object_get_int64(const struct json_object *obj);
/** Get the uint value of a json_object
*
* The type is coerced to a uint64 if the passed object is not a uint64.
* double objects will return their uint64 conversion. Strings will be
* parsed as an uint64. If no conversion exists then 0 is returned.
*
* NOTE: Set errno to 0 directly before a call to this function to determine
* whether or not conversion was successful (it does not clear the value for
* you).
*
* @param obj the json_object instance
* @returns an uint64
*/
JSON_EXPORT uint64_t json_object_get_uint64(const struct json_object *obj);
/** Set the int64_t value of a json_object
*
* The type of obj is checked to be a json_type_int and 0 is returned
*
* The type of obj is checked to be a json_type_int and 0 is returned
* if it is not without any further actions. If type of obj is json_type_int
* the obect value is chaned to new_value
* the object value is changed to new_value
*
* @param obj the json_object instance
* @param new_value the value to be set
* @returns 1 if value is set correctly, 0 otherwise
*/
JSON_EXPORT int json_object_set_int64(struct json_object *obj,int64_t new_value);
JSON_EXPORT int json_object_set_int64(struct json_object *obj, int64_t new_value);
/** Set the uint64_t value of a json_object
*
* The type of obj is checked to be a json_type_uint and 0 is returned
* if it is not without any further actions. If type of obj is json_type_uint
* the object value is changed to new_value
*
* @param obj the json_object instance
* @param new_value the value to be set
* @returns 1 if value is set correctly, 0 otherwise
*/
JSON_EXPORT int json_object_set_uint64(struct json_object *obj, uint64_t new_value);
/* double type methods */
@ -786,7 +805,7 @@ JSON_EXPORT int json_object_set_int64(struct json_object *obj,int64_t new_value)
* @param d the double
* @returns a json_object of type json_type_double
*/
JSON_EXPORT struct json_object* json_object_new_double(double d);
JSON_EXPORT struct json_object *json_object_new_double(double d);
/**
* Create a new json_object of type json_type_double, using
@ -804,7 +823,8 @@ JSON_EXPORT struct json_object* json_object_new_double(double d);
* The userdata field is used to store the string representation, so it
* can't be used for other data if this function is used.
*
* An equivalent sequence of calls is:
* A roughly equivalent sequence of calls, with the difference being that
* the serialization function won't be reset by json_object_set_double(), is:
* @code
* jso = json_object_new_double(d);
* json_object_set_serializer(jso, json_object_userdata_to_json_string,
@ -814,7 +834,7 @@ JSON_EXPORT struct json_object* json_object_new_double(double d);
* @param d the numeric value of the double.
* @param ds the string representation of the double. This will be copied.
*/
JSON_EXPORT struct json_object* json_object_new_double_s(double d, const char *ds);
JSON_EXPORT struct json_object *json_object_new_double_s(double d, const char *ds);
/**
* Set a global or thread-local json-c option, depending on whether
@ -828,9 +848,8 @@ JSON_EXPORT struct json_object* json_object_new_double_s(double d, const char *d
*
* @return -1 on errors, 0 on success.
*/
int json_c_set_serialization_double_format(const char *double_format, int global_or_thread);
JSON_EXPORT int json_c_set_serialization_double_format(const char *double_format,
int global_or_thread);
/** Serialize a json_object of type json_type_double to a string.
*
@ -851,10 +870,8 @@ int json_c_set_serialization_double_format(const char *double_format, int global
* @param level Ignored.
* @param flags Ignored.
*/
JSON_EXPORT int json_object_double_to_json_string(struct json_object* jso,
struct printbuf *pb,
int level,
int flags);
JSON_EXPORT int json_object_double_to_json_string(struct json_object *jso, struct printbuf *pb,
int level, int flags);
/** Get the double floating point value of a json_object
*
@ -881,20 +898,20 @@ JSON_EXPORT int json_object_double_to_json_string(struct json_object* jso,
*/
JSON_EXPORT double json_object_get_double(const struct json_object *obj);
/** Set the double value of a json_object
*
* The type of obj is checked to be a json_type_double and 0 is returned
*
* The type of obj is checked to be a json_type_double and 0 is returned
* if it is not without any further actions. If type of obj is json_type_double
* the obect value is chaned to new_value
* the object value is changed to new_value
*
* If the object was created with json_object_new_double_s(), the serialization
* function is reset to the default and the cached serialized value is cleared.
*
* @param obj the json_object instance
* @param new_value the value to be set
* @returns 1 if value is set correctly, 0 otherwise
*/
JSON_EXPORT int json_object_set_double(struct json_object *obj,double new_value);
JSON_EXPORT int json_object_set_double(struct json_object *obj, double new_value);
/* string type methods */
@ -904,10 +921,21 @@ JSON_EXPORT int json_object_set_double(struct json_object *obj,double new_value)
*
* @param s the string
* @returns a json_object of type json_type_string
* @see json_object_new_string_len()
*/
JSON_EXPORT struct json_object* json_object_new_string(const char *s);
JSON_EXPORT struct json_object *json_object_new_string(const char *s);
JSON_EXPORT struct json_object* json_object_new_string_len(const char *s, int len);
/** Create a new empty json_object of type json_type_string and allocate
* len characters for the new string.
*
* A copy of the string is made and the memory is managed by the json_object
*
* @param s the string
* @param len max length of the new string
* @returns a json_object of type json_type_string
* @see json_object_new_string()
*/
JSON_EXPORT struct json_object *json_object_new_string_len(const char *s, const int len);
/** Get the string value of a json_object
*
@ -925,7 +953,7 @@ JSON_EXPORT struct json_object* json_object_new_string_len(const char *s, int le
* @param obj the json_object instance
* @returns a string or NULL
*/
JSON_EXPORT const char* json_object_get_string(struct json_object *obj);
JSON_EXPORT const char *json_object_get_string(struct json_object *obj);
/** Get the string length of a json_object
*
@ -937,25 +965,30 @@ JSON_EXPORT const char* json_object_get_string(struct json_object *obj);
*/
JSON_EXPORT int json_object_get_string_len(const struct json_object *obj);
/** Set the string value of a json_object with zero terminated strings
* equivalent to json_object_set_string_len (obj, new_value, strlen(new_value))
* @returns 1 if value is set correctly, 0 otherwise
*/
JSON_EXPORT int json_object_set_string(json_object* obj, const char* new_value);
JSON_EXPORT int json_object_set_string(json_object *obj, const char *new_value);
/** Set the string value of a json_object str
*
* The type of obj is checked to be a json_type_string and 0 is returned
*
* The type of obj is checked to be a json_type_string and 0 is returned
* if it is not without any further actions. If type of obj is json_type_string
* the obect value is chaned to new_value
* the object value is changed to new_value
*
* @param obj the json_object instance
* @param new_value the value to be set; Since string legth is given in len this need not be zero terminated
* @param new_value the value to be set; Since string length is given in len this need not be zero terminated
* @param len the length of new_value
* @returns 1 if value is set correctly, 0 otherwise
*/
JSON_EXPORT int json_object_set_string_len(json_object* obj, const char* new_value, int len);
JSON_EXPORT int json_object_set_string_len(json_object *obj, const char *new_value, int len);
/** This method exists only to provide a complementary function
* along the lines of the other json_object_new_* functions.
* It always returns NULL, and it is entirely acceptable to simply use NULL directly.
*/
JSON_EXPORT struct json_object *json_object_new_null(void);
/** Check if two json_object's are equal
*
@ -974,8 +1007,7 @@ JSON_EXPORT int json_object_set_string_len(json_object* obj, const char* new_val
* @param obj2 the second json_object instance
* @returns whether both objects are equal or not
*/
JSON_EXPORT int json_object_equal(struct json_object *obj1,
struct json_object *obj2);
JSON_EXPORT int json_object_equal(struct json_object *obj1, struct json_object *obj2);
/**
* Perform a shallow copy of src into *dst as part of an overall json_object_deep_copy().
@ -985,17 +1017,18 @@ JSON_EXPORT int json_object_equal(struct json_object *obj1,
* When shallow_copy is called *dst will be NULL, and must be non-NULL when it returns.
* src will never be NULL.
*
* If shallow_copy sets the serializer on an object, return 2 to indicate to
* If shallow_copy sets the serializer on an object, return 2 to indicate to
* json_object_deep_copy that it should not attempt to use the standard userdata
* copy function.
*
* @return On success 1 or 2, -1 on errors
*/
typedef int (json_c_shallow_copy_fn)(json_object *src, json_object *parent, const char *key, size_t index, json_object **dst);
typedef int(json_c_shallow_copy_fn)(json_object *src, json_object *parent, const char *key,
size_t index, json_object **dst);
/**
* The default shallow copy implementation for use with json_object_deep_copy().
* This simply calls the appropriate json_object_new_<type>() function and
* This simply calls the appropriate json_object_new_<type>() function and
* copies over the serializer function (_to_json_string internal field of
* the json_object structure) but not any _userdata or _user_delete values.
*
@ -1005,7 +1038,7 @@ typedef int (json_c_shallow_copy_fn)(json_object *src, json_object *parent, cons
*
* @return 1 on success, -1 on errors, but never 2.
*/
json_c_shallow_copy_fn json_c_shallow_copy_default;
JSON_EXPORT json_c_shallow_copy_fn json_c_shallow_copy_default;
/**
* Copy the contents of the JSON object.
@ -1026,7 +1059,8 @@ json_c_shallow_copy_fn json_c_shallow_copy_default;
* or if the destination pointer is non-NULL
*/
JSON_EXPORT int json_object_deep_copy(struct json_object *src, struct json_object **dst, json_c_shallow_copy_fn *shallow_copy);
JSON_EXPORT int json_object_deep_copy(struct json_object *src, struct json_object **dst,
json_c_shallow_copy_fn *shallow_copy);
#ifdef __cplusplus
}
#endif

100
third_party/json-c/json_object_iterator.c поставляемый
Просмотреть файл

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

38
third_party/json-c/json_object_iterator.h поставляемый
Просмотреть файл

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

97
third_party/json-c/json_object_private.h поставляемый
Просмотреть файл

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

123
third_party/json-c/json_pointer.c поставляемый
Просмотреть файл

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

17
third_party/json-c/json_pointer.h поставляемый
Просмотреть файл

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

1915
third_party/json-c/json_tokener.c поставляемый
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

260
third_party/json-c/json_tokener.h поставляемый
Просмотреть файл

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

78
third_party/json-c/json_types.h поставляемый Normal file
Просмотреть файл

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

200
third_party/json-c/json_util.c поставляемый
Просмотреть файл

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

47
third_party/json-c/json_util.h поставляемый
Просмотреть файл

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

65
third_party/json-c/json_visit.c поставляемый
Просмотреть файл

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

24
third_party/json-c/json_visit.h поставляемый
Просмотреть файл

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

8
third_party/json-c/libjson.c поставляемый
Просмотреть файл

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

576
third_party/json-c/linkhash.c поставляемый
Просмотреть файл

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

83
third_party/json-c/linkhash.h поставляемый
Просмотреть файл

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

15
third_party/json-c/math_compat.h поставляемый
Просмотреть файл

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

142
third_party/json-c/printbuf.c поставляемый
Просмотреть файл

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

61
third_party/json-c/printbuf.h поставляемый
Просмотреть файл

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

240
third_party/json-c/random_seed.c поставляемый
Просмотреть файл

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

2
third_party/json-c/random_seed.h поставляемый
Просмотреть файл

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

4
third_party/json-c/snprintf_compat.h поставляемый
Просмотреть файл

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

6
third_party/json-c/strdup_compat.h поставляемый
Просмотреть файл

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

18
third_party/json-c/strerror_override.c поставляемый
Просмотреть файл

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

4
third_party/json-c/strerror_override.h поставляемый
Просмотреть файл

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

4
third_party/json-c/strerror_override_private.h поставляемый
Просмотреть файл

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

34
third_party/json-c/vasprintf_compat.h поставляемый
Просмотреть файл

@ -8,6 +8,8 @@
#include "snprintf_compat.h"
#include <stdlib.h>
#if !defined(HAVE_VASPRINTF)
/* CAW: compliant version of vasprintf */
static int vasprintf(char **buf, const char *fmt, va_list ap)
@ -18,24 +20,36 @@ static int vasprintf(char **buf, const char *fmt, va_list ap)
int chars;
char *b;
if(!buf) { return -1; }
if (!buf)
{
return -1;
}
#ifdef WIN32
chars = _vscprintf(fmt, ap)+1;
#else /* !defined(WIN32) */
chars = _vscprintf(fmt, ap) + 1;
#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, its time to move on */
chars = vsnprintf(&_T_emptybuffer, 0, fmt, ap)+1;
if(chars < 0) { chars *= -1; } /* CAW: old glibc versions have this problem */
* our buffer like on some 64bit sun systems.... but hey, its time to move on
*/
chars = vsnprintf(&_T_emptybuffer, 0, fmt, ap) + 1;
if (chars < 0)
{
chars *= -1;
} /* CAW: old glibc versions have this problem */
#endif /* defined(WIN32) */
b = (char*)malloc(sizeof(char)*chars);
if(!b) { return -1; }
b = (char *)malloc(sizeof(char) * chars);
if (!b)
{
return -1;
}
if((chars = vsprintf(b, fmt, ap)) < 0)
if ((chars = vsprintf(b, fmt, ap)) < 0)
{
free(b);
} else {
}
else
{
*buf = b;
}