mirror of https://github.com/GOSTSec/sgminer
troky
11 years ago
43 changed files with 501 additions and 5735 deletions
@ -0,0 +1,4 @@
@@ -0,0 +1,4 @@
|
||||
[submodule "jansson"] |
||||
path = submodules/jansson |
||||
url = https://github.com/akheron/jansson.git |
||||
|
||||
@ -1,3 +0,0 @@
@@ -1,3 +0,0 @@
|
||||
libusb-1.0/libusb/libusb-1.0.la |
||||
libusb-1.0/libusb/*.lo |
||||
libusb-1.0/libusb/os/*.lo |
||||
@ -1,554 +0,0 @@
@@ -1,554 +0,0 @@
|
||||
Version 2.5 |
||||
=========== |
||||
|
||||
Released 2013-09-19 |
||||
|
||||
* New features: |
||||
|
||||
- `json_pack()` and friends: Add format specifiers ``s#``, ``+`` and |
||||
``+#``. |
||||
|
||||
- Add ``JSON_DECODE_INT_AS_REAL`` decoding flag to treat all numbers |
||||
as real in the decoder (#123). |
||||
|
||||
- Add `json_array_foreach()`, paralleling `json_object_foreach()` |
||||
(#118). |
||||
|
||||
* Bug fixes: |
||||
|
||||
- `json_dumps()` and friends: Don't crash if json is *NULL* and |
||||
``JSON_ENCODE_ANY`` is set. |
||||
|
||||
- Fix a theoretical integer overflow in `jsonp_strdup()`. |
||||
|
||||
- Fix `l_isxdigit()` macro (#97). |
||||
|
||||
- Fix an off-by-one error in `json_array_remove()`. |
||||
|
||||
* Build: |
||||
|
||||
- Support CMake in addition to GNU Autotools (#106, #107, #112, |
||||
#115, #120, #127). |
||||
|
||||
- Support building for Android (#109). |
||||
|
||||
- Don't use ``-Werror`` by default. |
||||
|
||||
- Support building and testing with VPATH (#93). |
||||
|
||||
- Fix compilation when ``NDEBUG`` is defined (#128) |
||||
|
||||
* Tests: |
||||
|
||||
- Fix a refleak in ``test/bin/json_process.c``. |
||||
|
||||
* Documentation: |
||||
|
||||
- Clarify the return value of `json_load_callback_t`. |
||||
|
||||
- Document how to circumvent problems with separate heaps on Windows. |
||||
|
||||
- Fix memory leaks and warnings in ``github_commits.c``. |
||||
|
||||
- Use `json_decref()` properly in tutorial. |
||||
|
||||
* Other: |
||||
|
||||
- Make it possible to forward declare ``struct json_t``. |
||||
|
||||
|
||||
Version 2.4 |
||||
=========== |
||||
|
||||
Released 2012-09-23 |
||||
|
||||
* New features: |
||||
|
||||
- Add `json_boolean()` macro that returns the JSON true or false |
||||
value based on its argument (#86). |
||||
|
||||
- Add `json_load_callback()` that calls a callback function |
||||
repeatedly to read the JSON input (#57). |
||||
|
||||
- Add JSON_ESCAPE_SLASH encoding flag to escape all occurences of |
||||
``/`` with ``\/``. |
||||
|
||||
* Bug fixes: |
||||
|
||||
- Check for and reject NaN and Inf values for reals. Encoding these |
||||
values resulted in invalid JSON. |
||||
|
||||
- Fix `json_real_set()` to return -1 on error. |
||||
|
||||
* Build: |
||||
|
||||
- Jansson now builds on Windows with Visual Studio 2010, and |
||||
includes solution and project files in ``win32/vs2010/`` |
||||
directory. |
||||
|
||||
- Fix build warnings (#77, #78). |
||||
|
||||
- Add ``-no-undefined`` to LDFLAGS (#90). |
||||
|
||||
* Tests: |
||||
|
||||
- Fix the symbol exports test on Linux/PPC64 (#88). |
||||
|
||||
* Documentation: |
||||
|
||||
- Fix typos (#73, #84). |
||||
|
||||
|
||||
Version 2.3.1 |
||||
============= |
||||
|
||||
Released 2012-04-20 |
||||
|
||||
* Build issues: |
||||
|
||||
- Only use ``long long`` if ``strtoll()`` is also available. |
||||
|
||||
* Documentation: |
||||
|
||||
- Fix the names of library version constants in documentation. (#52) |
||||
|
||||
- Change the tutorial to use GitHub API v3. (#65) |
||||
|
||||
* Tests: |
||||
|
||||
- Make some tests locale independent. (#51) |
||||
|
||||
- Distribute the library exports test in the tarball. |
||||
|
||||
- Make test run on shells that don't support the ``export FOO=bar`` |
||||
syntax. |
||||
|
||||
|
||||
Version 2.3 |
||||
=========== |
||||
|
||||
Released 2012-01-27 |
||||
|
||||
* New features: |
||||
|
||||
- `json_unpack()` and friends: Add support for optional object keys |
||||
with the ``{s?o}`` syntax. |
||||
|
||||
- Add `json_object_update_existing()` and |
||||
`json_object_update_missing()`, for updating only existing keys or |
||||
only adding missing keys to an object. (#37) |
||||
|
||||
- Add `json_object_foreach()` for more convenient iteration over |
||||
objects. (#45, #46) |
||||
|
||||
- When decoding JSON, write the number of bytes that were read from |
||||
input to ``error.position`` also on success. This is handy with |
||||
``JSON_DISABLE_EOF_CHECK``. |
||||
|
||||
- Add support for decoding any JSON value, not just arrays or |
||||
objects. The support is enabled with the new ``JSON_DECODE_ANY`` |
||||
flag. Patch by Andrea Marchesini. (#4) |
||||
|
||||
* Bug fixes |
||||
|
||||
- Avoid problems with object's serial number growing too big. (#40, |
||||
#41) |
||||
|
||||
- Decoding functions now return NULL if the first argument is NULL. |
||||
Patch by Andrea Marchesini. |
||||
|
||||
- Include ``jansson_config.h.win32`` in the distribution tarball. |
||||
|
||||
- Remove ``+`` and leading zeros from exponents in the encoder. |
||||
(#39) |
||||
|
||||
- Make Jansson build and work on MinGW. (#39, #38) |
||||
|
||||
* Documentation |
||||
|
||||
- Note that the same JSON values must not be encoded in parallel by |
||||
separate threads. (#42) |
||||
|
||||
- Document MinGW support. |
||||
|
||||
|
||||
Version 2.2.1 |
||||
============= |
||||
|
||||
Released 2011-10-06 |
||||
|
||||
* Bug fixes: |
||||
|
||||
- Fix real number encoding and decoding under non-C locales. (#32) |
||||
|
||||
- Fix identifier decoding under non-UTF-8 locales. (#35) |
||||
|
||||
- `json_load_file()`: Open the input file in binary mode for maximum |
||||
compatiblity. |
||||
|
||||
* Documentation: |
||||
|
||||
- Clarify the lifecycle of the result of the ``s`` fromat of |
||||
`json_unpack()`. (#31) |
||||
|
||||
- Add some portability info. (#36) |
||||
|
||||
- Little clarifications here and there. |
||||
|
||||
* Other: |
||||
|
||||
- Some style fixes, issues detected by static analyzers. |
||||
|
||||
|
||||
Version 2.2 |
||||
=========== |
||||
|
||||
Released 2011-09-03 |
||||
|
||||
* New features: |
||||
|
||||
- `json_dump_callback()`: Pass the encoder output to a callback |
||||
function in chunks. |
||||
|
||||
* Bug fixes: |
||||
|
||||
- `json_string_set()`: Check that target is a string and value is |
||||
not NULL. |
||||
|
||||
* Other: |
||||
|
||||
- Documentation typo fixes and clarifications. |
||||
|
||||
|
||||
Version 2.1 |
||||
=========== |
||||
|
||||
Released 2011-06-10 |
||||
|
||||
* New features: |
||||
|
||||
- `json_loadb()`: Decode a string with a given size, useful if the |
||||
string is not null terminated. |
||||
|
||||
- Add ``JSON_ENCODE_ANY`` encoding flag to allow encoding any JSON |
||||
value. By default, only arrays and objects can be encoded. (#19) |
||||
|
||||
- Add ``JSON_REJECT_DUPLICATES`` decoding flag to issue a decoding |
||||
error if any JSON object in the input contins duplicate keys. (#3) |
||||
|
||||
- Add ``JSON_DISABLE_EOF_CHECK`` decoding flag to stop decoding after a |
||||
valid JSON input. This allows other data after the JSON data. |
||||
|
||||
* Bug fixes: |
||||
|
||||
- Fix an additional memory leak when memory allocation fails in |
||||
`json_object_set()` and friends. |
||||
|
||||
- Clear errno before calling `strtod()` for better portability. (#27) |
||||
|
||||
* Building: |
||||
|
||||
- Avoid set-but-not-used warning/error in a test. (#20) |
||||
|
||||
* Other: |
||||
|
||||
- Minor clarifications to documentation. |
||||
|
||||
|
||||
Version 2.0.1 |
||||
============= |
||||
|
||||
Released 2011-03-31 |
||||
|
||||
* Bug fixes: |
||||
|
||||
- Replace a few `malloc()` and `free()` calls with their |
||||
counterparts that support custom memory management. |
||||
|
||||
- Fix object key hashing in json_unpack() strict checking mode. |
||||
|
||||
- Fix the parentheses in ``JANSSON_VERSION_HEX`` macro. |
||||
|
||||
- Fix `json_object_size()` return value. |
||||
|
||||
- Fix a few compilation issues. |
||||
|
||||
* Portability: |
||||
|
||||
- Enhance portability of `va_copy()`. |
||||
|
||||
- Test framework portability enhancements. |
||||
|
||||
* Documentation: |
||||
|
||||
- Distribute ``doc/upgrading.rst`` with the source tarball. |
||||
|
||||
- Build documentation in strict mode in ``make distcheck``. |
||||
|
||||
|
||||
Version 2.0 |
||||
=========== |
||||
|
||||
Released 2011-02-28 |
||||
|
||||
This release is backwards incompatible with the 1.x release series. |
||||
See the chapter "Upgrading from older versions" in documentation for |
||||
details. |
||||
|
||||
* Backwards incompatible changes: |
||||
|
||||
- Unify unsigned integer usage in the API: All occurences of |
||||
unsigned int and unsigned long have been replaced with size_t. |
||||
|
||||
- Change JSON integer's underlying type to the widest signed integer |
||||
type available, i.e. long long if it's supported, otherwise long. |
||||
Add a typedef json_int_t that defines the type. |
||||
|
||||
- Change the maximum indentation depth to 31 spaces in encoder. This |
||||
frees up bits from the flags parameter of encoding functions |
||||
`json_dumpf()`, `json_dumps()` and `json_dump_file()`. |
||||
|
||||
- For future needs, add a flags parameter to all decoding functions |
||||
`json_loadf()`, `json_loads()` and `json_load_file()`. |
||||
|
||||
* New features |
||||
|
||||
- `json_pack()`, `json_pack_ex()`, `json_vpack_ex()`: Create JSON |
||||
values based on a format string. |
||||
|
||||
- `json_unpack()`, `json_unpack_ex()`, `json_vunpack_ex()`: Simple |
||||
value extraction and validation functionality based on a format |
||||
string. |
||||
|
||||
- Add column, position and source fields to the ``json_error_t`` |
||||
struct. |
||||
|
||||
- Enhance error reporting in the decoder. |
||||
|
||||
- ``JANSSON_VERSION`` et al.: Preprocessor constants that define the |
||||
library version. |
||||
|
||||
- `json_set_alloc_funcs()`: Set custom memory allocation functions. |
||||
|
||||
* Fix many portability issues, especially on Windows. |
||||
|
||||
* Configuration |
||||
|
||||
- Add file ``jansson_config.h`` that contains site specific |
||||
configuration. It's created automatically by the configure script, |
||||
or can be created by hand if the configure script cannot be used. |
||||
The file ``jansson_config.h.win32`` can be used without |
||||
modifications on Windows systems. |
||||
|
||||
- Add a section to documentation describing how to build Jansson on |
||||
Windows. |
||||
|
||||
- Documentation now requires Sphinx 1.0 or newer. |
||||
|
||||
|
||||
Version 1.3 |
||||
=========== |
||||
|
||||
Released 2010-06-13 |
||||
|
||||
* New functions: |
||||
|
||||
- `json_object_iter_set()`, `json_object_iter_set_new()`: Change |
||||
object contents while iterating over it. |
||||
|
||||
- `json_object_iter_at()`: Return an iterator that points to a |
||||
specific object item. |
||||
|
||||
* New encoding flags: |
||||
|
||||
- ``JSON_PRESERVE_ORDER``: Preserve the insertion order of object |
||||
keys. |
||||
|
||||
* Bug fixes: |
||||
|
||||
- Fix an error that occured when an array or object was first |
||||
encoded as empty, then populated with some data, and then |
||||
re-encoded |
||||
|
||||
- Fix the situation like above, but when the first encoding resulted |
||||
in an error |
||||
|
||||
* Documentation: |
||||
|
||||
- Clarify the documentation on reference stealing, providing an |
||||
example usage pattern |
||||
|
||||
|
||||
Version 1.2.1 |
||||
============= |
||||
|
||||
Released 2010-04-03 |
||||
|
||||
* Bug fixes: |
||||
|
||||
- Fix reference counting on ``true``, ``false`` and ``null`` |
||||
- Estimate real number underflows in decoder with 0.0 instead of |
||||
issuing an error |
||||
|
||||
* Portability: |
||||
|
||||
- Make ``int32_t`` available on all systems |
||||
- Support compilers that don't have the ``inline`` keyword |
||||
- Require Autoconf 2.60 (for ``int32_t``) |
||||
|
||||
* Tests: |
||||
|
||||
- Print test names correctly when ``VERBOSE=1`` |
||||
- ``test/suites/api``: Fail when a test fails |
||||
- Enhance tests for iterators |
||||
- Enhance tests for decoding texts that contain null bytes |
||||
|
||||
* Documentation: |
||||
|
||||
- Don't remove ``changes.rst`` in ``make clean`` |
||||
- Add a chapter on RFC conformance |
||||
|
||||
|
||||
Version 1.2 |
||||
=========== |
||||
|
||||
Released 2010-01-21 |
||||
|
||||
* New functions: |
||||
|
||||
- `json_equal()`: Test whether two JSON values are equal |
||||
- `json_copy()` and `json_deep_copy()`: Make shallow and deep copies |
||||
of JSON values |
||||
- Add a version of all functions taking a string argument that |
||||
doesn't check for valid UTF-8: `json_string_nocheck()`, |
||||
`json_string_set_nocheck()`, `json_object_set_nocheck()`, |
||||
`json_object_set_new_nocheck()` |
||||
|
||||
* New encoding flags: |
||||
|
||||
- ``JSON_SORT_KEYS``: Sort objects by key |
||||
- ``JSON_ENSURE_ASCII``: Escape all non-ASCII Unicode characters |
||||
- ``JSON_COMPACT``: Use a compact representation with all unneeded |
||||
whitespace stripped |
||||
|
||||
* Bug fixes: |
||||
|
||||
- Revise and unify whitespace usage in encoder: Add spaces between |
||||
array and object items, never append newline to output. |
||||
- Remove const qualifier from the ``json_t`` parameter in |
||||
`json_string_set()`, `json_integer_set()` and `json_real_set`. |
||||
- Use ``int32_t`` internally for representing Unicode code points |
||||
(int is not enough on all platforms) |
||||
|
||||
* Other changes: |
||||
|
||||
- Convert ``CHANGES`` (this file) to reStructured text and add it to |
||||
HTML documentation |
||||
- The test system has been refactored. Python is no longer required |
||||
to run the tests. |
||||
- Documentation can now be built by invoking ``make html`` |
||||
- Support for pkg-config |
||||
|
||||
|
||||
Version 1.1.3 |
||||
============= |
||||
|
||||
Released 2009-12-18 |
||||
|
||||
* Encode reals correctly, so that first encoding and then decoding a |
||||
real always produces the same value |
||||
* Don't export private symbols in ``libjansson.so`` |
||||
|
||||
|
||||
Version 1.1.2 |
||||
============= |
||||
|
||||
Released 2009-11-08 |
||||
|
||||
* Fix a bug where an error message was not produced if the input file |
||||
could not be opened in `json_load_file()` |
||||
* Fix an assertion failure in decoder caused by a minus sign without a |
||||
digit after it |
||||
* Remove an unneeded include of ``stdint.h`` in ``jansson.h`` |
||||
|
||||
|
||||
Version 1.1.1 |
||||
============= |
||||
|
||||
Released 2009-10-26 |
||||
|
||||
* All documentation files were not distributed with v1.1; build |
||||
documentation in make distcheck to prevent this in the future |
||||
* Fix v1.1 release date in ``CHANGES`` |
||||
|
||||
|
||||
Version 1.1 |
||||
=========== |
||||
|
||||
Released 2009-10-20 |
||||
|
||||
* API additions and improvements: |
||||
|
||||
- Extend array and object APIs |
||||
- Add functions to modify integer, real and string values |
||||
- Improve argument validation |
||||
- Use unsigned int instead of ``uint32_t`` for encoding flags |
||||
|
||||
* Enhance documentation |
||||
|
||||
- Add getting started guide and tutorial |
||||
- Fix some typos |
||||
- General clarifications and cleanup |
||||
|
||||
* Check for integer and real overflows and underflows in decoder |
||||
* Make singleton values thread-safe (``true``, ``false`` and ``null``) |
||||
* Enhance circular reference handling |
||||
* Don't define ``-std=c99`` in ``AM_CFLAGS`` |
||||
* Add C++ guards to ``jansson.h`` |
||||
* Minor performance and portability improvements |
||||
* Expand test coverage |
||||
|
||||
|
||||
Version 1.0.4 |
||||
============= |
||||
|
||||
Released 2009-10-11 |
||||
|
||||
* Relax Autoconf version requirement to 2.59 |
||||
* Make Jansson compile on platforms where plain ``char`` is unsigned |
||||
* Fix API tests for object |
||||
|
||||
|
||||
Version 1.0.3 |
||||
============= |
||||
|
||||
Released 2009-09-14 |
||||
|
||||
* Check for integer and real overflows and underflows in decoder |
||||
* Use the Python json module for tests, or simplejson if the json |
||||
module is not found |
||||
* Distribute changelog (this file) |
||||
|
||||
|
||||
Version 1.0.2 |
||||
============= |
||||
|
||||
Released 2009-09-08 |
||||
|
||||
* Handle EOF correctly in decoder |
||||
|
||||
|
||||
Version 1.0.1 |
||||
============= |
||||
|
||||
Released 2009-09-04 |
||||
|
||||
* Fixed broken `json_is_boolean()` |
||||
|
||||
|
||||
Version 1.0 |
||||
=========== |
||||
|
||||
Released 2009-08-25 |
||||
|
||||
* Initial release |
||||
@ -1,19 +0,0 @@
@@ -1,19 +0,0 @@
|
||||
Copyright (c) 2009-2013 Petri Lehtinen <petri@digip.org> |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in |
||||
all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||
THE SOFTWARE. |
||||
@ -1,17 +0,0 @@
@@ -1,17 +0,0 @@
|
||||
ACLOCAL_AMFLAGS = -I m4 |
||||
|
||||
EXTRA_DIST = CHANGES LICENSE README.rst |
||||
SUBDIRS = src |
||||
|
||||
# "make distcheck" builds the dvi target, so use it to check that the
|
||||
# documentation is built correctly.
|
||||
dvi: |
||||
$(MAKE) SPHINXOPTS_EXTRA=-W html |
||||
|
||||
pkgconfigdir = $(libdir)/pkgconfig |
||||
pkgconfig_DATA = jansson.pc |
||||
|
||||
if GCC |
||||
# These flags are gcc specific
|
||||
export AM_CFLAGS = -Wall -Wextra -Wdeclaration-after-statement |
||||
endif |
||||
@ -1,63 +0,0 @@
@@ -1,63 +0,0 @@
|
||||
Jansson README |
||||
============== |
||||
|
||||
.. image:: https://travis-ci.org/akheron/jansson.png |
||||
:alt: Build status |
||||
:target: https://travis-ci.org/akheron/jansson |
||||
|
||||
Jansson_ is a C library for encoding, decoding and manipulating JSON |
||||
data. Its main features and design principles are: |
||||
|
||||
- Simple and intuitive API and data model |
||||
|
||||
- Comprehensive documentation |
||||
|
||||
- No dependencies on other libraries |
||||
|
||||
- Full Unicode support (UTF-8) |
||||
|
||||
- Extensive test suite |
||||
|
||||
Jansson is licensed under the `MIT license`_; see LICENSE in the |
||||
source distribution for details. |
||||
|
||||
|
||||
Compilation and Installation |
||||
---------------------------- |
||||
|
||||
If you obtained a source tarball, just use the standard autotools |
||||
commands:: |
||||
|
||||
$ ./configure |
||||
$ make |
||||
$ make install |
||||
|
||||
To run the test suite, invoke:: |
||||
|
||||
$ make check |
||||
|
||||
If the source has been checked out from a Git repository, the |
||||
./configure script has to be generated first. The easiest way is to |
||||
use autoreconf:: |
||||
|
||||
$ autoreconf -i |
||||
|
||||
|
||||
Documentation |
||||
------------- |
||||
|
||||
Prebuilt HTML documentation is available at |
||||
http://www.digip.org/jansson/doc/. |
||||
|
||||
The documentation source is in the ``doc/`` subdirectory. To generate |
||||
HTML documentation, invoke:: |
||||
|
||||
$ make html |
||||
|
||||
Then, point your browser to ``doc/_build/html/index.html``. Sphinx_ |
||||
1.0 or newer is required to generate the documentation. |
||||
|
||||
|
||||
.. _Jansson: http://www.digip.org/jansson/ |
||||
.. _`MIT license`: http://www.opensource.org/licenses/mit-license.php |
||||
.. _Sphinx: http://sphinx.pocoo.org/ |
||||
@ -1,55 +0,0 @@
@@ -1,55 +0,0 @@
|
||||
AC_PREREQ([2.60]) |
||||
AC_INIT([jansson], [2.5], [petri@digip.org]) |
||||
|
||||
AC_CONFIG_MACRO_DIR([m4]) |
||||
|
||||
AM_INIT_AUTOMAKE([1.10 foreign]) |
||||
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) |
||||
|
||||
AC_CONFIG_SRCDIR([src/value.c]) |
||||
AC_CONFIG_HEADERS([config.h]) |
||||
|
||||
# Checks for programs. |
||||
AC_PROG_CC |
||||
AC_PROG_LIBTOOL |
||||
AM_CONDITIONAL([GCC], [test x$GCC = xyes]) |
||||
|
||||
# Checks for libraries. |
||||
|
||||
# Checks for header files. |
||||
AC_CHECK_HEADERS([locale.h]) |
||||
|
||||
# Checks for typedefs, structures, and compiler characteristics. |
||||
AC_TYPE_INT32_T |
||||
AC_TYPE_LONG_LONG_INT |
||||
|
||||
AC_C_INLINE |
||||
case $ac_cv_c_inline in |
||||
yes) json_inline=inline;; |
||||
no) json_inline=;; |
||||
*) json_inline=$ac_cv_c_inline;; |
||||
esac |
||||
AC_SUBST([json_inline]) |
||||
|
||||
# Checks for library functions. |
||||
AC_CHECK_FUNCS([strtoll localeconv]) |
||||
|
||||
case "$ac_cv_type_long_long_int$ac_cv_func_strtoll" in |
||||
yesyes) json_have_long_long=1;; |
||||
*) json_have_long_long=0;; |
||||
esac |
||||
AC_SUBST([json_have_long_long]) |
||||
|
||||
case "$ac_cv_header_locale_h$ac_cv_func_localeconv" in |
||||
yesyes) json_have_localeconv=1;; |
||||
*) json_have_localeconv=0;; |
||||
esac |
||||
AC_SUBST([json_have_localeconv]) |
||||
|
||||
AC_CONFIG_FILES([ |
||||
jansson.pc |
||||
Makefile |
||||
src/Makefile |
||||
src/jansson_config.h |
||||
]) |
||||
AC_OUTPUT |
||||
@ -1,10 +0,0 @@
@@ -1,10 +0,0 @@
|
||||
prefix=@prefix@ |
||||
exec_prefix=@exec_prefix@ |
||||
libdir=@libdir@ |
||||
includedir=${prefix}/include |
||||
|
||||
Name: Jansson |
||||
Description: Library for encoding, decoding and manipulating JSON data |
||||
Version: @VERSION@ |
||||
Libs: -L${libdir} -ljansson |
||||
Cflags: -I${includedir} |
||||
@ -1,24 +0,0 @@
@@ -1,24 +0,0 @@
|
||||
EXTRA_DIST = jansson.def |
||||
|
||||
include_HEADERS = jansson.h jansson_config.h |
||||
|
||||
lib_LTLIBRARIES = libjansson.la |
||||
libjansson_la_SOURCES = \
|
||||
dump.c \
|
||||
error.c \
|
||||
hashtable.c \
|
||||
hashtable.h \
|
||||
jansson_private.h \
|
||||
load.c \
|
||||
memory.c \
|
||||
pack_unpack.c \
|
||||
strbuffer.c \
|
||||
strbuffer.h \
|
||||
strconv.c \
|
||||
utf.c \
|
||||
utf.h \
|
||||
value.c |
||||
libjansson_la_LDFLAGS = \
|
||||
-no-undefined \
|
||||
-export-symbols-regex '^json_' \
|
||||
-version-info 9:0:5 |
||||
@ -1,456 +0,0 @@
@@ -1,456 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2009-2013 Petri Lehtinen <petri@digip.org> |
||||
* |
||||
* Jansson is free software; you can redistribute it and/or modify |
||||
* it under the terms of the MIT license. See LICENSE for details. |
||||
*/ |
||||
|
||||
#ifndef _GNU_SOURCE |
||||
#define _GNU_SOURCE |
||||
#endif |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <assert.h> |
||||
|
||||
#include "jansson.h" |
||||
#include "jansson_private.h" |
||||
#include "strbuffer.h" |
||||
#include "utf.h" |
||||
|
||||
#define MAX_INTEGER_STR_LENGTH 100 |
||||
#define MAX_REAL_STR_LENGTH 100 |
||||
|
||||
struct object_key { |
||||
size_t serial; |
||||
const char *key; |
||||
}; |
||||
|
||||
static int dump_to_strbuffer(const char *buffer, size_t size, void *data) |
||||
{ |
||||
return strbuffer_append_bytes((strbuffer_t *)data, buffer, size); |
||||
} |
||||
|
||||
static int dump_to_file(const char *buffer, size_t size, void *data) |
||||
{ |
||||
FILE *dest = (FILE *)data; |
||||
if(fwrite(buffer, size, 1, dest) != 1) |
||||
return -1; |
||||
return 0; |
||||
} |
||||
|
||||
/* 32 spaces (the maximum indentation size) */ |
||||
static const char whitespace[] = " "; |
||||
|
||||
static int dump_indent(size_t flags, int depth, int space, json_dump_callback_t dump, void *data) |
||||
{ |
||||
if(JSON_INDENT(flags) > 0) |
||||
{ |
||||
int i, ws_count = JSON_INDENT(flags); |
||||
|
||||
if(dump("\n", 1, data)) |
||||
return -1; |
||||
|
||||
for(i = 0; i < depth; i++) |
||||
{ |
||||
if(dump(whitespace, ws_count, data)) |
||||
return -1; |
||||
} |
||||
} |
||||
else if(space && !(flags & JSON_COMPACT)) |
||||
{ |
||||
return dump(" ", 1, data); |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
static int dump_string(const char *str, json_dump_callback_t dump, void *data, size_t flags) |
||||
{ |
||||
const char *pos, *end; |
||||
int32_t codepoint; |
||||
|
||||
if(dump("\"", 1, data)) |
||||
return -1; |
||||
|
||||
end = pos = str; |
||||
while(1) |
||||
{ |
||||
const char *text; |
||||
char seq[13]; |
||||
int length; |
||||
|
||||
while(*end) |
||||
{ |
||||
end = utf8_iterate(pos, &codepoint); |
||||
if(!end) |
||||
return -1; |
||||
|
||||
/* mandatory escape or control char */ |
||||
if(codepoint == '\\' || codepoint == '"' || codepoint < 0x20) |
||||
break; |
||||
|
||||
/* slash */ |
||||
if((flags & JSON_ESCAPE_SLASH) && codepoint == '/') |
||||
break; |
||||
|
||||
/* non-ASCII */ |
||||
if((flags & JSON_ENSURE_ASCII) && codepoint > 0x7F) |
||||
break; |
||||
|
||||
pos = end; |
||||
} |
||||
|
||||
if(pos != str) { |
||||
if(dump(str, pos - str, data)) |
||||
return -1; |
||||
} |
||||
|
||||
if(end == pos) |
||||
break; |
||||
|
||||
/* handle \, /, ", and control codes */ |
||||
length = 2; |
||||
switch(codepoint) |
||||
{ |
||||
case '\\': text = "\\\\"; break; |
||||
case '\"': text = "\\\""; break; |
||||
case '\b': text = "\\b"; break; |
||||
case '\f': text = "\\f"; break; |
||||
case '\n': text = "\\n"; break; |
||||
case '\r': text = "\\r"; break; |
||||
case '\t': text = "\\t"; break; |
||||
case '/': text = "\\/"; break; |
||||
default: |
||||
{ |
||||
/* codepoint is in BMP */ |
||||
if(codepoint < 0x10000) |
||||
{ |
||||
sprintf(seq, "\\u%04x", codepoint); |
||||
length = 6; |
||||
} |
||||
|
||||
/* not in BMP -> construct a UTF-16 surrogate pair */ |
||||
else |
||||
{ |
||||
int32_t first, last; |
||||
|
||||
codepoint -= 0x10000; |
||||
first = 0xD800 | ((codepoint & 0xffc00) >> 10); |
||||
last = 0xDC00 | (codepoint & 0x003ff); |
||||
|
||||
sprintf(seq, "\\u%04x\\u%04x", first, last); |
||||
length = 12; |
||||
} |
||||
|
||||
text = seq; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
if(dump(text, length, data)) |
||||
return -1; |
||||
|
||||
str = pos = end; |
||||
} |
||||
|
||||
return dump("\"", 1, data); |
||||
} |
||||
|
||||
static int object_key_compare_keys(const void *key1, const void *key2) |
||||
{ |
||||
return strcmp(((const struct object_key *)key1)->key, |
||||
((const struct object_key *)key2)->key); |
||||
} |
||||
|
||||
static int object_key_compare_serials(const void *key1, const void *key2) |
||||
{ |
||||
size_t a = ((const struct object_key *)key1)->serial; |
||||
size_t b = ((const struct object_key *)key2)->serial; |
||||
|
||||
return a < b ? -1 : a == b ? 0 : 1; |
||||
} |
||||
|
||||
static int do_dump(const json_t *json, size_t flags, int depth, |
||||
json_dump_callback_t dump, void *data) |
||||
{ |
||||
if(!json) |
||||
return -1; |
||||
|
||||
switch(json_typeof(json)) { |
||||
case JSON_NULL: |
||||
return dump("null", 4, data); |
||||
|
||||
case JSON_TRUE: |
||||
return dump("true", 4, data); |
||||
|
||||
case JSON_FALSE: |
||||
return dump("false", 5, data); |
||||
|
||||
case JSON_INTEGER: |
||||
{ |
||||
char buffer[MAX_INTEGER_STR_LENGTH]; |
||||
int size; |
||||
|
||||
size = snprintf(buffer, MAX_INTEGER_STR_LENGTH, |
||||
"%" JSON_INTEGER_FORMAT, |
||||
json_integer_value(json)); |
||||
if(size < 0 || size >= MAX_INTEGER_STR_LENGTH) |
||||
return -1; |
||||
|
||||
return dump(buffer, size, data); |
||||
} |
||||
|
||||
case JSON_REAL: |
||||
{ |
||||
char buffer[MAX_REAL_STR_LENGTH]; |
||||
int size; |
||||
double value = json_real_value(json); |
||||
|
||||
size = jsonp_dtostr(buffer, MAX_REAL_STR_LENGTH, value); |
||||
if(size < 0) |
||||
return -1; |
||||
|
||||
return dump(buffer, size, data); |
||||
} |
||||
|
||||
case JSON_STRING: |
||||
return dump_string(json_string_value(json), dump, data, flags); |
||||
|
||||
case JSON_ARRAY: |
||||
{ |
||||
int i; |
||||
int n; |
||||
json_array_t *array; |
||||
|
||||
/* detect circular references */ |
||||
array = json_to_array(json); |
||||
if(array->visited) |
||||
goto array_error; |
||||
array->visited = 1; |
||||
|
||||
n = json_array_size(json); |
||||
|
||||
if(dump("[", 1, data)) |
||||
goto array_error; |
||||
if(n == 0) { |
||||
array->visited = 0; |
||||
return dump("]", 1, data); |
||||
} |
||||
if(dump_indent(flags, depth + 1, 0, dump, data)) |
||||
goto array_error; |
||||
|
||||
for(i = 0; i < n; ++i) { |
||||
if(do_dump(json_array_get(json, i), flags, depth + 1, |
||||
dump, data)) |
||||
goto array_error; |
||||
|
||||
if(i < n - 1) |
||||
{ |
||||
if(dump(",", 1, data) || |
||||
dump_indent(flags, depth + 1, 1, dump, data)) |
||||
goto array_error; |
||||
} |
||||
else |
||||
{ |
||||
if(dump_indent(flags, depth, 0, dump, data)) |
||||
goto array_error; |
||||
} |
||||
} |
||||
|
||||
array->visited = 0; |
||||
return dump("]", 1, data); |
||||
|
||||
array_error: |
||||
array->visited = 0; |
||||
return -1; |
||||
} |
||||
|
||||
case JSON_OBJECT: |
||||
{ |
||||
json_object_t *object; |
||||
void *iter; |
||||
const char *separator; |
||||
int separator_length; |
||||
|
||||
if(flags & JSON_COMPACT) { |
||||
separator = ":"; |
||||
separator_length = 1; |
||||
} |
||||
else { |
||||
separator = ": "; |
||||
separator_length = 2; |
||||
} |
||||
|
||||
/* detect circular references */ |
||||
object = json_to_object(json); |
||||
if(object->visited) |
||||
goto object_error; |
||||
object->visited = 1; |
||||
|
||||
iter = json_object_iter((json_t *)json); |
||||
|
||||
if(dump("{", 1, data)) |
||||
goto object_error; |
||||
if(!iter) { |
||||
object->visited = 0; |
||||
return dump("}", 1, data); |
||||
} |
||||
if(dump_indent(flags, depth + 1, 0, dump, data)) |
||||
goto object_error; |
||||
|
||||
if(flags & JSON_SORT_KEYS || flags & JSON_PRESERVE_ORDER) |
||||
{ |
||||
struct object_key *keys; |
||||
size_t size, i; |
||||
int (*cmp_func)(const void *, const void *); |
||||
|
||||
size = json_object_size(json); |
||||
keys = (struct object_key *)jsonp_malloc(size * sizeof(struct object_key)); |
||||
if(!keys) |
||||
goto object_error; |
||||
|
||||
i = 0; |
||||
while(iter) |
||||
{ |
||||
keys[i].serial = hashtable_iter_serial(iter); |
||||
keys[i].key = json_object_iter_key(iter); |
||||
iter = json_object_iter_next((json_t *)json, iter); |
||||
i++; |
||||
} |
||||
assert(i == size); |
||||
|
||||
if(flags & JSON_SORT_KEYS) |
||||
cmp_func = object_key_compare_keys; |
||||
else |
||||
cmp_func = object_key_compare_serials; |
||||
|
||||
qsort(keys, size, sizeof(struct object_key), cmp_func); |
||||
|
||||
for(i = 0; i < size; i++) |
||||
{ |
||||
const char *key; |
||||
json_t *value; |
||||
|
||||
key = keys[i].key; |
||||
value = json_object_get(json, key); |
||||
assert(value); |
||||
|
||||
dump_string(key, dump, data, flags); |
||||
if(dump(separator, separator_length, data) || |
||||
do_dump(value, flags, depth + 1, dump, data)) |
||||
{ |
||||
jsonp_free(keys); |
||||
goto object_error; |
||||
} |
||||
|
||||
if(i < size - 1) |
||||
{ |
||||
if(dump(",", 1, data) || |
||||
dump_indent(flags, depth + 1, 1, dump, data)) |
||||
{ |
||||
jsonp_free(keys); |
||||
goto object_error; |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
if(dump_indent(flags, depth, 0, dump, data)) |
||||
{ |
||||
jsonp_free(keys); |
||||
goto object_error; |
||||
} |
||||
} |
||||
} |
||||
|
||||
jsonp_free(keys); |
||||
} |
||||
else |
||||
{ |
||||
/* Don't sort keys */ |
||||
|
||||
while(iter) |
||||
{ |
||||
void *next = json_object_iter_next((json_t *)json, iter); |
||||
|
||||
dump_string(json_object_iter_key(iter), dump, data, flags); |
||||
if(dump(separator, separator_length, data) || |
||||
do_dump(json_object_iter_value(iter), flags, depth + 1, |
||||
dump, data)) |
||||
goto object_error; |
||||
|
||||
if(next) |
||||
{ |
||||
if(dump(",", 1, data) || |
||||
dump_indent(flags, depth + 1, 1, dump, data)) |
||||
goto object_error; |
||||
} |
||||
else |
||||
{ |
||||
if(dump_indent(flags, depth, 0, dump, data)) |
||||
goto object_error; |
||||
} |
||||
|
||||
iter = next; |
||||
} |
||||
} |
||||
|
||||
object->visited = 0; |
||||
return dump("}", 1, data); |
||||
|
||||
object_error: |
||||
object->visited = 0; |
||||
return -1; |
||||
} |
||||
|
||||
default: |
||||
/* not reached */ |
||||
return -1; |
||||
} |
||||
} |
||||
|
||||
char *json_dumps(const json_t *json, size_t flags) |
||||
{ |
||||
strbuffer_t strbuff; |
||||
char *result; |
||||
|
||||
if(strbuffer_init(&strbuff)) |
||||
return NULL; |
||||
|
||||
if(json_dump_callback(json, dump_to_strbuffer, (void *)&strbuff, flags)) |
||||
result = NULL; |
||||
else |
||||
result = jsonp_strdup(strbuffer_value(&strbuff)); |
||||
|
||||
strbuffer_close(&strbuff); |
||||
return result; |
||||
} |
||||
|
||||
int json_dumpf(const json_t *json, FILE *output, size_t flags) |
||||
{ |
||||
return json_dump_callback(json, dump_to_file, (void *)output, flags); |
||||
} |
||||
|
||||
int json_dump_file(const json_t *json, const char *path, size_t flags) |
||||
{ |
||||
int result; |
||||
|
||||
FILE *output = fopen(path, "w"); |
||||
if(!output) |
||||
return -1; |
||||
|
||||
result = json_dumpf(json, output, flags); |
||||
|
||||
fclose(output); |
||||
return result; |
||||
} |
||||
|
||||
int json_dump_callback(const json_t *json, json_dump_callback_t callback, void *data, size_t flags) |
||||
{ |
||||
if(!(flags & JSON_ENCODE_ANY)) { |
||||
if(!json_is_array(json) && !json_is_object(json)) |
||||
return -1; |
||||
} |
||||
|
||||
return do_dump(json, flags, 0, callback, data); |
||||
} |
||||
@ -1,63 +0,0 @@
@@ -1,63 +0,0 @@
|
||||
#include <string.h> |
||||
#include "jansson_private.h" |
||||
|
||||
void jsonp_error_init(json_error_t *error, const char *source) |
||||
{ |
||||
if(error) |
||||
{ |
||||
error->text[0] = '\0'; |
||||
error->line = -1; |
||||
error->column = -1; |
||||
error->position = 0; |
||||
if(source) |
||||
jsonp_error_set_source(error, source); |
||||
else |
||||
error->source[0] = '\0'; |
||||
} |
||||
} |
||||
|
||||
void jsonp_error_set_source(json_error_t *error, const char *source) |
||||
{ |
||||
size_t length; |
||||
|
||||
if(!error || !source) |
||||
return; |
||||
|
||||
length = strlen(source); |
||||
if(length < JSON_ERROR_SOURCE_LENGTH) |
||||
strcpy(error->source, source); |
||||
else { |
||||
size_t extra = length - JSON_ERROR_SOURCE_LENGTH + 4; |
||||
strcpy(error->source, "..."); |
||||
strcpy(error->source + 3, source + extra); |
||||
} |
||||
} |
||||
|
||||
void jsonp_error_set(json_error_t *error, int line, int column, |
||||
size_t position, const char *msg, ...) |
||||
{ |
||||
va_list ap; |
||||
|
||||
va_start(ap, msg); |
||||
jsonp_error_vset(error, line, column, position, msg, ap); |
||||
va_end(ap); |
||||
} |
||||
|
||||
void jsonp_error_vset(json_error_t *error, int line, int column, |
||||
size_t position, const char *msg, va_list ap) |
||||
{ |
||||
if(!error) |
||||
return; |
||||
|
||||
if(error->text[0] != '\0') { |
||||
/* error already set */ |
||||
return; |
||||
} |
||||
|
||||
error->line = line; |
||||
error->column = column; |
||||
error->position = position; |
||||
|
||||
vsnprintf(error->text, JSON_ERROR_TEXT_LENGTH, msg, ap); |
||||
error->text[JSON_ERROR_TEXT_LENGTH - 1] = '\0'; |
||||
} |
||||
@ -1,360 +0,0 @@
@@ -1,360 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2009-2013 Petri Lehtinen <petri@digip.org> |
||||
* |
||||
* This library is free software; you can redistribute it and/or modify |
||||
* it under the terms of the MIT license. See LICENSE for details. |
||||
*/ |
||||
|
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <jansson_config.h> /* for JSON_INLINE */ |
||||
#include "jansson_private.h" /* for container_of() */ |
||||
#include "hashtable.h" |
||||
|
||||
typedef struct hashtable_list list_t; |
||||
typedef struct hashtable_pair pair_t; |
||||
typedef struct hashtable_bucket bucket_t; |
||||
|
||||
#define list_to_pair(list_) container_of(list_, pair_t, list) |
||||
|
||||
/* From http://www.cse.yorku.ca/~oz/hash.html */ |
||||
static size_t hash_str(const void *ptr) |
||||
{ |
||||
const char *str = (const char *)ptr; |
||||
|
||||
size_t hash = 5381; |
||||
size_t c; |
||||
|
||||
while((c = (size_t)*str)) |
||||
{ |
||||
hash = ((hash << 5) + hash) + c; |
||||
str++; |
||||
} |
||||
|
||||
return hash; |
||||
} |
||||
|
||||
static JSON_INLINE void list_init(list_t *list) |
||||
{ |
||||
list->next = list; |
||||
list->prev = list; |
||||
} |
||||
|
||||
static JSON_INLINE void list_insert(list_t *list, list_t *node) |
||||
{ |
||||
node->next = list; |
||||
node->prev = list->prev; |
||||
list->prev->next = node; |
||||
list->prev = node; |
||||
} |
||||
|
||||
static JSON_INLINE void list_remove(list_t *list) |
||||
{ |
||||
list->prev->next = list->next; |
||||
list->next->prev = list->prev; |
||||
} |
||||
|
||||
static JSON_INLINE int bucket_is_empty(hashtable_t *hashtable, bucket_t *bucket) |
||||
{ |
||||
return bucket->first == &hashtable->list && bucket->first == bucket->last; |
||||
} |
||||
|
||||
static void insert_to_bucket(hashtable_t *hashtable, bucket_t *bucket, |
||||
list_t *list) |
||||
{ |
||||
if(bucket_is_empty(hashtable, bucket)) |
||||
{ |
||||
list_insert(&hashtable->list, list); |
||||
bucket->first = bucket->last = list; |
||||
} |
||||
else |
||||
{ |
||||
list_insert(bucket->first, list); |
||||
bucket->first = list; |
||||
} |
||||
} |
||||
|
||||
static const size_t primes[] = { |
||||
5, 13, 23, 53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593, |
||||
49157, 98317, 196613, 393241, 786433, 1572869, 3145739, 6291469, |
||||
12582917, 25165843, 50331653, 100663319, 201326611, 402653189, |
||||
805306457, 1610612741 |
||||
}; |
||||
|
||||
static JSON_INLINE size_t num_buckets(hashtable_t *hashtable) |
||||
{ |
||||
return primes[hashtable->num_buckets]; |
||||
} |
||||
|
||||
|
||||
static pair_t *hashtable_find_pair(hashtable_t *hashtable, bucket_t *bucket, |
||||
const char *key, size_t hash) |
||||
{ |
||||
list_t *list; |
||||
pair_t *pair; |
||||
|
||||
if(bucket_is_empty(hashtable, bucket)) |
||||
return NULL; |
||||
|
||||
list = bucket->first; |
||||
while(1) |
||||
{ |
||||
pair = list_to_pair(list); |
||||
if(pair->hash == hash && strcmp(pair->key, key) == 0) |
||||
return pair; |
||||
|
||||
if(list == bucket->last) |
||||
break; |
||||
|
||||
list = list->next; |
||||
} |
||||
|
||||
return NULL; |
||||
} |
||||
|
||||
/* returns 0 on success, -1 if key was not found */ |
||||
static int hashtable_do_del(hashtable_t *hashtable, |
||||
const char *key, size_t hash) |
||||
{ |
||||
pair_t *pair; |
||||
bucket_t *bucket; |
||||
size_t index; |
||||
|
||||
index = hash % num_buckets(hashtable); |
||||
bucket = &hashtable->buckets[index]; |
||||
|
||||
pair = hashtable_find_pair(hashtable, bucket, key, hash); |
||||
if(!pair) |
||||
return -1; |
||||
|
||||
if(&pair->list == bucket->first && &pair->list == bucket->last) |
||||
bucket->first = bucket->last = &hashtable->list; |
||||
|
||||
else if(&pair->list == bucket->first) |
||||
bucket->first = pair->list.next; |
||||
|
||||
else if(&pair->list == bucket->last) |
||||
bucket->last = pair->list.prev; |
||||
|
||||
list_remove(&pair->list); |
||||
json_decref(pair->value); |
||||
|
||||
jsonp_free(pair); |
||||
hashtable->size--; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static void hashtable_do_clear(hashtable_t *hashtable) |
||||
{ |
||||
list_t *list, *next; |
||||
pair_t *pair; |
||||
|
||||
for(list = hashtable->list.next; list != &hashtable->list; list = next) |
||||
{ |
||||
next = list->next; |
||||
pair = list_to_pair(list); |
||||
json_decref(pair->value); |
||||
jsonp_free(pair); |
||||
} |
||||
} |
||||
|
||||
static int hashtable_do_rehash(hashtable_t *hashtable) |
||||
{ |
||||
list_t *list, *next; |
||||
pair_t *pair; |
||||
size_t i, index, new_size; |
||||
|
||||
jsonp_free(hashtable->buckets); |
||||
|
||||
hashtable->num_buckets++; |
||||
new_size = num_buckets(hashtable); |
||||
|
||||
hashtable->buckets = (struct hashtable_bucket *)jsonp_malloc(new_size * sizeof(bucket_t)); |
||||
if(!hashtable->buckets) |
||||
return -1; |
||||
|
||||
for(i = 0; i < num_buckets(hashtable); i++) |
||||
{ |
||||
hashtable->buckets[i].first = hashtable->buckets[i].last = |
||||
&hashtable->list; |
||||
} |
||||
|
||||
list = hashtable->list.next; |
||||
list_init(&hashtable->list); |
||||
|
||||
for(; list != &hashtable->list; list = next) { |
||||
next = list->next; |
||||
pair = list_to_pair(list); |
||||
index = pair->hash % new_size; |
||||
insert_to_bucket(hashtable, &hashtable->buckets[index], &pair->list); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
|
||||
int hashtable_init(hashtable_t *hashtable) |
||||
{ |
||||
size_t i; |
||||
|
||||
hashtable->size = 0; |
||||
hashtable->num_buckets = 0; /* index to primes[] */ |
||||
hashtable->buckets = (struct hashtable_bucket *)jsonp_malloc(num_buckets(hashtable) * sizeof(bucket_t)); |
||||
if(!hashtable->buckets) |
||||
return -1; |
||||
|
||||
list_init(&hashtable->list); |
||||
|
||||
for(i = 0; i < num_buckets(hashtable); i++) |
||||
{ |
||||
hashtable->buckets[i].first = hashtable->buckets[i].last = |
||||
&hashtable->list; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
void hashtable_close(hashtable_t *hashtable) |
||||
{ |
||||
hashtable_do_clear(hashtable); |
||||
jsonp_free(hashtable->buckets); |
||||
} |
||||
|
||||
int hashtable_set(hashtable_t *hashtable, |
||||
const char *key, size_t serial, |
||||
json_t *value) |
||||
{ |
||||
pair_t *pair; |
||||
bucket_t *bucket; |
||||
size_t hash, index; |
||||
|
||||
/* rehash if the load ratio exceeds 1 */ |
||||
if(hashtable->size >= num_buckets(hashtable)) |
||||
if(hashtable_do_rehash(hashtable)) |
||||
return -1; |
||||
|
||||
hash = hash_str(key); |
||||
index = hash % num_buckets(hashtable); |
||||
bucket = &hashtable->buckets[index]; |
||||
pair = hashtable_find_pair(hashtable, bucket, key, hash); |
||||
|
||||
if(pair) |
||||
{ |
||||
json_decref(pair->value); |
||||
pair->value = value; |
||||
} |
||||
else |
||||
{ |
||||
/* offsetof(...) returns the size of pair_t without the last,
|
||||
flexible member. This way, the correct amount is |
||||
allocated. */ |
||||
pair = (pair_t *)jsonp_malloc(offsetof(pair_t, key) + strlen(key) + 1); |
||||
if(!pair) |
||||
return -1; |
||||
|
||||
pair->hash = hash; |
||||
pair->serial = serial; |
||||
strcpy(pair->key, key); |
||||
pair->value = value; |
||||
list_init(&pair->list); |
||||
|
||||
insert_to_bucket(hashtable, bucket, &pair->list); |
||||
|
||||
hashtable->size++; |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
void *hashtable_get(hashtable_t *hashtable, const char *key) |
||||
{ |
||||
pair_t *pair; |
||||
size_t hash; |
||||
bucket_t *bucket; |
||||
|
||||
hash = hash_str(key); |
||||
bucket = &hashtable->buckets[hash % num_buckets(hashtable)]; |
||||
|
||||
pair = hashtable_find_pair(hashtable, bucket, key, hash); |
||||
if(!pair) |
||||
return NULL; |
||||
|
||||
return pair->value; |
||||
} |
||||
|
||||
int hashtable_del(hashtable_t *hashtable, const char *key) |
||||
{ |
||||
size_t hash = hash_str(key); |
||||
return hashtable_do_del(hashtable, key, hash); |
||||
} |
||||
|
||||
void hashtable_clear(hashtable_t *hashtable) |
||||
{ |
||||
size_t i; |
||||
|
||||
hashtable_do_clear(hashtable); |
||||
|
||||
for(i = 0; i < num_buckets(hashtable); i++) |
||||
{ |
||||
hashtable->buckets[i].first = hashtable->buckets[i].last = |
||||
&hashtable->list; |
||||
} |
||||
|
||||
list_init(&hashtable->list); |
||||
hashtable->size = 0; |
||||
} |
||||
|
||||
void *hashtable_iter(hashtable_t *hashtable) |
||||
{ |
||||
return hashtable_iter_next(hashtable, &hashtable->list); |
||||
} |
||||
|
||||
void *hashtable_iter_at(hashtable_t *hashtable, const char *key) |
||||
{ |
||||
pair_t *pair; |
||||
size_t hash; |
||||
bucket_t *bucket; |
||||
|
||||
hash = hash_str(key); |
||||
bucket = &hashtable->buckets[hash % num_buckets(hashtable)]; |
||||
|
||||
pair = hashtable_find_pair(hashtable, bucket, key, hash); |
||||
if(!pair) |
||||
return NULL; |
||||
|
||||
return &pair->list; |
||||
} |
||||
|
||||
void *hashtable_iter_next(hashtable_t *hashtable, void *iter) |
||||
{ |
||||
list_t *list = (list_t *)iter; |
||||
if(list->next == &hashtable->list) |
||||
return NULL; |
||||
return list->next; |
||||
} |
||||
|
||||
void *hashtable_iter_key(void *iter) |
||||
{ |
||||
pair_t *pair = list_to_pair((list_t *)iter); |
||||
return pair->key; |
||||
} |
||||
|
||||
size_t hashtable_iter_serial(void *iter) |
||||
{ |
||||
pair_t *pair = list_to_pair((list_t *)iter); |
||||
return pair->serial; |
||||
} |
||||
|
||||
void *hashtable_iter_value(void *iter) |
||||
{ |
||||
pair_t *pair = list_to_pair((list_t *)iter); |
||||
return pair->value; |
||||
} |
||||
|
||||
void hashtable_iter_set(void *iter, json_t *value) |
||||
{ |
||||
pair_t *pair = list_to_pair((list_t *)iter); |
||||
|
||||
json_decref(pair->value); |
||||
pair->value = value; |
||||
} |
||||
@ -1,180 +0,0 @@
@@ -1,180 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2009-2013 Petri Lehtinen <petri@digip.org> |
||||
* |
||||
* This library is free software; you can redistribute it and/or modify |
||||
* it under the terms of the MIT license. See LICENSE for details. |
||||
*/ |
||||
|
||||
#ifndef HASHTABLE_H |
||||
#define HASHTABLE_H |
||||
|
||||
struct hashtable_list { |
||||
struct hashtable_list *prev; |
||||
struct hashtable_list *next; |
||||
}; |
||||
|
||||
/* "pair" may be a bit confusing a name, but think of it as a
|
||||
key-value pair. In this case, it just encodes some extra data, |
||||
too */ |
||||
struct hashtable_pair { |
||||
size_t hash; |
||||
struct hashtable_list list; |
||||
json_t *value; |
||||
size_t serial; |
||||
char key[1]; |
||||
}; |
||||
|
||||
struct hashtable_bucket { |
||||
struct hashtable_list *first; |
||||
struct hashtable_list *last; |
||||
}; |
||||
|
||||
typedef struct hashtable { |
||||
size_t size; |
||||
struct hashtable_bucket *buckets; |
||||
size_t num_buckets; /* index to primes[] */ |
||||
struct hashtable_list list; |
||||
} hashtable_t; |
||||
|
||||
|
||||
#define hashtable_key_to_iter(key_) \ |
||||
(&(container_of(key_, struct hashtable_pair, key)->list)) |
||||
|
||||
/**
|
||||
* hashtable_init - Initialize a hashtable object |
||||
* |
||||
* @hashtable: The (statically allocated) hashtable object |
||||
* |
||||
* Initializes a statically allocated hashtable object. The object |
||||
* should be cleared with hashtable_close when it's no longer used. |
||||
* |
||||
* Returns 0 on success, -1 on error (out of memory). |
||||
*/ |
||||
int hashtable_init(hashtable_t *hashtable); |
||||
|
||||
/**
|
||||
* hashtable_close - Release all resources used by a hashtable object |
||||
* |
||||
* @hashtable: The hashtable |
||||
* |
||||
* Destroys a statically allocated hashtable object. |
||||
*/ |
||||
void hashtable_close(hashtable_t *hashtable); |
||||
|
||||
/**
|
||||
* hashtable_set - Add/modify value in hashtable |
||||
* |
||||
* @hashtable: The hashtable object |
||||
* @key: The key |
||||
* @serial: For addition order of keys |
||||
* @value: The value |
||||
* |
||||
* If a value with the given key already exists, its value is replaced |
||||
* with the new value. Value is "stealed" in the sense that hashtable |
||||
* doesn't increment its refcount but decreases the refcount when the |
||||
* value is no longer needed. |
||||
* |
||||
* Returns 0 on success, -1 on failure (out of memory). |
||||
*/ |
||||
int hashtable_set(hashtable_t *hashtable, |
||||
const char *key, size_t serial, |
||||
json_t *value); |
||||
|
||||
/**
|
||||
* hashtable_get - Get a value associated with a key |
||||
* |
||||
* @hashtable: The hashtable object |
||||
* @key: The key |
||||
* |
||||
* Returns value if it is found, or NULL otherwise. |
||||
*/ |
||||
void *hashtable_get(hashtable_t *hashtable, const char *key); |
||||
|
||||
/**
|
||||
* hashtable_del - Remove a value from the hashtable |
||||
* |
||||
* @hashtable: The hashtable object |
||||
* @key: The key |
||||
* |
||||
* Returns 0 on success, or -1 if the key was not found. |
||||
*/ |
||||
int hashtable_del(hashtable_t *hashtable, const char *key); |
||||
|
||||
/**
|
||||
* hashtable_clear - Clear hashtable |
||||
* |
||||
* @hashtable: The hashtable object |
||||
* |
||||
* Removes all items from the hashtable. |
||||
*/ |
||||
void hashtable_clear(hashtable_t *hashtable); |
||||
|
||||
/**
|
||||
* hashtable_iter - Iterate over hashtable |
||||
* |
||||
* @hashtable: The hashtable object |
||||
* |
||||
* Returns an opaque iterator to the first element in the hashtable. |
||||
* The iterator should be passed to hashtable_iter_* functions. |
||||
* The hashtable items are not iterated over in any particular order. |
||||
* |
||||
* There's no need to free the iterator in any way. The iterator is |
||||
* valid as long as the item that is referenced by the iterator is not |
||||
* deleted. Other values may be added or deleted. In particular, |
||||
* hashtable_iter_next() may be called on an iterator, and after that |
||||
* the key/value pair pointed by the old iterator may be deleted. |
||||
*/ |
||||
void *hashtable_iter(hashtable_t *hashtable); |
||||
|
||||
/**
|
||||
* hashtable_iter_at - Return an iterator at a specific key |
||||
* |
||||
* @hashtable: The hashtable object |
||||
* @key: The key that the iterator should point to |
||||
* |
||||
* Like hashtable_iter() but returns an iterator pointing to a |
||||
* specific key. |
||||
*/ |
||||
void *hashtable_iter_at(hashtable_t *hashtable, const char *key); |
||||
|
||||
/**
|
||||
* hashtable_iter_next - Advance an iterator |
||||
* |
||||
* @hashtable: The hashtable object |
||||
* @iter: The iterator |
||||
* |
||||
* Returns a new iterator pointing to the next element in the |
||||
* hashtable or NULL if the whole hastable has been iterated over. |
||||
*/ |
||||
void *hashtable_iter_next(hashtable_t *hashtable, void *iter); |
||||
|
||||
/**
|
||||
* hashtable_iter_key - Retrieve the key pointed by an iterator |
||||
* |
||||
* @iter: The iterator |
||||
*/ |
||||
void *hashtable_iter_key(void *iter); |
||||
|
||||
/**
|
||||
* hashtable_iter_serial - Retrieve the serial number pointed to by an iterator |
||||
* |
||||
* @iter: The iterator |
||||
*/ |
||||
size_t hashtable_iter_serial(void *iter); |
||||
|
||||
/**
|
||||
* hashtable_iter_value - Retrieve the value pointed by an iterator |
||||
* |
||||
* @iter: The iterator |
||||
*/ |
||||
void *hashtable_iter_value(void *iter); |
||||
|
||||
/**
|
||||
* hashtable_iter_set - Set the value pointed by an iterator |
||||
* |
||||
* @iter: The iterator |
||||
* @value: The value to set |
||||
*/ |
||||
void hashtable_iter_set(void *iter, json_t *value); |
||||
|
||||
#endif |
||||
@ -1,63 +0,0 @@
@@ -1,63 +0,0 @@
|
||||
EXPORTS |
||||
json_delete |
||||
json_true |
||||
json_false |
||||
json_null |
||||
json_string |
||||
json_string_nocheck |
||||
json_string_value |
||||
json_string_set |
||||
json_string_set_nocheck |
||||
json_integer |
||||
json_integer_value |
||||
json_integer_set |
||||
json_real |
||||
json_real_value |
||||
json_real_set |
||||
json_number_value |
||||
json_array |
||||
json_array_size |
||||
json_array_get |
||||
json_array_set_new |
||||
json_array_append_new |
||||
json_array_insert_new |
||||
json_array_remove |
||||
json_array_clear |
||||
json_array_extend |
||||
json_object |
||||
json_object_size |
||||
json_object_get |
||||
json_object_set_new |
||||
json_object_set_new_nocheck |
||||
json_object_del |
||||
json_object_clear |
||||
json_object_update |
||||
json_object_update_existing |
||||
json_object_update_missing |
||||
json_object_iter |
||||
json_object_iter_at |
||||
json_object_iter_next |
||||
json_object_iter_key |
||||
json_object_iter_value |
||||
json_object_iter_set_new |
||||
json_object_key_to_iter |
||||
json_dumps |
||||
json_dumpf |
||||
json_dump_file |
||||
json_dump_callback |
||||
json_loads |
||||
json_loadb |
||||
json_loadf |
||||
json_load_file |
||||
json_load_callback |
||||
json_equal |
||||
json_copy |
||||
json_deep_copy |
||||
json_pack |
||||
json_pack_ex |
||||
json_vpack_ex |
||||
json_unpack |
||||
json_unpack_ex |
||||
json_vunpack_ex |
||||
json_set_alloc_funcs |
||||
|
||||
@ -1,281 +0,0 @@
@@ -1,281 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2009-2013 Petri Lehtinen <petri@digip.org> |
||||
* |
||||
* Jansson is free software; you can redistribute it and/or modify |
||||
* it under the terms of the MIT license. See LICENSE for details. |
||||
*/ |
||||
|
||||
#ifndef JANSSON_H |
||||
#define JANSSON_H |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> /* for size_t */ |
||||
#include <stdarg.h> |
||||
|
||||
#include <jansson_config.h> |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
/* version */ |
||||
|
||||
#define JANSSON_MAJOR_VERSION 2 |
||||
#define JANSSON_MINOR_VERSION 5 |
||||
#define JANSSON_MICRO_VERSION 0 |
||||
|
||||
/* Micro version is omitted if it's 0 */ |
||||
#define JANSSON_VERSION "2.5" |
||||
|
||||
/* Version as a 3-byte hex number, e.g. 0x010201 == 1.2.1. Use this
|
||||
for numeric comparisons, e.g. #if JANSSON_VERSION_HEX >= ... */ |
||||
#define JANSSON_VERSION_HEX ((JANSSON_MAJOR_VERSION << 16) | \ |
||||
(JANSSON_MINOR_VERSION << 8) | \ |
||||
(JANSSON_MICRO_VERSION << 0)) |
||||
|
||||
|
||||
/* types */ |
||||
|
||||
typedef enum { |
||||
JSON_OBJECT, |
||||
JSON_ARRAY, |
||||
JSON_STRING, |
||||
JSON_INTEGER, |
||||
JSON_REAL, |
||||
JSON_TRUE, |
||||
JSON_FALSE, |
||||
JSON_NULL |
||||
} json_type; |
||||
|
||||
typedef struct json_t { |
||||
json_type type; |
||||
size_t refcount; |
||||
} json_t; |
||||
|
||||
#ifndef JANSSON_USING_CMAKE /* disabled if using cmake */ |
||||
#if JSON_INTEGER_IS_LONG_LONG |
||||
#ifdef _WIN32 |
||||
#define JSON_INTEGER_FORMAT "I64d" |
||||
#else |
||||
#define JSON_INTEGER_FORMAT "lld" |
||||
#endif |
||||
typedef long long json_int_t; |
||||
#else |
||||
#define JSON_INTEGER_FORMAT "ld" |
||||
typedef long json_int_t; |
||||
#endif /* JSON_INTEGER_IS_LONG_LONG */ |
||||
#endif |
||||
|
||||
#define json_typeof(json) ((json)->type) |
||||
#define json_is_object(json) (json && json_typeof(json) == JSON_OBJECT) |
||||
#define json_is_array(json) (json && json_typeof(json) == JSON_ARRAY) |
||||
#define json_is_string(json) (json && json_typeof(json) == JSON_STRING) |
||||
#define json_is_integer(json) (json && json_typeof(json) == JSON_INTEGER) |
||||
#define json_is_real(json) (json && json_typeof(json) == JSON_REAL) |
||||
#define json_is_number(json) (json_is_integer(json) || json_is_real(json)) |
||||
#define json_is_true(json) (json && json_typeof(json) == JSON_TRUE) |
||||
#define json_is_false(json) (json && json_typeof(json) == JSON_FALSE) |
||||
#define json_is_boolean(json) (json_is_true(json) || json_is_false(json)) |
||||
#define json_is_null(json) (json && json_typeof(json) == JSON_NULL) |
||||
|
||||
/* construction, destruction, reference counting */ |
||||
|
||||
json_t *json_object(void); |
||||
json_t *json_array(void); |
||||
json_t *json_string(const char *value); |
||||
json_t *json_string_nocheck(const char *value); |
||||
json_t *json_integer(json_int_t value); |
||||
json_t *json_real(double value); |
||||
json_t *json_true(void); |
||||
json_t *json_false(void); |
||||
#define json_boolean(val) ((val) ? json_true() : json_false()) |
||||
json_t *json_null(void); |
||||
|
||||
static JSON_INLINE |
||||
json_t *json_incref(json_t *json) |
||||
{ |
||||
if(json && json->refcount != (size_t)-1) |
||||
++json->refcount; |
||||
return json; |
||||
} |
||||
|
||||
/* do not call json_delete directly */ |
||||
void json_delete(json_t *json); |
||||
|
||||
static JSON_INLINE |
||||
void json_decref(json_t *json) |
||||
{ |
||||
if(json && json->refcount != (size_t)-1 && --json->refcount == 0) |
||||
json_delete(json); |
||||
} |
||||
|
||||
|
||||
/* error reporting */ |
||||
|
||||
#define JSON_ERROR_TEXT_LENGTH 160 |
||||
#define JSON_ERROR_SOURCE_LENGTH 80 |
||||
|
||||
typedef struct { |
||||
int line; |
||||
int column; |
||||
int position; |
||||
char source[JSON_ERROR_SOURCE_LENGTH]; |
||||
char text[JSON_ERROR_TEXT_LENGTH]; |
||||
} json_error_t; |
||||
|
||||
|
||||
/* getters, setters, manipulation */ |
||||
|
||||
size_t json_object_size(const json_t *object); |
||||
json_t *json_object_get(const json_t *object, const char *key); |
||||
int json_object_set_new(json_t *object, const char *key, json_t *value); |
||||
int json_object_set_new_nocheck(json_t *object, const char *key, json_t *value); |
||||
int json_object_del(json_t *object, const char *key); |
||||
int json_object_clear(json_t *object); |
||||
int json_object_update(json_t *object, json_t *other); |
||||
int json_object_update_existing(json_t *object, json_t *other); |
||||
int json_object_update_missing(json_t *object, json_t *other); |
||||
void *json_object_iter(json_t *object); |
||||
void *json_object_iter_at(json_t *object, const char *key); |
||||
void *json_object_key_to_iter(const char *key); |
||||
void *json_object_iter_next(json_t *object, void *iter); |
||||
const char *json_object_iter_key(void *iter); |
||||
json_t *json_object_iter_value(void *iter); |
||||
int json_object_iter_set_new(json_t *object, void *iter, json_t *value); |
||||
|
||||
#define json_object_foreach(object, key, value) \ |
||||
for(key = json_object_iter_key(json_object_iter(object)); \ |
||||
key && (value = json_object_iter_value(json_object_key_to_iter(key))); \ |
||||
key = json_object_iter_key(json_object_iter_next(object, json_object_key_to_iter(key)))) |
||||
|
||||
#define json_array_foreach(array, index, value) \ |
||||
for(index = 0; \ |
||||
index < json_array_size(array) && (value = json_array_get(array, index)); \ |
||||
index++) |
||||
|
||||
static JSON_INLINE |
||||
int json_object_set(json_t *object, const char *key, json_t *value) |
||||
{ |
||||
return json_object_set_new(object, key, json_incref(value)); |
||||
} |
||||
|
||||
static JSON_INLINE |
||||
int json_object_set_nocheck(json_t *object, const char *key, json_t *value) |
||||
{ |
||||
return json_object_set_new_nocheck(object, key, json_incref(value)); |
||||
} |
||||
|
||||
static JSON_INLINE |
||||
int json_object_iter_set(json_t *object, void *iter, json_t *value) |
||||
{ |
||||
return json_object_iter_set_new(object, iter, json_incref(value)); |
||||
} |
||||
|
||||
size_t json_array_size(const json_t *array); |
||||
json_t *json_array_get(const json_t *array, size_t index); |
||||
int json_array_set_new(json_t *array, size_t index, json_t *value); |
||||
int json_array_append_new(json_t *array, json_t *value); |
||||
int json_array_insert_new(json_t *array, size_t index, json_t *value); |
||||
int json_array_remove(json_t *array, size_t index); |
||||
int json_array_clear(json_t *array); |
||||
int json_array_extend(json_t *array, json_t *other); |
||||
|
||||
static JSON_INLINE |
||||
int json_array_set(json_t *array, size_t ind, json_t *value) |
||||
{ |
||||
return json_array_set_new(array, ind, json_incref(value)); |
||||
} |
||||
|
||||
static JSON_INLINE |
||||
int json_array_append(json_t *array, json_t *value) |
||||
{ |
||||
return json_array_append_new(array, json_incref(value)); |
||||
} |
||||
|
||||
static JSON_INLINE |
||||
int json_array_insert(json_t *array, size_t ind, json_t *value) |
||||
{ |
||||
return json_array_insert_new(array, ind, json_incref(value)); |
||||
} |
||||
|
||||
const char *json_string_value(const json_t *string); |
||||
json_int_t json_integer_value(const json_t *integer); |
||||
double json_real_value(const json_t *real); |
||||
double json_number_value(const json_t *json); |
||||
|
||||
int json_string_set(json_t *string, const char *value); |
||||
int json_string_set_nocheck(json_t *string, const char *value); |
||||
int json_integer_set(json_t *integer, json_int_t value); |
||||
int json_real_set(json_t *real, double value); |
||||
|
||||
|
||||
/* pack, unpack */ |
||||
|
||||
json_t *json_pack(const char *fmt, ...); |
||||
json_t *json_pack_ex(json_error_t *error, size_t flags, const char *fmt, ...); |
||||
json_t *json_vpack_ex(json_error_t *error, size_t flags, const char *fmt, va_list ap); |
||||
|
||||
#define JSON_VALIDATE_ONLY 0x1 |
||||
#define JSON_STRICT 0x2 |
||||
|
||||
int json_unpack(json_t *root, const char *fmt, ...); |
||||
int json_unpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, ...); |
||||
int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, va_list ap); |
||||
|
||||
|
||||
/* equality */ |
||||
|
||||
int json_equal(json_t *value1, json_t *value2); |
||||
|
||||
|
||||
/* copying */ |
||||
|
||||
json_t *json_copy(json_t *value); |
||||
json_t *json_deep_copy(const json_t *value); |
||||
|
||||
|
||||
/* decoding */ |
||||
|
||||
#define JSON_REJECT_DUPLICATES 0x1 |
||||
#define JSON_DISABLE_EOF_CHECK 0x2 |
||||
#define JSON_DECODE_ANY 0x4 |
||||
#define JSON_DECODE_INT_AS_REAL 0x8 |
||||
|
||||
typedef size_t (*json_load_callback_t)(void *buffer, size_t buflen, void *data); |
||||
|
||||
json_t *json_loads(const char *input, size_t flags, json_error_t *error); |
||||
json_t *json_loadb(const char *buffer, size_t buflen, size_t flags, json_error_t *error); |
||||
json_t *json_loadf(FILE *input, size_t flags, json_error_t *error); |
||||
json_t *json_load_file(const char *path, size_t flags, json_error_t *error); |
||||
json_t *json_load_callback(json_load_callback_t callback, void *data, size_t flags, json_error_t *error); |
||||
|
||||
|
||||
/* encoding */ |
||||
|
||||
#define JSON_INDENT(n) (n & 0x1F) |
||||
#define JSON_COMPACT 0x20 |
||||
#define JSON_ENSURE_ASCII 0x40 |
||||
#define JSON_SORT_KEYS 0x80 |
||||
#define JSON_PRESERVE_ORDER 0x100 |
||||
#define JSON_ENCODE_ANY 0x200 |
||||
#define JSON_ESCAPE_SLASH 0x400 |
||||
|
||||
typedef int (*json_dump_callback_t)(const char *buffer, size_t size, void *data); |
||||
|
||||
char *json_dumps(const json_t *json, size_t flags); |
||||
int json_dumpf(const json_t *json, FILE *output, size_t flags); |
||||
int json_dump_file(const json_t *json, const char *path, size_t flags); |
||||
int json_dump_callback(const json_t *json, json_dump_callback_t callback, void *data, size_t flags); |
||||
|
||||
/* custom memory allocation */ |
||||
|
||||
typedef void *(*json_malloc_t)(size_t); |
||||
typedef void (*json_free_t)(void *); |
||||
|
||||
void json_set_alloc_funcs(json_malloc_t malloc_fn, json_free_t free_fn); |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
|
||||
#endif |
||||
@ -1,39 +0,0 @@
@@ -1,39 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2010-2013 Petri Lehtinen <petri@digip.org> |
||||
* |
||||
* Jansson is free software; you can redistribute it and/or modify |
||||
* it under the terms of the MIT license. See LICENSE for details. |
||||
* |
||||
* |
||||
* This file specifies a part of the site-specific configuration for |
||||
* Jansson, namely those things that affect the public API in |
||||
* jansson.h. |
||||
* |
||||
* The configure script copies this file to jansson_config.h and |
||||
* replaces @var@ substitutions by values that fit your system. If you |
||||
* cannot run the configure script, you can do the value substitution |
||||
* by hand. |
||||
*/ |
||||
|
||||
#ifndef JANSSON_CONFIG_H |
||||
#define JANSSON_CONFIG_H |
||||
|
||||
/* If your compiler supports the inline keyword in C, JSON_INLINE is
|
||||
defined to `inline', otherwise empty. In C++, the inline is always |
||||
supported. */ |
||||
#ifdef __cplusplus |
||||
#define JSON_INLINE inline |
||||
#else |
||||
#define JSON_INLINE @json_inline@ |
||||
#endif |
||||
|
||||
/* If your compiler supports the `long long` type and the strtoll()
|
||||
library function, JSON_INTEGER_IS_LONG_LONG is defined to 1, |
||||
otherwise to 0. */ |
||||
#define JSON_INTEGER_IS_LONG_LONG @json_have_long_long@ |
||||
|
||||
/* If locale.h and localeconv() are available, define to 1,
|
||||
otherwise to 0. */ |
||||
#define JSON_HAVE_LOCALECONV @json_have_localeconv@ |
||||
|
||||
#endif |
||||
@ -1,93 +0,0 @@
@@ -1,93 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2009-2013 Petri Lehtinen <petri@digip.org> |
||||
* |
||||
* Jansson is free software; you can redistribute it and/or modify |
||||
* it under the terms of the MIT license. See LICENSE for details. |
||||
*/ |
||||
|
||||
#ifndef JANSSON_PRIVATE_H |
||||
#define JANSSON_PRIVATE_H |
||||
|
||||
#include <stddef.h> |
||||
#include "jansson.h" |
||||
#include "hashtable.h" |
||||
#include "strbuffer.h" |
||||
|
||||
#define container_of(ptr_, type_, member_) \ |
||||
((type_ *)((char *)ptr_ - offsetof(type_, member_))) |
||||
|
||||
/* On some platforms, max() may already be defined */ |
||||
#ifndef max |
||||
#define max(a, b) ((a) > (b) ? (a) : (b)) |
||||
#endif |
||||
|
||||
/* va_copy is a C99 feature. In C89 implementations, it's sometimes
|
||||
available as __va_copy. If not, memcpy() should do the trick. */ |
||||
#ifndef va_copy |
||||
#ifdef __va_copy |
||||
#define va_copy __va_copy |
||||
#else |
||||
#define va_copy(a, b) memcpy(&(a), &(b), sizeof(va_list)) |
||||
#endif |
||||
#endif |
||||
|
||||
typedef struct { |
||||
json_t json; |
||||
hashtable_t hashtable; |
||||
size_t serial; |
||||
int visited; |
||||
} json_object_t; |
||||
|
||||
typedef struct { |
||||
json_t json; |
||||
size_t size; |
||||
size_t entries; |
||||
json_t **table; |
||||
int visited; |
||||
} json_array_t; |
||||
|
||||
typedef struct { |
||||
json_t json; |
||||
char *value; |
||||
} json_string_t; |
||||
|
||||
typedef struct { |
||||
json_t json; |
||||
double value; |
||||
} json_real_t; |
||||
|
||||
typedef struct { |
||||
json_t json; |
||||
json_int_t value; |
||||
} json_integer_t; |
||||
|
||||
#define json_to_object(json_) container_of(json_, json_object_t, json) |
||||
#define json_to_array(json_) container_of(json_, json_array_t, json) |
||||
#define json_to_string(json_) container_of(json_, json_string_t, json) |
||||
#define json_to_real(json_) container_of(json_, json_real_t, json) |
||||
#define json_to_integer(json_) container_of(json_, json_integer_t, json) |
||||
|
||||
void jsonp_error_init(json_error_t *error, const char *source); |
||||
void jsonp_error_set_source(json_error_t *error, const char *source); |
||||
void jsonp_error_set(json_error_t *error, int line, int column, |
||||
size_t position, const char *msg, ...); |
||||
void jsonp_error_vset(json_error_t *error, int line, int column, |
||||
size_t position, const char *msg, va_list ap); |
||||
|
||||
/* Locale independent string<->double conversions */ |
||||
int jsonp_strtod(strbuffer_t *strbuffer, double *out); |
||||
int jsonp_dtostr(char *buffer, size_t size, double value); |
||||
|
||||
/* Wrappers for custom memory functions */ |
||||
void* jsonp_malloc(size_t size); |
||||
void jsonp_free(void *ptr); |
||||
char *jsonp_strndup(const char *str, size_t length); |
||||
char *jsonp_strdup(const char *str); |
||||
|
||||
/* Windows compatibility */ |
||||
#ifdef _WIN32 |
||||
#define snprintf _snprintf |
||||
#define vsnprintf _vsnprintf |
||||
#endif |
||||
|
||||
#endif |
||||
@ -1,56 +0,0 @@
@@ -1,56 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2009-2013 Petri Lehtinen <petri@digip.org> |
||||
* Copyright (c) 2011-2012 Basile Starynkevitch <basile@starynkevitch.net> |
||||
* |
||||
* Jansson is free software; you can redistribute it and/or modify it |
||||
* under the terms of the MIT license. See LICENSE for details. |
||||
*/ |
||||
|
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
|
||||
#include "jansson.h" |
||||
#include "jansson_private.h" |
||||
|
||||
/* memory function pointers */ |
||||
static json_malloc_t do_malloc = malloc; |
||||
static json_free_t do_free = free; |
||||
|
||||
void *jsonp_malloc(size_t size) |
||||
{ |
||||
if(!size) |
||||
return NULL; |
||||
|
||||
return (*do_malloc)(size); |
||||
} |
||||
|
||||
void jsonp_free(void *ptr) |
||||
{ |
||||
if(!ptr) |
||||
return; |
||||
|
||||
(*do_free)(ptr); |
||||
} |
||||
|
||||
char *jsonp_strdup(const char *str) |
||||
{ |
||||
char *new_str; |
||||
size_t len; |
||||
|
||||
len = strlen(str); |
||||
if(len == (size_t)-1) |
||||
return NULL; |
||||
|
||||
new_str = (char *)jsonp_malloc(len + 1); |
||||
if(!new_str) |
||||
return NULL; |
||||
|
||||
memcpy(new_str, str, len + 1); |
||||
return new_str; |
||||
} |
||||
|
||||
void json_set_alloc_funcs(json_malloc_t malloc_fn, json_free_t free_fn) |
||||
{ |
||||
do_malloc = malloc_fn; |
||||
do_free = free_fn; |
||||
} |
||||
@ -1,762 +0,0 @@
@@ -1,762 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2009-2013 Petri Lehtinen <petri@digip.org> |
||||
* Copyright (c) 2011-2012 Graeme Smecher <graeme.smecher@mail.mcgill.ca> |
||||
* |
||||
* Jansson is free software; you can redistribute it and/or modify |
||||
* it under the terms of the MIT license. See LICENSE for details. |
||||
*/ |
||||
|
||||
#include <string.h> |
||||
#include "jansson.h" |
||||
#include "jansson_private.h" |
||||
#include "utf.h" |
||||
|
||||
typedef struct { |
||||
int line; |
||||
int column; |
||||
size_t pos; |
||||
char token; |
||||
} token_t; |
||||
|
||||
typedef struct { |
||||
const char *start; |
||||
const char *fmt; |
||||
token_t prev_token; |
||||
token_t token; |
||||
token_t next_token; |
||||
json_error_t *error; |
||||
size_t flags; |
||||
int line; |
||||
int column; |
||||
size_t pos; |
||||
} scanner_t; |
||||
|
||||
#define token(scanner) ((scanner)->token.token) |
||||
|
||||
static const char * const type_names[] = { |
||||
"object", |
||||
"array", |
||||
"string", |
||||
"integer", |
||||
"real", |
||||
"true", |
||||
"false", |
||||
"null" |
||||
}; |
||||
|
||||
#define type_name(x) type_names[json_typeof(x)] |
||||
|
||||
static const char unpack_value_starters[] = "{[siIbfFOon"; |
||||
|
||||
|
||||
static void scanner_init(scanner_t *s, json_error_t *error, |
||||
size_t flags, const char *fmt) |
||||
{ |
||||
s->error = error; |
||||
s->flags = flags; |
||||
s->fmt = s->start = fmt; |
||||
memset(&s->prev_token, 0, sizeof(token_t)); |
||||
memset(&s->token, 0, sizeof(token_t)); |
||||
memset(&s->next_token, 0, sizeof(token_t)); |
||||
s->line = 1; |
||||
s->column = 0; |
||||
s->pos = 0; |
||||
} |
||||
|
||||
static void next_token(scanner_t *s) |
||||
{ |
||||
const char *t; |
||||
s->prev_token = s->token; |
||||
|
||||
if(s->next_token.line) { |
||||
s->token = s->next_token; |
||||
s->next_token.line = 0; |
||||
return; |
||||
} |
||||
|
||||
t = s->fmt; |
||||
s->column++; |
||||
s->pos++; |
||||
|
||||
/* skip space and ignored chars */ |
||||
while(*t == ' ' || *t == '\t' || *t == '\n' || *t == ',' || *t == ':') { |
||||
if(*t == '\n') { |
||||
s->line++; |
||||
s->column = 1; |
||||
} |
||||
else |
||||
s->column++; |
||||
|
||||
s->pos++; |
||||
t++; |
||||
} |
||||
|
||||
s->token.token = *t; |
||||
s->token.line = s->line; |
||||
s->token.column = s->column; |
||||
s->token.pos = s->pos; |
||||
|
||||
t++; |
||||
s->fmt = t; |
||||
} |
||||
|
||||
static void prev_token(scanner_t *s) |
||||
{ |
||||
s->next_token = s->token; |
||||
s->token = s->prev_token; |
||||
} |
||||
|
||||
static void set_error(scanner_t *s, const char *source, const char *fmt, ...) |
||||
{ |
||||
va_list ap; |
||||
va_start(ap, fmt); |
||||
|
||||
jsonp_error_vset(s->error, s->token.line, s->token.column, s->token.pos, |
||||
fmt, ap); |
||||
|
||||
jsonp_error_set_source(s->error, source); |
||||
|
||||
va_end(ap); |
||||
} |
||||
|
||||
static json_t *pack(scanner_t *s, va_list *ap); |
||||
|
||||
|
||||
/* ours will be set to 1 if jsonp_free() must be called for the result
|
||||
afterwards */ |
||||
static char *read_string(scanner_t *s, va_list *ap, |
||||
const char *purpose, int *ours) |
||||
{ |
||||
char t; |
||||
strbuffer_t strbuff; |
||||
const char *str; |
||||
size_t length; |
||||
char *result; |
||||
|
||||
next_token(s); |
||||
t = token(s); |
||||
prev_token(s); |
||||
|
||||
if(t != '#' && t != '+') { |
||||
/* Optimize the simple case */ |
||||
str = va_arg(*ap, const char *); |
||||
|
||||
if(!str) { |
||||
set_error(s, "<args>", "NULL string argument"); |
||||
return NULL; |
||||
} |
||||
|
||||
if(!utf8_check_string(str, -1)) { |
||||
set_error(s, "<args>", "Invalid UTF-8 %s", purpose); |
||||
return NULL; |
||||
} |
||||
|
||||
*ours = 0; |
||||
return (char *)str; |
||||
} |
||||
|
||||
strbuffer_init(&strbuff); |
||||
|
||||
while(1) { |
||||
str = va_arg(*ap, const char *); |
||||
if(!str) { |
||||
set_error(s, "<args>", "NULL string argument"); |
||||
strbuffer_close(&strbuff); |
||||
return NULL; |
||||
} |
||||
|
||||
next_token(s); |
||||
|
||||
if(token(s) == '#') { |
||||
length = va_arg(*ap, int); |
||||
} |
||||
else { |
||||
prev_token(s); |
||||
length = strlen(str); |
||||
} |
||||
|
||||
if(strbuffer_append_bytes(&strbuff, str, length) == -1) { |
||||
set_error(s, "<internal>", "Out of memory"); |
||||
strbuffer_close(&strbuff); |
||||
return NULL; |
||||
} |
||||
|
||||
next_token(s); |
||||
if(token(s) != '+') { |
||||
prev_token(s); |
||||
break; |
||||
} |
||||
} |
||||
|
||||
result = strbuffer_steal_value(&strbuff); |
||||
|
||||
if(!utf8_check_string(result, -1)) { |
||||
set_error(s, "<args>", "Invalid UTF-8 %s", purpose); |
||||
return NULL; |
||||
} |
||||
|
||||
*ours = 1; |
||||
return result; |
||||
} |
||||
|
||||
static json_t *pack_object(scanner_t *s, va_list *ap) |
||||
{ |
||||
json_t *object = json_object(); |
||||
next_token(s); |
||||
|
||||
while(token(s) != '}') { |
||||
char *key; |
||||
int ours; |
||||
json_t *value; |
||||
|
||||
if(!token(s)) { |
||||
set_error(s, "<format>", "Unexpected end of format string"); |
||||
goto error; |
||||
} |
||||
|
||||
if(token(s) != 's') { |
||||
set_error(s, "<format>", "Expected format 's', got '%c'", token(s)); |
||||
goto error; |
||||
} |
||||
|
||||
key = read_string(s, ap, "object key", &ours); |
||||
if(!key) |
||||
goto error; |
||||
|
||||
next_token(s); |
||||
|
||||
value = pack(s, ap); |
||||
if(!value) |
||||
goto error; |
||||
|
||||
if(json_object_set_new_nocheck(object, key, value)) { |
||||
if(ours) |
||||
jsonp_free(key); |
||||
|
||||
set_error(s, "<internal>", "Unable to add key \"%s\"", key); |
||||
goto error; |
||||
} |
||||
|
||||
if(ours) |
||||
jsonp_free(key); |
||||
|
||||
next_token(s); |
||||
} |
||||
|
||||
return object; |
||||
|
||||
error: |
||||
json_decref(object); |
||||
return NULL; |
||||
} |
||||
|
||||
static json_t *pack_array(scanner_t *s, va_list *ap) |
||||
{ |
||||
json_t *array = json_array(); |
||||
next_token(s); |
||||
|
||||
while(token(s) != ']') { |
||||
json_t *value; |
||||
|
||||
if(!token(s)) { |
||||
set_error(s, "<format>", "Unexpected end of format string"); |
||||
goto error; |
||||
} |
||||
|
||||
value = pack(s, ap); |
||||
if(!value) |
||||
goto error; |
||||
|
||||
if(json_array_append_new(array, value)) { |
||||
set_error(s, "<internal>", "Unable to append to array"); |
||||
goto error; |
||||
} |
||||
|
||||
next_token(s); |
||||
} |
||||
return array; |
||||
|
||||
error: |
||||
json_decref(array); |
||||
return NULL; |
||||
} |
||||
|
||||
static json_t *pack(scanner_t *s, va_list *ap) |
||||
{ |
||||
switch(token(s)) { |
||||
case '{': |
||||
return pack_object(s, ap); |
||||
|
||||
case '[': |
||||
return pack_array(s, ap); |
||||
|
||||
case 's': { /* string */ |
||||
char *str; |
||||
int ours; |
||||
json_t *result; |
||||
|
||||
str = read_string(s, ap, "string", &ours); |
||||
if(!str) |
||||
return NULL; |
||||
|
||||
result = json_string_nocheck(str); |
||||
if(ours) |
||||
jsonp_free(str); |
||||
|
||||
return result; |
||||
} |
||||
|
||||
case 'n': /* null */ |
||||
return json_null(); |
||||
|
||||
case 'b': /* boolean */ |
||||
return va_arg(*ap, int) ? json_true() : json_false(); |
||||
|
||||
case 'i': /* integer from int */ |
||||
return json_integer(va_arg(*ap, int)); |
||||
|
||||
case 'I': /* integer from json_int_t */ |
||||
return json_integer(va_arg(*ap, json_int_t)); |
||||
|
||||
case 'f': /* real */ |
||||
return json_real(va_arg(*ap, double)); |
||||
|
||||
case 'O': /* a json_t object; increments refcount */ |
||||
return json_incref(va_arg(*ap, json_t *)); |
||||
|
||||
case 'o': /* a json_t object; doesn't increment refcount */ |
||||
return va_arg(*ap, json_t *); |
||||
|
||||
default: |
||||
set_error(s, "<format>", "Unexpected format character '%c'", |
||||
token(s)); |
||||
return NULL; |
||||
} |
||||
} |
||||
|
||||
static int unpack(scanner_t *s, json_t *root, va_list *ap); |
||||
|
||||
static int unpack_object(scanner_t *s, json_t *root, va_list *ap) |
||||
{ |
||||
int ret = -1; |
||||
int strict = 0; |
||||
|
||||
/* Use a set (emulated by a hashtable) to check that all object
|
||||
keys are accessed. Checking that the correct number of keys |
||||
were accessed is not enough, as the same key can be unpacked |
||||
multiple times. |
||||
*/ |
||||
hashtable_t key_set; |
||||
|
||||
if(hashtable_init(&key_set)) { |
||||
set_error(s, "<internal>", "Out of memory"); |
||||
return -1; |
||||
} |
||||
|
||||
if(root && !json_is_object(root)) { |
||||
set_error(s, "<validation>", "Expected object, got %s", |
||||
type_name(root)); |
||||
goto out; |
||||
} |
||||
next_token(s); |
||||
|
||||
while(token(s) != '}') { |
||||
const char *key; |
||||
json_t *value; |
||||
int opt = 0; |
||||
|
||||
if(strict != 0) { |
||||
set_error(s, "<format>", "Expected '}' after '%c', got '%c'", |
||||
(strict == 1 ? '!' : '*'), token(s)); |
||||
goto out; |
||||
} |
||||
|
||||
if(!token(s)) { |
||||
set_error(s, "<format>", "Unexpected end of format string"); |
||||
goto out; |
||||
} |
||||
|
||||
if(token(s) == '!' || token(s) == '*') { |
||||
strict = (token(s) == '!' ? 1 : -1); |
||||
next_token(s); |
||||
continue; |
||||
} |
||||
|
||||
if(token(s) != 's') { |
||||
set_error(s, "<format>", "Expected format 's', got '%c'", token(s)); |
||||
goto out; |
||||
} |
||||
|
||||
key = va_arg(*ap, const char *); |
||||
if(!key) { |
||||
set_error(s, "<args>", "NULL object key"); |
||||
goto out; |
||||
} |
||||
|
||||
next_token(s); |
||||
|
||||
if(token(s) == '?') { |
||||
opt = 1; |
||||
next_token(s); |
||||
} |
||||
|
||||
if(!root) { |
||||
/* skipping */ |
||||
value = NULL; |
||||
} |
||||
else { |
||||
value = json_object_get(root, key); |
||||
if(!value && !opt) { |
||||
set_error(s, "<validation>", "Object item not found: %s", key); |
||||
goto out; |
||||
} |
||||
} |
||||
|
||||
if(unpack(s, value, ap)) |
||||
goto out; |
||||
|
||||
hashtable_set(&key_set, key, 0, json_null()); |
||||
next_token(s); |
||||
} |
||||
|
||||
if(strict == 0 && (s->flags & JSON_STRICT)) |
||||
strict = 1; |
||||
|
||||
if(root && strict == 1 && key_set.size != json_object_size(root)) { |
||||
long diff = (long)json_object_size(root) - (long)key_set.size; |
||||
set_error(s, "<validation>", "%li object item(s) left unpacked", diff); |
||||
goto out; |
||||
} |
||||
|
||||
ret = 0; |
||||
|
||||
out: |
||||
hashtable_close(&key_set); |
||||
return ret; |
||||
} |
||||
|
||||
static int unpack_array(scanner_t *s, json_t *root, va_list *ap) |
||||
{ |
||||
size_t i = 0; |
||||
int strict = 0; |
||||
|
||||
if(root && !json_is_array(root)) { |
||||
set_error(s, "<validation>", "Expected array, got %s", type_name(root)); |
||||
return -1; |
||||
} |
||||
next_token(s); |
||||
|
||||
while(token(s) != ']') { |
||||
json_t *value; |
||||
|
||||
if(strict != 0) { |
||||
set_error(s, "<format>", "Expected ']' after '%c', got '%c'", |
||||
(strict == 1 ? '!' : '*'), |
||||
token(s)); |
||||
return -1; |
||||
} |
||||
|
||||
if(!token(s)) { |
||||
set_error(s, "<format>", "Unexpected end of format string"); |
||||
return -1; |
||||
} |
||||
|
||||
if(token(s) == '!' || token(s) == '*') { |
||||
strict = (token(s) == '!' ? 1 : -1); |
||||
next_token(s); |
||||
continue; |
||||
} |
||||
|
||||
if(!strchr(unpack_value_starters, token(s))) { |
||||
set_error(s, "<format>", "Unexpected format character '%c'", |
||||
token(s)); |
||||
return -1; |
||||
} |
||||
|
||||
if(!root) { |
||||
/* skipping */ |
||||
value = NULL; |
||||
} |
||||
else { |
||||
value = json_array_get(root, i); |
||||
if(!value) { |
||||
set_error(s, "<validation>", "Array index %lu out of range", |
||||
(unsigned long)i); |
||||
return -1; |
||||
} |
||||
} |
||||
|
||||
if(unpack(s, value, ap)) |
||||
return -1; |
||||
|
||||
next_token(s); |
||||
i++; |
||||
} |
||||
|
||||
if(strict == 0 && (s->flags & JSON_STRICT)) |
||||
strict = 1; |
||||
|
||||
if(root && strict == 1 && i != json_array_size(root)) { |
||||
long diff = (long)json_array_size(root) - (long)i; |
||||
set_error(s, "<validation>", "%li array item(s) left unpacked", diff); |
||||
return -1; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static int unpack(scanner_t *s, json_t *root, va_list *ap) |
||||
{ |
||||
switch(token(s)) |
||||
{ |
||||
case '{': |
||||
return unpack_object(s, root, ap); |
||||
|
||||
case '[': |
||||
return unpack_array(s, root, ap); |
||||
|
||||
case 's': |
||||
if(root && !json_is_string(root)) { |
||||
set_error(s, "<validation>", "Expected string, got %s", |
||||
type_name(root)); |
||||
return -1; |
||||
} |
||||
|
||||
if(!(s->flags & JSON_VALIDATE_ONLY)) { |
||||
const char **target; |
||||
|
||||
target = va_arg(*ap, const char **); |
||||
if(!target) { |
||||
set_error(s, "<args>", "NULL string argument"); |
||||
return -1; |
||||
} |
||||
|
||||
if(root) |
||||
*target = json_string_value(root); |
||||
} |
||||
return 0; |
||||
|
||||
case 'i': |
||||
if(root && !json_is_integer(root)) { |
||||
set_error(s, "<validation>", "Expected integer, got %s", |
||||
type_name(root)); |
||||
return -1; |
||||
} |
||||
|
||||
if(!(s->flags & JSON_VALIDATE_ONLY)) { |
||||
int *target = va_arg(*ap, int*); |
||||
if(root) |
||||
*target = (int)json_integer_value(root); |
||||
} |
||||
|
||||
return 0; |
||||
|
||||
case 'I': |
||||
if(root && !json_is_integer(root)) { |
||||
set_error(s, "<validation>", "Expected integer, got %s", |
||||
type_name(root)); |
||||
return -1; |
||||
} |
||||
|
||||
if(!(s->flags & JSON_VALIDATE_ONLY)) { |
||||
json_int_t *target = va_arg(*ap, json_int_t*); |
||||
if(root) |
||||
*target = json_integer_value(root); |
||||
} |
||||
|
||||
return 0; |
||||
|
||||
case 'b': |
||||
if(root && !json_is_boolean(root)) { |
||||
set_error(s, "<validation>", "Expected true or false, got %s", |
||||
type_name(root)); |
||||
return -1; |
||||
} |
||||
|
||||
if(!(s->flags & JSON_VALIDATE_ONLY)) { |
||||
int *target = va_arg(*ap, int*); |
||||
if(root) |
||||
*target = json_is_true(root); |
||||
} |
||||
|
||||
return 0; |
||||
|
||||
case 'f': |
||||
if(root && !json_is_real(root)) { |
||||
set_error(s, "<validation>", "Expected real, got %s", |
||||
type_name(root)); |
||||
return -1; |
||||
} |
||||
|
||||
if(!(s->flags & JSON_VALIDATE_ONLY)) { |
||||
double *target = va_arg(*ap, double*); |
||||
if(root) |
||||
*target = json_real_value(root); |
||||
} |
||||
|
||||
return 0; |
||||
|
||||
case 'F': |
||||
if(root && !json_is_number(root)) { |
||||
set_error(s, "<validation>", "Expected real or integer, got %s", |
||||
type_name(root)); |
||||
return -1; |
||||
} |
||||
|
||||
if(!(s->flags & JSON_VALIDATE_ONLY)) { |
||||
double *target = va_arg(*ap, double*); |
||||
if(root) |
||||
*target = json_number_value(root); |
||||
} |
||||
|
||||
return 0; |
||||
|
||||
case 'O': |
||||
if(root && !(s->flags & JSON_VALIDATE_ONLY)) |
||||
json_incref(root); |
||||
/* Fall through */ |
||||
|
||||
case 'o': |
||||
if(!(s->flags & JSON_VALIDATE_ONLY)) { |
||||
json_t **target = va_arg(*ap, json_t**); |
||||
if(root) |
||||
*target = root; |
||||
} |
||||
|
||||
return 0; |
||||
|
||||
case 'n': |
||||
/* Never assign, just validate */ |
||||
if(root && !json_is_null(root)) { |
||||
set_error(s, "<validation>", "Expected null, got %s", |
||||
type_name(root)); |
||||
return -1; |
||||
} |
||||
return 0; |
||||
|
||||
default: |
||||
set_error(s, "<format>", "Unexpected format character '%c'", |
||||
token(s)); |
||||
return -1; |
||||
} |
||||
} |
||||
|
||||
json_t *json_vpack_ex(json_error_t *error, size_t flags, |
||||
const char *fmt, va_list ap) |
||||
{ |
||||
scanner_t s; |
||||
va_list ap_copy; |
||||
json_t *value; |
||||
|
||||
if(!fmt || !*fmt) { |
||||
jsonp_error_init(error, "<format>"); |
||||
jsonp_error_set(error, -1, -1, 0, "NULL or empty format string"); |
||||
return NULL; |
||||
} |
||||
jsonp_error_init(error, NULL); |
||||
|
||||
scanner_init(&s, error, flags, fmt); |
||||
next_token(&s); |
||||
|
||||
va_copy(ap_copy, ap); |
||||
value = pack(&s, &ap_copy); |
||||
va_end(ap_copy); |
||||
|
||||
if(!value) |
||||
return NULL; |
||||
|
||||
next_token(&s); |
||||
if(token(&s)) { |
||||
json_decref(value); |
||||
set_error(&s, "<format>", "Garbage after format string"); |
||||
return NULL; |
||||
} |
||||
|
||||
return value; |
||||
} |
||||
|
||||
json_t *json_pack_ex(json_error_t *error, size_t flags, const char *fmt, ...) |
||||
{ |
||||
json_t *value; |
||||
va_list ap; |
||||
|
||||
va_start(ap, fmt); |
||||
value = json_vpack_ex(error, flags, fmt, ap); |
||||
va_end(ap); |
||||
|
||||
return value; |
||||
} |
||||
|
||||
json_t *json_pack(const char *fmt, ...) |
||||
{ |
||||
json_t *value; |
||||
va_list ap; |
||||
|
||||
va_start(ap, fmt); |
||||
value = json_vpack_ex(NULL, 0, fmt, ap); |
||||
va_end(ap); |
||||
|
||||
return value; |
||||
} |
||||
|
||||
int json_vunpack_ex(json_t *root, json_error_t *error, size_t flags, |
||||
const char *fmt, va_list ap) |
||||
{ |
||||
scanner_t s; |
||||
va_list ap_copy; |
||||
|
||||
if(!root) { |
||||
jsonp_error_init(error, "<root>"); |
||||
jsonp_error_set(error, -1, -1, 0, "NULL root value"); |
||||
return -1; |
||||
} |
||||
|
||||
if(!fmt || !*fmt) { |
||||
jsonp_error_init(error, "<format>"); |
||||
jsonp_error_set(error, -1, -1, 0, "NULL or empty format string"); |
||||
return -1; |
||||
} |
||||
jsonp_error_init(error, NULL); |
||||
|
||||
scanner_init(&s, error, flags, fmt); |
||||
next_token(&s); |
||||
|
||||
va_copy(ap_copy, ap); |
||||
if(unpack(&s, root, &ap_copy)) { |
||||
va_end(ap_copy); |
||||
return -1; |
||||
} |
||||
va_end(ap_copy); |
||||
|
||||
next_token(&s); |
||||
if(token(&s)) { |
||||
set_error(&s, "<format>", "Garbage after format string"); |
||||
return -1; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int json_unpack_ex(json_t *root, json_error_t *error, size_t flags, const char *fmt, ...) |
||||
{ |
||||
int ret; |
||||
va_list ap; |
||||
|
||||
va_start(ap, fmt); |
||||
ret = json_vunpack_ex(root, error, flags, fmt, ap); |
||||
va_end(ap); |
||||
|
||||
return ret; |
||||
} |
||||
|
||||
int json_unpack(json_t *root, const char *fmt, ...) |
||||
{ |
||||
int ret; |
||||
va_list ap; |
||||
|
||||
va_start(ap, fmt); |
||||
ret = json_vunpack_ex(root, NULL, 0, fmt, ap); |
||||
va_end(ap); |
||||
|
||||
return ret; |
||||
} |
||||
@ -1,116 +0,0 @@
@@ -1,116 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2009-2013 Petri Lehtinen <petri@digip.org> |
||||
* |
||||
* Jansson is free software; you can redistribute it and/or modify |
||||
* it under the terms of the MIT license. See LICENSE for details. |
||||
*/ |
||||
|
||||
#ifndef _GNU_SOURCE |
||||
#define _GNU_SOURCE |
||||
#endif |
||||
|
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include "jansson_private.h" |
||||
#include "strbuffer.h" |
||||
|
||||
#define STRBUFFER_MIN_SIZE 16 |
||||
#define STRBUFFER_FACTOR 2 |
||||
#define STRBUFFER_SIZE_MAX ((size_t)-1) |
||||
|
||||
int strbuffer_init(strbuffer_t *strbuff) |
||||
{ |
||||
strbuff->size = STRBUFFER_MIN_SIZE; |
||||
strbuff->length = 0; |
||||
|
||||
strbuff->value = (char *)jsonp_malloc(strbuff->size); |
||||
if(!strbuff->value) |
||||
return -1; |
||||
|
||||
/* initialize to empty */ |
||||
strbuff->value[0] = '\0'; |
||||
return 0; |
||||
} |
||||
|
||||
void strbuffer_close(strbuffer_t *strbuff) |
||||
{ |
||||
if(strbuff->value) |
||||
jsonp_free(strbuff->value); |
||||
|
||||
strbuff->size = 0; |
||||
strbuff->length = 0; |
||||
strbuff->value = NULL; |
||||
} |
||||
|
||||
void strbuffer_clear(strbuffer_t *strbuff) |
||||
{ |
||||
strbuff->length = 0; |
||||
strbuff->value[0] = '\0'; |
||||
} |
||||
|
||||
const char *strbuffer_value(const strbuffer_t *strbuff) |
||||
{ |
||||
return strbuff->value; |
||||
} |
||||
|
||||
char *strbuffer_steal_value(strbuffer_t *strbuff) |
||||
{ |
||||
char *result = strbuff->value; |
||||
strbuff->value = NULL; |
||||
return result; |
||||
} |
||||
|
||||
int strbuffer_append(strbuffer_t *strbuff, const char *string) |
||||
{ |
||||
return strbuffer_append_bytes(strbuff, string, strlen(string)); |
||||
} |
||||
|
||||
int strbuffer_append_byte(strbuffer_t *strbuff, char byte) |
||||
{ |
||||
return strbuffer_append_bytes(strbuff, &byte, 1); |
||||
} |
||||
|
||||
int strbuffer_append_bytes(strbuffer_t *strbuff, const char *data, size_t size) |
||||
{ |
||||
if(size >= strbuff->size - strbuff->length) |
||||
{ |
||||
size_t new_size; |
||||
char *new_value; |
||||
|
||||
/* avoid integer overflow */ |
||||
if (strbuff->size > STRBUFFER_SIZE_MAX / STRBUFFER_FACTOR |
||||
|| size > STRBUFFER_SIZE_MAX - 1 |
||||
|| strbuff->length > STRBUFFER_SIZE_MAX - 1 - size) |
||||
return -1; |
||||
|
||||
new_size = max(strbuff->size * STRBUFFER_FACTOR, |
||||
strbuff->length + size + 1); |
||||
|
||||
new_value = (char *)jsonp_malloc(new_size); |
||||
if(!new_value) |
||||
return -1; |
||||
|
||||
memcpy(new_value, strbuff->value, strbuff->length); |
||||
|
||||
jsonp_free(strbuff->value); |
||||
strbuff->value = new_value; |
||||
strbuff->size = new_size; |
||||
} |
||||
|
||||
memcpy(strbuff->value + strbuff->length, data, size); |
||||
strbuff->length += size; |
||||
strbuff->value[strbuff->length] = '\0'; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
char strbuffer_pop(strbuffer_t *strbuff) |
||||
{ |
||||
if(strbuff->length > 0) { |
||||
char c = strbuff->value[--strbuff->length]; |
||||
strbuff->value[strbuff->length] = '\0'; |
||||
return c; |
||||
} |
||||
else |
||||
return '\0'; |
||||
} |
||||
@ -1,33 +0,0 @@
@@ -1,33 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2009-2013 Petri Lehtinen <petri@digip.org> |
||||
* |
||||
* Jansson is free software; you can redistribute it and/or modify |
||||
* it under the terms of the MIT license. See LICENSE for details. |
||||
*/ |
||||
|
||||
#ifndef STRBUFFER_H |
||||
#define STRBUFFER_H |
||||
|
||||
typedef struct { |
||||
char *value; |
||||
size_t length; /* bytes used */ |
||||
size_t size; /* bytes allocated */ |
||||
} strbuffer_t; |
||||
|
||||
int strbuffer_init(strbuffer_t *strbuff); |
||||
void strbuffer_close(strbuffer_t *strbuff); |
||||
|
||||
void strbuffer_clear(strbuffer_t *strbuff); |
||||
|
||||
const char *strbuffer_value(const strbuffer_t *strbuff); |
||||
|
||||
/* Steal the value and close the strbuffer */ |
||||
char *strbuffer_steal_value(strbuffer_t *strbuff); |
||||
|
||||
int strbuffer_append(strbuffer_t *strbuff, const char *string); |
||||
int strbuffer_append_byte(strbuffer_t *strbuff, char byte); |
||||
int strbuffer_append_bytes(strbuffer_t *strbuff, const char *data, size_t size); |
||||
|
||||
char strbuffer_pop(strbuffer_t *strbuff); |
||||
|
||||
#endif |
||||
@ -1,134 +0,0 @@
@@ -1,134 +0,0 @@
|
||||
#include <assert.h> |
||||
#include <errno.h> |
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include "jansson_private.h" |
||||
#include "strbuffer.h" |
||||
|
||||
/* need config.h to get the correct snprintf */ |
||||
#ifdef HAVE_CONFIG_H |
||||
#include <config.h> |
||||
#endif |
||||
|
||||
#if JSON_HAVE_LOCALECONV |
||||
#include <locale.h> |
||||
|
||||
/*
|
||||
- This code assumes that the decimal separator is exactly one |
||||
character. |
||||
|
||||
- If setlocale() is called by another thread between the call to |
||||
localeconv() and the call to sprintf() or strtod(), the result may |
||||
be wrong. setlocale() is not thread-safe and should not be used |
||||
this way. Multi-threaded programs should use uselocale() instead. |
||||
*/ |
||||
|
||||
static void to_locale(strbuffer_t *strbuffer) |
||||
{ |
||||
const char *point; |
||||
char *pos; |
||||
|
||||
point = localeconv()->decimal_point; |
||||
if(*point == '.') { |
||||
/* No conversion needed */ |
||||
return; |
||||
} |
||||
|
||||
pos = strchr(strbuffer->value, '.'); |
||||
if(pos) |
||||
*pos = *point; |
||||
} |
||||
|
||||
static void from_locale(char *buffer) |
||||
{ |
||||
const char *point; |
||||
char *pos; |
||||
|
||||
point = localeconv()->decimal_point; |
||||
if(*point == '.') { |
||||
/* No conversion needed */ |
||||
return; |
||||
} |
||||
|
||||
pos = strchr(buffer, *point); |
||||
if(pos) |
||||
*pos = '.'; |
||||
} |
||||
#endif |
||||
|
||||
int jsonp_strtod(strbuffer_t *strbuffer, double *out) |
||||
{ |
||||
double value; |
||||
char *end; |
||||
|
||||
#if JSON_HAVE_LOCALECONV |
||||
to_locale(strbuffer); |
||||
#endif |
||||
|
||||
errno = 0; |
||||
value = strtod(strbuffer->value, &end); |
||||
assert(end == strbuffer->value + strbuffer->length); |
||||
|
||||
if(errno == ERANGE && value != 0) { |
||||
/* Overflow */ |
||||
return -1; |
||||
} |
||||
|
||||
*out = value; |
||||
return 0; |
||||
} |
||||
|
||||
int jsonp_dtostr(char *buffer, size_t size, double value) |
||||
{ |
||||
int ret; |
||||
char *start, *end; |
||||
size_t length; |
||||
|
||||
ret = snprintf(buffer, size, "%.17g", value); |
||||
if(ret < 0) |
||||
return -1; |
||||
|
||||
length = (size_t)ret; |
||||
if(length >= size) |
||||
return -1; |
||||
|
||||
#if JSON_HAVE_LOCALECONV |
||||
from_locale(buffer); |
||||
#endif |
||||
|
||||
/* Make sure there's a dot or 'e' in the output. Otherwise
|
||||
a real is converted to an integer when decoding */ |
||||
if(strchr(buffer, '.') == NULL && |
||||
strchr(buffer, 'e') == NULL) |
||||
{ |
||||
if(length + 3 >= size) { |
||||
/* No space to append ".0" */ |
||||
return -1; |
||||
} |
||||
buffer[length] = '.'; |
||||
buffer[length + 1] = '0'; |
||||
buffer[length + 2] = '\0'; |
||||
length += 2; |
||||
} |
||||
|
||||
/* Remove leading '+' from positive exponent. Also remove leading
|
||||
zeros from exponents (added by some printf() implementations) */ |
||||
start = strchr(buffer, 'e'); |
||||
if(start) { |
||||
start++; |
||||
end = start + 1; |
||||
|
||||
if(*start == '-') |
||||
start++; |
||||
|
||||
while(*end == '0') |
||||
end++; |
||||
|
||||
if(end != start) { |
||||
memmove(start, end, length - (size_t)(end - buffer)); |
||||
length -= (size_t)(end - start); |
||||
} |
||||
} |
||||
|
||||
return (int)length; |
||||
} |
||||
@ -1,190 +0,0 @@
@@ -1,190 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2009-2013 Petri Lehtinen <petri@digip.org> |
||||
* |
||||
* Jansson is free software; you can redistribute it and/or modify |
||||
* it under the terms of the MIT license. See LICENSE for details. |
||||
*/ |
||||
|
||||
#include <string.h> |
||||
#include "utf.h" |
||||
|
||||
int utf8_encode(int32_t codepoint, char *buffer, int *size) |
||||
{ |
||||
if(codepoint < 0) |
||||
return -1; |
||||
else if(codepoint < 0x80) |
||||
{ |
||||
buffer[0] = (char)codepoint; |
||||
*size = 1; |
||||
} |
||||
else if(codepoint < 0x800) |
||||
{ |
||||
buffer[0] = 0xC0 + ((codepoint & 0x7C0) >> 6); |
||||
buffer[1] = 0x80 + ((codepoint & 0x03F)); |
||||
*size = 2; |
||||
} |
||||
else if(codepoint < 0x10000) |
||||
{ |
||||
buffer[0] = 0xE0 + ((codepoint & 0xF000) >> 12); |
||||
buffer[1] = 0x80 + ((codepoint & 0x0FC0) >> 6); |
||||
buffer[2] = 0x80 + ((codepoint & 0x003F)); |
||||
*size = 3; |
||||
} |
||||
else if(codepoint <= 0x10FFFF) |
||||
{ |
||||
buffer[0] = 0xF0 + ((codepoint & 0x1C0000) >> 18); |
||||
buffer[1] = 0x80 + ((codepoint & 0x03F000) >> 12); |
||||
buffer[2] = 0x80 + ((codepoint & 0x000FC0) >> 6); |
||||
buffer[3] = 0x80 + ((codepoint & 0x00003F)); |
||||
*size = 4; |
||||
} |
||||
else |
||||
return -1; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int utf8_check_first(char byte) |
||||
{ |
||||
unsigned char u = (unsigned char)byte; |
||||
|
||||
if(u < 0x80) |
||||
return 1; |
||||
|
||||
if(0x80 <= u && u <= 0xBF) { |
||||
/* second, third or fourth byte of a multi-byte
|
||||
sequence, i.e. a "continuation byte" */ |
||||
return 0; |
||||
} |
||||
else if(u == 0xC0 || u == 0xC1) { |
||||
/* overlong encoding of an ASCII byte */ |
||||
return 0; |
||||
} |
||||
else if(0xC2 <= u && u <= 0xDF) { |
||||
/* 2-byte sequence */ |
||||
return 2; |
||||
} |
||||
|
||||
else if(0xE0 <= u && u <= 0xEF) { |
||||
/* 3-byte sequence */ |
||||
return 3; |
||||
} |
||||
else if(0xF0 <= u && u <= 0xF4) { |
||||
/* 4-byte sequence */ |
||||
return 4; |
||||
} |
||||
else { /* u >= 0xF5 */ |
||||
/* Restricted (start of 4-, 5- or 6-byte sequence) or invalid
|
||||
UTF-8 */ |
||||
return 0; |
||||
} |
||||
} |
||||
|
||||
int utf8_check_full(const char *buffer, int size, int32_t *codepoint) |
||||
{ |
||||
int i; |
||||
int32_t value = 0; |
||||
unsigned char u = (unsigned char)buffer[0]; |
||||
|
||||
if(size == 2) |
||||
{ |
||||
value = u & 0x1F; |
||||
} |
||||
else if(size == 3) |
||||
{ |
||||
value = u & 0xF; |
||||
} |
||||
else if(size == 4) |
||||
{ |
||||
value = u & 0x7; |
||||
} |
||||
else |
||||
return 0; |
||||
|
||||
for(i = 1; i < size; i++) |
||||
{ |
||||
u = (unsigned char)buffer[i]; |
||||
|
||||
if(u < 0x80 || u > 0xBF) { |
||||
/* not a continuation byte */ |
||||
return 0; |
||||
} |
||||
|
||||
value = (value << 6) + (u & 0x3F); |
||||
} |
||||
|
||||
if(value > 0x10FFFF) { |
||||
/* not in Unicode range */ |
||||
return 0; |
||||
} |
||||
|
||||
else if(0xD800 <= value && value <= 0xDFFF) { |
||||
/* invalid code point (UTF-16 surrogate halves) */ |
||||
return 0; |
||||
} |
||||
|
||||
else if((size == 2 && value < 0x80) || |
||||
(size == 3 && value < 0x800) || |
||||
(size == 4 && value < 0x10000)) { |
||||
/* overlong encoding */ |
||||
return 0; |
||||
} |
||||
|
||||
if(codepoint) |
||||
*codepoint = value; |
||||
|
||||
return 1; |
||||
} |
||||
|
||||
const char *utf8_iterate(const char *buffer, int32_t *codepoint) |
||||
{ |
||||
int count; |
||||
int32_t value; |
||||
|
||||
if(!*buffer) |
||||
return buffer; |
||||
|
||||
count = utf8_check_first(buffer[0]); |
||||
if(count <= 0) |
||||
return NULL; |
||||
|
||||
if(count == 1) |
||||
value = (unsigned char)buffer[0]; |
||||
else |
||||
{ |
||||
if(!utf8_check_full(buffer, count, &value)) |
||||
return NULL; |
||||
} |
||||
|
||||
if(codepoint) |
||||
*codepoint = value; |
||||
|
||||
return buffer + count; |
||||
} |
||||
|
||||
int utf8_check_string(const char *string, int length) |
||||
{ |
||||
int i; |
||||
|
||||
if(length == -1) |
||||
length = strlen(string); |
||||
|
||||
for(i = 0; i < length; i++) |
||||
{ |
||||
int count = utf8_check_first(string[i]); |
||||
if(count == 0) |
||||
return 0; |
||||
else if(count > 1) |
||||
{ |
||||
if(i + count > length) |
||||
return 0; |
||||
|
||||
if(!utf8_check_full(&string[i], count, NULL)) |
||||
return 0; |
||||
|
||||
i += count - 1; |
||||
} |
||||
} |
||||
|
||||
return 1; |
||||
} |
||||
@ -1,39 +0,0 @@
@@ -1,39 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2009-2013 Petri Lehtinen <petri@digip.org> |
||||
* |
||||
* Jansson is free software; you can redistribute it and/or modify |
||||
* it under the terms of the MIT license. See LICENSE for details. |
||||
*/ |
||||
|
||||
#ifndef UTF_H |
||||
#define UTF_H |
||||
|
||||
#ifdef HAVE_CONFIG_H |
||||
#include <config.h> |
||||
|
||||
#ifdef HAVE_INTTYPES_H |
||||
/* inttypes.h includes stdint.h in a standard environment, so there's
|
||||
no need to include stdint.h separately. If inttypes.h doesn't define |
||||
int32_t, it's defined in config.h. */ |
||||
#include <inttypes.h> |
||||
#endif /* HAVE_INTTYPES_H */ |
||||
|
||||
#else /* !HAVE_CONFIG_H */ |
||||
#ifdef _WIN32 |
||||
typedef int int32_t; |
||||
#else /* !_WIN32 */ |
||||
/* Assume a standard environment */ |
||||
#include <inttypes.h> |
||||
#endif /* _WIN32 */ |
||||
|
||||
#endif /* HAVE_CONFIG_H */ |
||||
|
||||
int utf8_encode(int codepoint, char *buffer, int *size); |
||||
|
||||
int utf8_check_first(char byte); |
||||
int utf8_check_full(const char *buffer, int size, int32_t *codepoint); |
||||
const char *utf8_iterate(const char *buffer, int32_t *codepoint); |
||||
|
||||
int utf8_check_string(const char *string, int length); |
||||
|
||||
#endif |
||||
@ -1,950 +0,0 @@
@@ -1,950 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2009-2013 Petri Lehtinen <petri@digip.org> |
||||
* |
||||
* Jansson is free software; you can redistribute it and/or modify |
||||
* it under the terms of the MIT license. See LICENSE for details. |
||||
*/ |
||||
|
||||
#ifndef _GNU_SOURCE |
||||
#define _GNU_SOURCE |
||||
#endif |
||||
|
||||
#include <stddef.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <math.h> |
||||
|
||||
#include "jansson.h" |
||||
#include "hashtable.h" |
||||
#include "jansson_private.h" |
||||
#include "utf.h" |
||||
|
||||
/* Work around nonstandard isnan() and isinf() implementations */ |
||||
#ifndef isnan |
||||
static JSON_INLINE int isnan(double x) { return x != x; } |
||||
#endif |
||||
#ifndef isinf |
||||
static JSON_INLINE int isinf(double x) { return !isnan(x) && isnan(x - x); } |
||||
#endif |
||||
|
||||
static JSON_INLINE void json_init(json_t *json, json_type type) |
||||
{ |
||||
json->type = type; |
||||
json->refcount = 1; |
||||
} |
||||
|
||||
|
||||
/*** object ***/ |
||||
|
||||
json_t *json_object(void) |
||||
{ |
||||
json_object_t *object = (json_object_t *)jsonp_malloc(sizeof(json_object_t)); |
||||
if(!object) |
||||
return NULL; |
||||
json_init(&object->json, JSON_OBJECT); |
||||
|
||||
if(hashtable_init(&object->hashtable)) |
||||
{ |
||||
jsonp_free(object); |
||||
return NULL; |
||||
} |
||||
|
||||
object->serial = 0; |
||||
object->visited = 0; |
||||
|
||||
return &object->json; |
||||
} |
||||
|
||||
static void json_delete_object(json_object_t *object) |
||||
{ |
||||
hashtable_close(&object->hashtable); |
||||
jsonp_free(object); |
||||
} |
||||
|
||||
size_t json_object_size(const json_t *json) |
||||
{ |
||||
json_object_t *object; |
||||
|
||||
if(!json_is_object(json)) |
||||
return 0; |
||||
|
||||
object = json_to_object(json); |
||||
return object->hashtable.size; |
||||
} |
||||
|
||||
json_t *json_object_get(const json_t *json, const char *key) |
||||
{ |
||||
json_object_t *object; |
||||
|
||||
if(!json_is_object(json)) |
||||
return NULL; |
||||
|
||||
object = json_to_object(json); |
||||
return (json_t *)hashtable_get(&object->hashtable, key); |
||||
} |
||||
|
||||
int json_object_set_new_nocheck(json_t *json, const char *key, json_t *value) |
||||
{ |
||||
json_object_t *object; |
||||
|
||||
if(!value) |
||||
return -1; |
||||
|
||||
if(!key || !json_is_object(json) || json == value) |
||||
{ |
||||
json_decref(value); |
||||
return -1; |
||||
} |
||||
object = json_to_object(json); |
||||
|
||||
if(hashtable_set(&object->hashtable, key, object->serial++, value)) |
||||
{ |
||||
json_decref(value); |
||||
return -1; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int json_object_set_new(json_t *json, const char *key, json_t *value) |
||||
{ |
||||
if(!key || !utf8_check_string(key, -1)) |
||||
{ |
||||
json_decref(value); |
||||
return -1; |
||||
} |
||||
|
||||
return json_object_set_new_nocheck(json, key, value); |
||||
} |
||||
|
||||
int json_object_del(json_t *json, const char *key) |
||||
{ |
||||
json_object_t *object; |
||||
|
||||
if(!json_is_object(json)) |
||||
return -1; |
||||
|
||||
object = json_to_object(json); |
||||
return hashtable_del(&object->hashtable, key); |
||||
} |
||||
|
||||
int json_object_clear(json_t *json) |
||||
{ |
||||
json_object_t *object; |
||||
|
||||
if(!json_is_object(json)) |
||||
return -1; |
||||
|
||||
object = json_to_object(json); |
||||
|
||||
hashtable_clear(&object->hashtable); |
||||
object->serial = 0; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int json_object_update(json_t *object, json_t *other) |
||||
{ |
||||
const char *key; |
||||
json_t *value; |
||||
|
||||
if(!json_is_object(object) || !json_is_object(other)) |
||||
return -1; |
||||
|
||||
json_object_foreach(other, key, value) { |
||||
if(json_object_set_nocheck(object, key, value)) |
||||
return -1; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int json_object_update_existing(json_t *object, json_t *other) |
||||
{ |
||||
const char *key; |
||||
json_t *value; |
||||
|
||||
if(!json_is_object(object) || !json_is_object(other)) |
||||
return -1; |
||||
|
||||
json_object_foreach(other, key, value) { |
||||
if(json_object_get(object, key)) |
||||
json_object_set_nocheck(object, key, value); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int json_object_update_missing(json_t *object, json_t *other) |
||||
{ |
||||
const char *key; |
||||
json_t *value; |
||||
|
||||
if(!json_is_object(object) || !json_is_object(other)) |
||||
return -1; |
||||
|
||||
json_object_foreach(other, key, value) { |
||||
if(!json_object_get(object, key)) |
||||
json_object_set_nocheck(object, key, value); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
void *json_object_iter(json_t *json) |
||||
{ |
||||
json_object_t *object; |
||||
|
||||
if(!json_is_object(json)) |
||||
return NULL; |
||||
|
||||
object = json_to_object(json); |
||||
return hashtable_iter(&object->hashtable); |
||||
} |
||||
|
||||
void *json_object_iter_at(json_t *json, const char *key) |
||||
{ |
||||
json_object_t *object; |
||||
|
||||
if(!key || !json_is_object(json)) |
||||
return NULL; |
||||
|
||||
object = json_to_object(json); |
||||
return hashtable_iter_at(&object->hashtable, key); |
||||
} |
||||
|
||||
void *json_object_iter_next(json_t *json, void *iter) |
||||
{ |
||||
json_object_t *object; |
||||
|
||||
if(!json_is_object(json) || iter == NULL) |
||||
return NULL; |
||||
|
||||
object = json_to_object(json); |
||||
return hashtable_iter_next(&object->hashtable, iter); |
||||
} |
||||
|
||||
const char *json_object_iter_key(void *iter) |
||||
{ |
||||
if(!iter) |
||||
return NULL; |
||||
|
||||
return (char *)hashtable_iter_key(iter); |
||||
} |
||||
|
||||
json_t *json_object_iter_value(void *iter) |
||||
{ |
||||
if(!iter) |
||||
return NULL; |
||||
|
||||
return (json_t *)hashtable_iter_value(iter); |
||||
} |
||||
|
||||
int json_object_iter_set_new(json_t *json, void *iter, json_t *value) |
||||
{ |
||||
if(!json_is_object(json) || !iter || !value) |
||||
return -1; |
||||
|
||||
hashtable_iter_set(iter, value); |
||||
return 0; |
||||
} |
||||
|
||||
void *json_object_key_to_iter(const char *key) |
||||
{ |
||||
if(!key) |
||||
return NULL; |
||||
|
||||
return hashtable_key_to_iter(key); |
||||
} |
||||
|
||||
static int json_object_equal(json_t *object1, json_t *object2) |
||||
{ |
||||
const char *key; |
||||
json_t *value1, *value2; |
||||
|
||||
if(json_object_size(object1) != json_object_size(object2)) |
||||
return 0; |
||||
|
||||
json_object_foreach(object1, key, value1) { |
||||
value2 = json_object_get(object2, key); |
||||
|
||||
if(!json_equal(value1, value2)) |
||||
return 0; |
||||
} |
||||
|
||||
return 1; |
||||
} |
||||
|
||||
static json_t *json_object_copy(json_t *object) |
||||
{ |
||||
json_t *result; |
||||
|
||||
const char *key; |
||||
json_t *value; |
||||
|
||||
result = json_object(); |
||||
if(!result) |
||||
return NULL; |
||||
|
||||
json_object_foreach(object, key, value) |
||||
json_object_set_nocheck(result, key, value); |
||||
|
||||
return result; |
||||
} |
||||
|
||||
static json_t *json_object_deep_copy(const json_t *object) |
||||
{ |
||||
json_t *result; |
||||
void *iter; |
||||
|
||||
result = json_object(); |
||||
if(!result) |
||||
return NULL; |
||||
|
||||
/* Cannot use json_object_foreach because object has to be cast
|
||||
non-const */ |
||||
iter = json_object_iter((json_t *)object); |
||||
while(iter) { |
||||
const char *key; |
||||
const json_t *value; |
||||
key = json_object_iter_key(iter); |
||||
value = json_object_iter_value(iter); |
||||
|
||||
json_object_set_new_nocheck(result, key, json_deep_copy(value)); |
||||
iter = json_object_iter_next((json_t *)object, iter); |
||||
} |
||||
|
||||
return result; |
||||
} |
||||
|
||||
|
||||
/*** array ***/ |
||||
|
||||
json_t *json_array(void) |
||||
{ |
||||
json_array_t *array = (json_array_t *)jsonp_malloc(sizeof(json_array_t)); |
||||
if(!array) |
||||
return NULL; |
||||
json_init(&array->json, JSON_ARRAY); |
||||
|
||||
array->entries = 0; |
||||
array->size = 8; |
||||
|
||||
array->table = (json_t **)jsonp_malloc(array->size * sizeof(json_t *)); |
||||
if(!array->table) { |
||||
jsonp_free(array); |
||||
return NULL; |
||||
} |
||||
|
||||
array->visited = 0; |
||||
|
||||
return &array->json; |
||||
} |
||||
|
||||
static void json_delete_array(json_array_t *array) |
||||
{ |
||||
size_t i; |
||||
|
||||
for(i = 0; i < array->entries; i++) |
||||
json_decref(array->table[i]); |
||||
|
||||
jsonp_free(array->table); |
||||
jsonp_free(array); |
||||
} |
||||
|
||||
size_t json_array_size(const json_t *json) |
||||
{ |
||||
if(!json_is_array(json)) |
||||
return 0; |
||||
|
||||
return json_to_array(json)->entries; |
||||
} |
||||
|
||||
json_t *json_array_get(const json_t *json, size_t index) |
||||
{ |
||||
json_array_t *array; |
||||
if(!json_is_array(json)) |
||||
return NULL; |
||||
array = json_to_array(json); |
||||
|
||||
if(index >= array->entries) |
||||
return NULL; |
||||
|
||||
return array->table[index]; |
||||
} |
||||
|
||||
int json_array_set_new(json_t *json, size_t index, json_t *value) |
||||
{ |
||||
json_array_t *array; |
||||
|
||||
if(!value) |
||||
return -1; |
||||
|
||||
if(!json_is_array(json) || json == value) |
||||
{ |
||||
json_decref(value); |
||||
return -1; |
||||
} |
||||
array = json_to_array(json); |
||||
|
||||
if(index >= array->entries) |
||||
{ |
||||
json_decref(value); |
||||
return -1; |
||||
} |
||||
|
||||
json_decref(array->table[index]); |
||||
array->table[index] = value; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static void array_move(json_array_t *array, size_t dest, |
||||
size_t src, size_t count) |
||||
{ |
||||
memmove(&array->table[dest], &array->table[src], count * sizeof(json_t *)); |
||||
} |
||||
|
||||
static void array_copy(json_t **dest, size_t dpos, |
||||
json_t **src, size_t spos, |
||||
size_t count) |
||||
{ |
||||
memcpy(&dest[dpos], &src[spos], count * sizeof(json_t *)); |
||||
} |
||||
|
||||
static json_t **json_array_grow(json_array_t *array, |
||||
size_t amount, |
||||
int copy) |
||||
{ |
||||
size_t new_size; |
||||
json_t **old_table, **new_table; |
||||
|
||||
if(array->entries + amount <= array->size) |
||||
return array->table; |
||||
|
||||
old_table = array->table; |
||||
|
||||
new_size = max(array->size + amount, array->size * 2); |
||||
new_table = (json_t **)jsonp_malloc(new_size * sizeof(json_t *)); |
||||
if(!new_table) |
||||
return NULL; |
||||
|
||||
array->size = new_size; |
||||
array->table = new_table; |
||||
|
||||
if(copy) { |
||||
array_copy(array->table, 0, old_table, 0, array->entries); |
||||
jsonp_free(old_table); |
||||
return array->table; |
||||
} |
||||
|
||||
return old_table; |
||||
} |
||||
|
||||
int json_array_append_new(json_t *json, json_t *value) |
||||
{ |
||||
json_array_t *array; |
||||
|
||||
if(!value) |
||||
return -1; |
||||
|
||||
if(!json_is_array(json) || json == value) |
||||
{ |
||||
json_decref(value); |
||||
return -1; |
||||
} |
||||
array = json_to_array(json); |
||||
|
||||
if(!json_array_grow(array, 1, 1)) { |
||||
json_decref(value); |
||||
return -1; |
||||
} |
||||
|
||||
array->table[array->entries] = value; |
||||
array->entries++; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int json_array_insert_new(json_t *json, size_t index, json_t *value) |
||||
{ |
||||
json_array_t *array; |
||||
json_t **old_table; |
||||
|
||||
if(!value) |
||||
return -1; |
||||
|
||||
if(!json_is_array(json) || json == value) { |
||||
json_decref(value); |
||||
return -1; |
||||
} |
||||
array = json_to_array(json); |
||||
|
||||
if(index > array->entries) { |
||||
json_decref(value); |
||||
return -1; |
||||
} |
||||
|
||||
old_table = json_array_grow(array, 1, 0); |
||||
if(!old_table) { |
||||
json_decref(value); |
||||
return -1; |
||||
} |
||||
|
||||
if(old_table != array->table) { |
||||
array_copy(array->table, 0, old_table, 0, index); |
||||
array_copy(array->table, index + 1, old_table, index, |
||||
array->entries - index); |
||||
jsonp_free(old_table); |
||||
} |
||||
else |
||||
array_move(array, index + 1, index, array->entries - index); |
||||
|
||||
array->table[index] = value; |
||||
array->entries++; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int json_array_remove(json_t *json, size_t index) |
||||
{ |
||||
json_array_t *array; |
||||
|
||||
if(!json_is_array(json)) |
||||
return -1; |
||||
array = json_to_array(json); |
||||
|
||||
if(index >= array->entries) |
||||
return -1; |
||||
|
||||
json_decref(array->table[index]); |
||||
|
||||
/* If we're removing the last element, nothing has to be moved */ |
||||
if(index < array->entries - 1) |
||||
array_move(array, index, index + 1, array->entries - index - 1); |
||||
|
||||
array->entries--; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int json_array_clear(json_t *json) |
||||
{ |
||||
json_array_t *array; |
||||
size_t i; |
||||
|
||||
if(!json_is_array(json)) |
||||
return -1; |
||||
array = json_to_array(json); |
||||
|
||||
for(i = 0; i < array->entries; i++) |
||||
json_decref(array->table[i]); |
||||
|
||||
array->entries = 0; |
||||
return 0; |
||||
} |
||||
|
||||
int json_array_extend(json_t *json, json_t *other_json) |
||||
{ |
||||
json_array_t *array, *other; |
||||
size_t i; |
||||
|
||||
if(!json_is_array(json) || !json_is_array(other_json)) |
||||
return -1; |
||||
array = json_to_array(json); |
||||
other = json_to_array(other_json); |
||||
|
||||
if(!json_array_grow(array, other->entries, 1)) |
||||
return -1; |
||||
|
||||
for(i = 0; i < other->entries; i++) |
||||
json_incref(other->table[i]); |
||||
|
||||
array_copy(array->table, array->entries, other->table, 0, other->entries); |
||||
|
||||
array->entries += other->entries; |
||||
return 0; |
||||
} |
||||
|
||||
static int json_array_equal(json_t *array1, json_t *array2) |
||||
{ |
||||
size_t i, size; |
||||
|
||||
size = json_array_size(array1); |
||||
if(size != json_array_size(array2)) |
||||
return 0; |
||||
|
||||
for(i = 0; i < size; i++) |
||||
{ |
||||
json_t *value1, *value2; |
||||
|
||||
value1 = json_array_get(array1, i); |
||||
value2 = json_array_get(array2, i); |
||||
|
||||
if(!json_equal(value1, value2)) |
||||
return 0; |
||||
} |
||||
|
||||
return 1; |
||||
} |
||||
|
||||
static json_t *json_array_copy(json_t *array) |
||||
{ |
||||
json_t *result; |
||||
size_t i; |
||||
|
||||
result = json_array(); |
||||
if(!result) |
||||
return NULL; |
||||
|
||||
for(i = 0; i < json_array_size(array); i++) |
||||
json_array_append(result, json_array_get(array, i)); |
||||
|
||||
return result; |
||||
} |
||||
|
||||
static json_t *json_array_deep_copy(const json_t *array) |
||||
{ |
||||
json_t *result; |
||||
size_t i; |
||||
|
||||
result = json_array(); |
||||
if(!result) |
||||
return NULL; |
||||
|
||||
for(i = 0; i < json_array_size(array); i++) |
||||
json_array_append_new(result, json_deep_copy(json_array_get(array, i))); |
||||
|
||||
return result; |
||||
} |
||||
|
||||
/*** string ***/ |
||||
|
||||
json_t *json_string_nocheck(const char *value) |
||||
{ |
||||
json_string_t *string; |
||||
|
||||
if(!value) |
||||
return NULL; |
||||
|
||||
string = (json_string_t *)jsonp_malloc(sizeof(json_string_t)); |
||||
if(!string) |
||||
return NULL; |
||||
json_init(&string->json, JSON_STRING); |
||||
|
||||
string->value = jsonp_strdup(value); |
||||
if(!string->value) { |
||||
jsonp_free(string); |
||||
return NULL; |
||||
} |
||||
|
||||
return &string->json; |
||||
} |
||||
|
||||
json_t *json_string(const char *value) |
||||
{ |
||||
if(!value || !utf8_check_string(value, -1)) |
||||
return NULL; |
||||
|
||||
return json_string_nocheck(value); |
||||
} |
||||
|
||||
const char *json_string_value(const json_t *json) |
||||
{ |
||||
if(!json_is_string(json)) |
||||
return NULL; |
||||
|
||||
return json_to_string(json)->value; |
||||
} |
||||
|
||||
int json_string_set_nocheck(json_t *json, const char *value) |
||||
{ |
||||
char *dup; |
||||
json_string_t *string; |
||||
|
||||
if(!json_is_string(json) || !value) |
||||
return -1; |
||||
|
||||
dup = jsonp_strdup(value); |
||||
if(!dup) |
||||
return -1; |
||||
|
||||
string = json_to_string(json); |
||||
jsonp_free(string->value); |
||||
string->value = dup; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
int json_string_set(json_t *json, const char *value) |
||||
{ |
||||
if(!value || !utf8_check_string(value, -1)) |
||||
return -1; |
||||
|
||||
return json_string_set_nocheck(json, value); |
||||
} |
||||
|
||||
static void json_delete_string(json_string_t *string) |
||||
{ |
||||
jsonp_free(string->value); |
||||
jsonp_free(string); |
||||
} |
||||
|
||||
static int json_string_equal(json_t *string1, json_t *string2) |
||||
{ |
||||
return strcmp(json_string_value(string1), json_string_value(string2)) == 0; |
||||
} |
||||
|
||||
static json_t *json_string_copy(const json_t *string) |
||||
{ |
||||
return json_string_nocheck(json_string_value(string)); |
||||
} |
||||
|
||||
|
||||
/*** integer ***/ |
||||
|
||||
json_t *json_integer(json_int_t value) |
||||
{ |
||||
json_integer_t *integer = (json_integer_t *)jsonp_malloc(sizeof(json_integer_t)); |
||||
if(!integer) |
||||
return NULL; |
||||
json_init(&integer->json, JSON_INTEGER); |
||||
|
||||
integer->value = value; |
||||
return &integer->json; |
||||
} |
||||
|
||||
json_int_t json_integer_value(const json_t *json) |
||||
{ |
||||
if(!json_is_integer(json)) |
||||
return 0; |
||||
|
||||
return json_to_integer(json)->value; |
||||
} |
||||
|
||||
int json_integer_set(json_t *json, json_int_t value) |
||||
{ |
||||
if(!json_is_integer(json)) |
||||
return -1; |
||||
|
||||
json_to_integer(json)->value = value; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static void json_delete_integer(json_integer_t *integer) |
||||
{ |
||||
jsonp_free(integer); |
||||
} |
||||
|
||||
static int json_integer_equal(json_t *integer1, json_t *integer2) |
||||
{ |
||||
return json_integer_value(integer1) == json_integer_value(integer2); |
||||
} |
||||
|
||||
static json_t *json_integer_copy(const json_t *integer) |
||||
{ |
||||
return json_integer(json_integer_value(integer)); |
||||
} |
||||
|
||||
|
||||
/*** real ***/ |
||||
|
||||
json_t *json_real(double value) |
||||
{ |
||||
json_real_t *real; |
||||
|
||||
if(isnan(value) || isinf(value)) |
||||
return NULL; |
||||
|
||||
real = (json_real_t *)jsonp_malloc(sizeof(json_real_t)); |
||||
if(!real) |
||||
return NULL; |
||||
json_init(&real->json, JSON_REAL); |
||||
|
||||
real->value = value; |
||||
return &real->json; |
||||
} |
||||
|
||||
double json_real_value(const json_t *json) |
||||
{ |
||||
if(!json_is_real(json)) |
||||
return 0; |
||||
|
||||
return json_to_real(json)->value; |
||||
} |
||||
|
||||
int json_real_set(json_t *json, double value) |
||||
{ |
||||
if(!json_is_real(json) || isnan(value) || isinf(value)) |
||||
return -1; |
||||
|
||||
json_to_real(json)->value = value; |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
static void json_delete_real(json_real_t *real) |
||||
{ |
||||
jsonp_free(real); |
||||
} |
||||
|
||||
static int json_real_equal(json_t *real1, json_t *real2) |
||||
{ |
||||
return json_real_value(real1) == json_real_value(real2); |
||||
} |
||||
|
||||
static json_t *json_real_copy(const json_t *real) |
||||
{ |
||||
return json_real(json_real_value(real)); |
||||
} |
||||
|
||||
|
||||
/*** number ***/ |
||||
|
||||
double json_number_value(const json_t *json) |
||||
{ |
||||
if(json_is_integer(json)) |
||||
return (double)json_integer_value(json); |
||||
else if(json_is_real(json)) |
||||
return json_real_value(json); |
||||
else |
||||
return 0.0; |
||||
} |
||||
|
||||
|
||||
/*** simple values ***/ |
||||
|
||||
json_t *json_true(void) |
||||
{ |
||||
static json_t the_true = {JSON_TRUE, (size_t)-1}; |
||||
return &the_true; |
||||
} |
||||
|
||||
|
||||
json_t *json_false(void) |
||||
{ |
||||
static json_t the_false = {JSON_FALSE, (size_t)-1}; |
||||
return &the_false; |
||||
} |
||||
|
||||
|
||||
json_t *json_null(void) |
||||
{ |
||||
static json_t the_null = {JSON_NULL, (size_t)-1}; |
||||
return &the_null; |
||||
} |
||||
|
||||
|
||||
/*** deletion ***/ |
||||
|
||||
void json_delete(json_t *json) |
||||
{ |
||||
if(json_is_object(json)) |
||||
json_delete_object(json_to_object(json)); |
||||
|
||||
else if(json_is_array(json)) |
||||
json_delete_array(json_to_array(json)); |
||||
|
||||
else if(json_is_string(json)) |
||||
json_delete_string(json_to_string(json)); |
||||
|
||||
else if(json_is_integer(json)) |
||||
json_delete_integer(json_to_integer(json)); |
||||
|
||||
else if(json_is_real(json)) |
||||
json_delete_real(json_to_real(json)); |
||||
|
||||
/* json_delete is not called for true, false or null */ |
||||
} |
||||
|
||||
|
||||
/*** equality ***/ |
||||
|
||||
int json_equal(json_t *json1, json_t *json2) |
||||
{ |
||||
if(!json1 || !json2) |
||||
return 0; |
||||
|
||||
if(json_typeof(json1) != json_typeof(json2)) |
||||
return 0; |
||||
|
||||
/* this covers true, false and null as they are singletons */ |
||||
if(json1 == json2) |
||||
return 1; |
||||
|
||||
if(json_is_object(json1)) |
||||
return json_object_equal(json1, json2); |
||||
|
||||
if(json_is_array(json1)) |
||||
return json_array_equal(json1, json2); |
||||
|
||||
if(json_is_string(json1)) |
||||
return json_string_equal(json1, json2); |
||||
|
||||
if(json_is_integer(json1)) |
||||
return json_integer_equal(json1, json2); |
||||
|
||||
if(json_is_real(json1)) |
||||
return json_real_equal(json1, json2); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
|
||||
/*** copying ***/ |
||||
|
||||
json_t *json_copy(json_t *json) |
||||
{ |
||||
if(!json) |
||||
return NULL; |
||||
|
||||
if(json_is_object(json)) |
||||
return json_object_copy(json); |
||||
|
||||
if(json_is_array(json)) |
||||
return json_array_copy(json); |
||||
|
||||
if(json_is_string(json)) |
||||
return json_string_copy(json); |
||||
|
||||
if(json_is_integer(json)) |
||||
return json_integer_copy(json); |
||||
|
||||
if(json_is_real(json)) |
||||
return json_real_copy(json); |
||||
|
||||
if(json_is_true(json) || json_is_false(json) || json_is_null(json)) |
||||
return json; |
||||
|
||||
return NULL; |
||||
} |
||||
|
||||
json_t *json_deep_copy(const json_t *json) |
||||
{ |
||||
if(!json) |
||||
return NULL; |
||||
|
||||
if(json_is_object(json)) |
||||
return json_object_deep_copy(json); |
||||
|
||||
if(json_is_array(json)) |
||||
return json_array_deep_copy(json); |
||||
|
||||
/* for the rest of the types, deep copying doesn't differ from
|
||||
shallow copying */ |
||||
|
||||
if(json_is_string(json)) |
||||
return json_string_copy(json); |
||||
|
||||
if(json_is_integer(json)) |
||||
return json_integer_copy(json); |
||||
|
||||
if(json_is_real(json)) |
||||
return json_real_copy(json); |
||||
|
||||
if(json_is_true(json) || json_is_false(json) || json_is_null(json)) |
||||
return (json_t *)json; |
||||
|
||||
return NULL; |
||||
} |
||||
@ -0,0 +1 @@
@@ -0,0 +1 @@
|
||||
Subproject commit df248712a5d982b0721b6e8d15b09d4a9264301e |
||||
@ -0,0 +1,59 @@
@@ -0,0 +1,59 @@
|
||||
/* #undef HAVE_ENDIAN_H */ |
||||
#define HAVE_FCNTL_H 1 |
||||
/* #undef HAVE_SCHED_H */ |
||||
/* #undef HAVE_UNISTD_H */ |
||||
/* #undef HAVE_SYS_PARAM_H */ |
||||
#define HAVE_SYS_STAT_H 1 |
||||
/* #undef HAVE_SYS_TIME_H */ |
||||
/* #undef HAVE_SYS_TYPES_H */ |
||||
#define HAVE_STDINT_H 1 |
||||
|
||||
#define HAVE_CLOSE 1 |
||||
#define HAVE_GETPID 1 |
||||
/* #undef HAVE_GETTIMEOFDAY */ |
||||
#define HAVE_OPEN 1 |
||||
#define HAVE_READ 1 |
||||
/* #undef HAVE_SCHED_YIELD */ |
||||
|
||||
/* #undef HAVE_SYNC_BUILTINS */ |
||||
/* #undef HAVE_ATOMIC_BUILTINS */ |
||||
|
||||
#define HAVE_LOCALE_H 1 |
||||
/* #undef HAVE_SETLOCALE */ |
||||
|
||||
#define HAVE_INT32_T 1 |
||||
#ifndef HAVE_INT32_T |
||||
# define int32_t int32_t |
||||
#endif |
||||
|
||||
#define HAVE_UINT32_T 1 |
||||
#ifndef HAVE_UINT32_T |
||||
# define uint32_t uint32_t |
||||
#endif |
||||
|
||||
#define HAVE_UINT16_T 1 |
||||
#ifndef HAVE_UINT16_T |
||||
# define uint16_t uint16_t |
||||
#endif |
||||
|
||||
#define HAVE_UINT8_T 1 |
||||
#ifndef HAVE_UINT8_T |
||||
# define uint8_t uint8_t |
||||
#endif |
||||
|
||||
/* #undef HAVE_SSIZE_T */ |
||||
|
||||
#ifndef HAVE_SSIZE_T |
||||
# define ssize_t int |
||||
#endif |
||||
|
||||
/* #undef HAVE_SNPRINTF */ |
||||
|
||||
#ifndef HAVE_SNPRINTF |
||||
# define snprintf _snprintf |
||||
#endif |
||||
|
||||
/* #undef HAVE_VSNPRINTF */ |
||||
|
||||
#define USE_URANDOM 1 |
||||
#define USE_WINDOWS_CRYPTOAPI 1 |
||||
@ -0,0 +1,62 @@
@@ -0,0 +1,62 @@
|
||||
/*
|
||||
* Copyright (c) 2010-2014 Petri Lehtinen <petri@digip.org> |
||||
* |
||||
* Jansson is free software; you can redistribute it and/or modify |
||||
* it under the terms of the MIT license. See LICENSE for details. |
||||
* |
||||
* |
||||
* This file specifies a part of the site-specific configuration for |
||||
* Jansson, namely those things that affect the public API in |
||||
* jansson.h. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef JANSSON_CONFIG_H |
||||
#define JANSSON_CONFIG_H |
||||
|
||||
/* Define this so that we can disable scattered automake configuration in source files */ |
||||
#ifndef JANSSON_USING_CMAKE |
||||
#define JANSSON_USING_CMAKE |
||||
#endif |
||||
|
||||
/* Note: when using cmake, JSON_INTEGER_IS_LONG_LONG is not defined nor used,
|
||||
* as we will also check for __int64 etc types. |
||||
* (the definition was used in the automake system) */ |
||||
|
||||
/* Bring in the cmake-detected defines */ |
||||
#define HAVE_STDINT_H 1 |
||||
/* #undef HAVE_INTTYPES_H */ |
||||
/* #undef HAVE_SYS_TYPES_H */ |
||||
|
||||
/* Include our standard type header for the integer typedef */ |
||||
|
||||
#if defined(HAVE_STDINT_H) |
||||
# include <stdint.h> |
||||
#elif defined(HAVE_INTTYPES_H) |
||||
# include <inttypes.h> |
||||
#elif defined(HAVE_SYS_TYPES_H) |
||||
# include <sys/types.h> |
||||
#endif |
||||
|
||||
|
||||
/* If your compiler supports the inline keyword in C, JSON_INLINE is
|
||||
defined to `inline', otherwise empty. In C++, the inline is always |
||||
supported. */ |
||||
#ifdef __cplusplus |
||||
#define JSON_INLINE inline |
||||
#else |
||||
#define JSON_INLINE __inline |
||||
#endif |
||||
|
||||
|
||||
#define json_int_t long long |
||||
#define json_strtoint _strtoi64 |
||||
#define JSON_INTEGER_FORMAT "I64d" |
||||
|
||||
|
||||
/* If locale.h and localeconv() are available, define to 1, otherwise to 0. */ |
||||
#define JSON_HAVE_LOCALECONV 1 |
||||
|
||||
|
||||
|
||||
#endif |
||||
@ -0,0 +1,59 @@
@@ -0,0 +1,59 @@
|
||||
/* #undef HAVE_ENDIAN_H */ |
||||
#define HAVE_FCNTL_H 1 |
||||
/* #undef HAVE_SCHED_H */ |
||||
/* #undef HAVE_UNISTD_H */ |
||||
/* #undef HAVE_SYS_PARAM_H */ |
||||
#define HAVE_SYS_STAT_H 1 |
||||
/* #undef HAVE_SYS_TIME_H */ |
||||
/* #undef HAVE_SYS_TYPES_H */ |
||||
#define HAVE_STDINT_H 1 |
||||
|
||||
#define HAVE_CLOSE 1 |
||||
#define HAVE_GETPID 1 |
||||
/* #undef HAVE_GETTIMEOFDAY */ |
||||
#define HAVE_OPEN 1 |
||||
#define HAVE_READ 1 |
||||
/* #undef HAVE_SCHED_YIELD */ |
||||
|
||||
/* #undef HAVE_SYNC_BUILTINS */ |
||||
/* #undef HAVE_ATOMIC_BUILTINS */ |
||||
|
||||
#define HAVE_LOCALE_H 1 |
||||
/* #undef HAVE_SETLOCALE */ |
||||
|
||||
#define HAVE_INT32_T 1 |
||||
#ifndef HAVE_INT32_T |
||||
# define int32_t int32_t |
||||
#endif |
||||
|
||||
#define HAVE_UINT32_T 1 |
||||
#ifndef HAVE_UINT32_T |
||||
# define uint32_t uint32_t |
||||
#endif |
||||
|
||||
#define HAVE_UINT16_T 1 |
||||
#ifndef HAVE_UINT16_T |
||||
# define uint16_t uint16_t |
||||
#endif |
||||
|
||||
#define HAVE_UINT8_T 1 |
||||
#ifndef HAVE_UINT8_T |
||||
# define uint8_t uint8_t |
||||
#endif |
||||
|
||||
/* #undef HAVE_SSIZE_T */ |
||||
|
||||
#ifndef HAVE_SSIZE_T |
||||
# define ssize_t int |
||||
#endif |
||||
|
||||
/* #undef HAVE_SNPRINTF */ |
||||
|
||||
#ifndef HAVE_SNPRINTF |
||||
# define snprintf _snprintf |
||||
#endif |
||||
|
||||
/* #undef HAVE_VSNPRINTF */ |
||||
|
||||
#define USE_URANDOM 1 |
||||
#define USE_WINDOWS_CRYPTOAPI 1 |
||||
Loading…
Reference in new issue