json-c  0.13.1
  1. Overview and Build Status
  2. Building on Unix
  3. Install Prerequisites
  4. Building with partial threading support
  5. Linking to libjson-c
  6. Using json-c

JSON-C - A JSON implementation in C

Build Status

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

Building on Unix with git, gcc and autotools

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


See also the "Installing prerequisites" section below.

If you're not using a release tarball, you'll also need:

Make sure you have a complete libtool install, including libtoolize.

To generate docs (e.g. as part of make distcheck) you'll also need:

Build instructions:

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

```sh $ git clone https://github.com/json-c/json-c.git $ cd json-c $ sh autogen.sh ```

followed by

```sh $ ./configure # –enable-threading $ make $ make install ```

To build and run the test programs:

```sh $ make check $ make USE_VALGRIND=0 check # optionally skip using valgrind ```

Install prerequisites

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

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

```sh sudo apt install git sudo apt install autoconf automake libtool sudo apt install valgrind # optional ```

Then start from the "git clone" command, above.

Manually install and build autoconf, automake and libtool

For older OS's that don't have up-to-date version of the packages will require a bit more work. For example, CentOS release 5.11, etc...

```sh curl -O http://ftp.gnu.org/gnu/autoconf/autoconf-2.69.tar.gz curl -O http://ftp.gnu.org/gnu/automake/automake-1.15.tar.gz curl -O http://ftp.gnu.org/gnu/libtool/libtool-2.2.6b.tar.gz

tar xzf autoconf-2.69.tar.gz tar xzf automake-1.15.tar.gz tar xzf libtool-2.2.6b.tar.gz

export PATH=${HOME}/ac_install/bin:$PATH

(cd autoconf-2.69 && \ ./configure –prefix ${HOME}/ac_install && \ make && \ make install)

(cd automake-1.15 && \ ./configure –prefix ${HOME}/ac_install && \ make && \ make install)

(cd libtool-2.2.6b && \ ./configure –prefix ${HOME}/ac_install && \ make && \ make install) ```

Building with partial threading support

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

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

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

Linking to libjson-c

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

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

Without pkgconfig, you would do something like this:

```make JSON_C_DIR=/path/to/json_c/install CFLAGS += -I/include/json-c LDFLAGS+= -L/lib -ljson-c ```

Using json-c

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

For a full list of headers see files.html