You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.

README.md 13 kB

3 years ago
5 years ago
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345
  1. \mainpage
  2. `json-c`
  3. ========
  4. 1. [Overview and Build Status](#overview)
  5. 2. [Getting Help](#gettinghelp)
  6. 3. [Building on Unix](#buildunix)
  7. * [Prerequisites](#installprereq)
  8. * [Build commands](#buildcmds)
  9. 4. [CMake options](#CMake)
  10. 5. [Testing](#testing)
  11. 6. [Building with `vcpkg`](#buildvcpkg)
  12. 7. [Building for Android](#android)
  13. 7. [Linking to libjson-c](#linking)
  14. 8. [Using json-c](#using)
  15. JSON-C - A JSON implementation in C <a name="overview"></a>
  16. -----------------------------------
  17. JSON-C implements a reference counting object model that allows you to easily
  18. construct JSON objects in C, output them as JSON formatted strings and parse
  19. JSON formatted strings back into the C representation of JSON objects.
  20. It aims to conform to [RFC 8259](https://www.rfc-editor.org/rfc/rfc8259).
  21. Skip down to [Using json-c](#using)
  22. or check out the [API docs](https://json-c.github.io/json-c/),
  23. if you already have json-c installed and ready to use.
  24. Home page for json-c: https://github.com/json-c/json-c/wiki
  25. Getting Help <a name="gettinghelp"></a>
  26. ------------
  27. If you have questions about using json-c, please start a thread on
  28. our forums at: https://groups.google.com/forum/#!forum/json-c
  29. If you believe you've discovered a bug, report it at
  30. (https://github.com/json-c/json-c/issues). Please be sure to include
  31. the version of json-c you're using, the OS you're running on, and any
  32. other relevant details. Fully reproducible test cases and/or patches
  33. to fix problems are greatly appreciated.
  34. Fixes for bugs, or small new features can be directly submitted as a
  35. [pull request](https://github.com/json-c/json-c/pulls). For major new
  36. features or large changes of any kind, please first start a discussion
  37. on the [forums](https://groups.google.com/forum/#!forum/json-c).
  38. Building on Unix with `git`, `gcc` and `cmake` <a name="buildunix"></a>
  39. --------------------------------------------------
  40. If you already have json-c installed, see [Linking to `libjson-c`](#linking)
  41. for how to build and link your program against it.
  42. Build Status
  43. * [AppVeyor Build](https://ci.appveyor.com/project/hawicz/json-c) ![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/github/json-c/json-c?branch=master&svg=true)
  44. * [Travis Build](https://app.travis-ci.com/github/json-c/json-c) ![Travis Build Status](https://api.travis-ci.com/json-c/json-c.svg?branch=master)
  45. Test Status
  46. * [Coveralls](https://coveralls.io/github/json-c/json-c?branch=master) [![Coverage Status](https://coveralls.io/repos/github/json-c/json-c/badge.svg?branch=master)](https://coveralls.io/github/json-c/json-c?branch=master)
  47. ### Prerequisites: <a name="installprereq"></a>
  48. - `gcc`, `clang`, or another C compiler
  49. - `cmake>=2.8`, `>=3.16` recommended, `cmake=>3.1` for tests
  50. To generate docs you'll also need:
  51. - `doxygen>=1.8.13`
  52. If you are on a relatively modern system, you'll likely be able to install
  53. the prerequisites using your OS's packaging system.
  54. ### Install using apt (e.g. Ubuntu 16.04.2 LTS)
  55. ```sh
  56. sudo apt install git
  57. sudo apt install cmake
  58. sudo apt install doxygen # optional
  59. sudo apt install valgrind # optional
  60. ```
  61. ### Build instructions: <a name="buildcmds"></a>
  62. `json-c` GitHub repo: https://github.com/json-c/json-c
  63. ```sh
  64. $ git clone https://github.com/json-c/json-c.git
  65. $ mkdir json-c-build
  66. $ cd json-c-build
  67. $ cmake ../json-c # See CMake section below for custom arguments
  68. ```
  69. Note: it's also possible to put your build directory inside the json-c
  70. source directory, or even not use a separate build directory at all, but
  71. certain things might not work quite right (notably, `make distcheck`)
  72. Then:
  73. ```sh
  74. $ make
  75. $ make test
  76. $ make USE_VALGRIND=0 test # optionally skip using valgrind
  77. $ sudo make install # it could be necessary to execute make install
  78. ```
  79. ### Generating documentation with Doxygen:
  80. The library documentation can be generated directly from the source code using Doxygen tool:
  81. ```sh
  82. # in build directory
  83. make doc
  84. google-chrome doc/html/index.html
  85. ```
  86. CMake Options <a name="CMake"></a>
  87. --------------------
  88. The json-c library is built with [CMake](https://cmake.org/cmake-tutorial/),
  89. which can take a few options.
  90. Variable | Type | Description
  91. -----------------------------|--------|--------------
  92. CMAKE_INSTALL_PREFIX | String | The install location.
  93. CMAKE_BUILD_TYPE | String | Defaults to "debug".
  94. BUILD_SHARED_LIBS | Bool | The default build generates a dynamic (dll/so) library. Set this to OFF to create a static library only.
  95. BUILD_STATIC_LIBS | Bool | The default build generates a static (lib/a) library. Set this to OFF to create a shared library only.
  96. DISABLE_STATIC_FPIC | Bool | The default builds position independent code. Set this to OFF to create a shared library only.
  97. DISABLE_BSYMBOLIC | Bool | Disable use of -Bsymbolic-functions.
  98. DISABLE_THREAD_LOCAL_STORAGE | Bool | Disable use of Thread-Local Storage (HAVE___THREAD).
  99. DISABLE_WERROR | Bool | Disable use of -Werror.
  100. DISABLE_EXTRA_LIBS | Bool | Disable use of extra libraries, libbsd
  101. DISABLE_JSON_POINTER | Bool | Omit json_pointer support from the build.
  102. ENABLE_RDRAND | Bool | Enable RDRAND Hardware RNG Hash Seed.
  103. ENABLE_THREADING | Bool | Enable partial threading support.
  104. OVERRIDE_GET_RANDOM_SEED | String | A block of code to use instead of the default implementation of json_c_get_random_seed(), e.g. on embedded platforms where not even the fallback to time() works. Must be a single line.
  105. Pass these options as `-D` on CMake's command-line.
  106. ```sh
  107. # build a static library only
  108. cmake -DBUILD_SHARED_LIBS=OFF ..
  109. ```
  110. ### Building with partial threading support
  111. Although json-c does not support fully multi-threaded access to
  112. object trees, it has some code to help make its use in threaded programs
  113. a bit safer. Currently, this is limited to using atomic operations for
  114. json_object_get() and json_object_put().
  115. Since this may have a performance impact, of at least 3x slower
  116. according to https://stackoverflow.com/a/11609063, it is disabled by
  117. default. You may turn it on by adjusting your cmake command with:
  118. -DENABLE_THREADING=ON
  119. Separately, the default hash function used for object field keys,
  120. lh_char_hash, uses a compare-and-swap operation to ensure the random
  121. seed is only generated once. Because this is a one-time operation, it
  122. is always compiled in when the compare-and-swap operation is available.
  123. ### cmake-configure wrapper script
  124. For those familiar with the old autoconf/autogen.sh/configure method,
  125. there is a `cmake-configure` wrapper script to ease the transition to cmake.
  126. ```sh
  127. mkdir build
  128. cd build
  129. ../cmake-configure --prefix=/some/install/path
  130. make
  131. ```
  132. cmake-configure can take a few options.
  133. | options | Description|
  134. | ---- | ---- |
  135. | prefix=PREFIX | install architecture-independent files in PREFIX |
  136. | enable-threading | Enable code to support partly multi-threaded use |
  137. | enable-rdrand | Enable RDRAND Hardware RNG Hash Seed generation on supported x86/x64 platforms. |
  138. | enable-shared | build shared libraries [default=yes] |
  139. | enable-static | build static libraries [default=yes] |
  140. | disable-Bsymbolic | Avoid linking with -Bsymbolic-function |
  141. | disable-werror | Avoid treating compiler warnings as fatal errors |
  142. Testing: <a name="testing"></a>
  143. ----------
  144. By default, if valgrind is available running tests uses it.
  145. That can slow the tests down considerably, so to disable it use:
  146. ```sh
  147. export USE_VALGRIND=0
  148. ```
  149. To run tests a separate build directory is recommended:
  150. ```sh
  151. mkdir build-test
  152. cd build-test
  153. # VALGRIND=1 causes -DVALGRIND=1 to be passed when compiling code
  154. # which uses slightly slower, but valgrind-safe code.
  155. VALGRIND=1 cmake ..
  156. make
  157. make test
  158. # By default, if valgrind is available running tests uses it.
  159. make USE_VALGRIND=0 test # optionally skip using valgrind
  160. ```
  161. If a test fails, check `Testing/Temporary/LastTest.log`,
  162. `tests/testSubDir/${testname}/${testname}.vg.out`, and other similar files.
  163. If there is insufficient output try:
  164. ```sh
  165. VERBOSE=1 CTEST_OUTPUT_ON_FAILURE=1 make test
  166. ```
  167. or
  168. ```sh
  169. JSONC_TEST_TRACE=1 make test
  170. ```
  171. and check the log files again.
  172. Building on Unix and Windows with `vcpkg` <a name="buildvcpkg"></a>
  173. --------------------------------------------------
  174. You can download and install JSON-C using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager:
  175. git clone https://github.com/Microsoft/vcpkg.git
  176. cd vcpkg
  177. ./bootstrap-vcpkg.sh
  178. ./vcpkg integrate install
  179. vcpkg install json-c
  180. The JSON-C port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
  181. Building for Android <a name="android">
  182. ----------------------
  183. Building on Android is now particularly well supported, but there
  184. have been some reports of success using
  185. https://developer.android.com/ndk/guides/cmake
  186. ```
  187. mkdir json-c-build
  188. cd json-c-build/
  189. export NDK_HOME=~/Library/Android/sdk/ndk/22.1.7171670/
  190. cmake \
  191. --toolchain=$NDK_HOME/build/cmake/android.toolchain.cmake \
  192. -DANDROID_STL=none \
  193. -DANDROID_ABI=arm64-v8a \
  194. -DANDROID_PLATFORM=android-29 \
  195. -DANDROID_LD=lld \
  196. -DCMAKE_BUILD_TYPE=MinSizeRel \
  197. -DCMAKE_INSTALL_PREFIX=<install prefix> \
  198. -DENABLE_THREADING=true \
  199. ..
  200. make install
  201. ```
  202. Linking to `libjson-c` <a name="linking">
  203. ----------------------
  204. If your system has `pkgconfig`,
  205. then you can just add this to your `makefile`:
  206. ```make
  207. CFLAGS += $(shell pkg-config --cflags json-c)
  208. LDFLAGS += $(shell pkg-config --libs json-c)
  209. ```
  210. Without `pkgconfig`, you might do something like this:
  211. ```make
  212. JSON_C_DIR=/path/to/json_c/install
  213. CFLAGS += -I$(JSON_C_DIR)/include/json-c
  214. # Or to use lines like: #include <json-c/json_object.h>
  215. #CFLAGS += -I$(JSON_C_DIR)/include
  216. LDFLAGS+= -L$(JSON_C_DIR)/lib -ljson-c
  217. ```
  218. If your project uses cmake:
  219. * Add to your CMakeLists.txt file:
  220. ```cmake
  221. find_package(json-c CONFIG)
  222. target_link_libraries(${PROJECT_NAME} PRIVATE json-c::json-c)
  223. ```
  224. * Then you might run in your project:
  225. ```sh
  226. cd build
  227. cmake -DCMAKE_PREFIX_PATH=/path/to/json_c/install/lib64/cmake ..
  228. ```
  229. Using json-c <a name="using">
  230. ------------
  231. To use json-c you can either include json.h, or preferably, one of the
  232. following more specific header files:
  233. * json_object.h - Core types and methods.
  234. * json_tokener.h - Methods for parsing and serializing json-c object trees.
  235. * json_pointer.h - JSON Pointer (RFC 6901) implementation for retrieving
  236. objects from a json-c object tree.
  237. * json_object_iterator.h - Methods for iterating over single json_object instances. (See also `json_object_object_foreach()` in json_object.h)
  238. * json_visit.h - Methods for walking a tree of json-c objects.
  239. * json_util.h - Miscellaneous utility functions.
  240. For a full list of headers see [files.html](https://json-c.github.io/json-c/json-c-current-release/doc/html/files.html)
  241. The primary type in json-c is json_object. It describes a reference counted
  242. tree of json objects which are created by either parsing text with a
  243. json_tokener (i.e. `json_tokener_parse_ex()`), or by creating
  244. (with `json_object_new_object()`, `json_object_new_int()`, etc...) and adding
  245. (with `json_object_object_add()`, `json_object_array_add()`, etc...) them
  246. individually.
  247. Typically, every object in the tree will have one reference, from its parent.
  248. When you are done with the tree of objects, you call json_object_put() on just
  249. the root object to free it, which recurses down through any child objects
  250. calling json_object_put() on each one of those in turn.
  251. You can get a reference to a single child
  252. (`json_object_object_get()` or `json_object_array_get_idx()`)
  253. and use that object as long as its parent is valid.
  254. If you need a child object to live longer than its parent, you can
  255. increment the child's refcount (`json_object_get()`) to allow it to survive
  256. the parent being freed or it being removed from its parent
  257. (`json_object_object_del()` or `json_object_array_del_idx()`)
  258. When parsing text, the json_tokener object is independent from the json_object
  259. that it returns. It can be allocated (`json_tokener_new()`)
  260. used one or multiple times (`json_tokener_parse_ex()`, and
  261. freed (`json_tokener_free()`) while the json_object objects live on.
  262. A json_object tree can be serialized back into a string with
  263. `json_object_to_json_string_ext()`. The string that is returned
  264. is only valid until the next "to_json_string" call on that same object.
  265. Also, it is freed when the json_object is freed.