libcouchbase 1.0.4 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 35fe6cdbdb5c9b531318676b7d84d6f82dfc7a5c
-  data.tar.gz: 4140f1a10bce79401304ed15794dbdabab7ae979
+  metadata.gz: be988dba6fcc3cad2ae5e6b5ee57be6382fab952
+  data.tar.gz: 7eba0fd2d3ec665e9373e308bd78405766670769
 SHA512:
-  metadata.gz: b0f1994bd9ee6195b33419c7bfce7b5e0c2a46b9c5aa3126ca7e1e7663fa14d2b0764037a7b51d02f5228f36cd1667671746d2cda58a7a9849e62da553d35fde
-  data.tar.gz: 1ae07ed59cfb4c90286e870b70b0d0c3cb18a7a74b41d98773646325fcfaf7727fb65cceb283ffada8a3959fa850f74c9f745b21c64d55fd42bf86bb64f27ecd
+  metadata.gz: 386f1456c6853cae5766041ee2ee988703cf1f71d4d4d5974ebbc00ee887f44f6b0a8689144b83bc2b9c13df573b262ecd281cc1fa57e817904544ef96576889
+  data.tar.gz: 7a37eecb3b1bbb3c761fc21f68a4eb6c5a7974e32624642f49de9a89b3e84581444cb40e13f970f66774c57fee977f3d4215a9bbefd4577ade7f4e867d8d1784

data/.travis.yml

@@ -1,28 +1,30 @@
 language: ruby
 rvm:
-  - ruby-2.4.1
-  - ruby-2.3.4
+  - ruby-2.4.2
+  - ruby-2.3.5
   - ruby-head
-  - jruby-9.1.10.0
+  - jruby-9.1.13.0
   - jruby-head
   - rubinius
-  - rubinius-3.78
+  - rubinius-3.86
 branches:
   only:
     - master
 before_install:
   - git submodule update --init --recursive
   - gem install ffi
-  - sudo apt-get install libev-dev
-  - sudo wget https://packages.couchbase.com/releases/4.6.2/couchbase-server-enterprise_4.6.2-ubuntu14.04_amd64.deb
-  - sudo dpkg -i couchbase-server-enterprise_4.6.2-ubuntu14.04_amd64.deb
+  - sudo apt-get install libev-dev python-httplib2
+  - sudo wget https://packages.couchbase.com/releases/5.0.0/couchbase-server-enterprise_5.0.0-ubuntu14.04_amd64.deb
+  - sudo dpkg -i couchbase-server-enterprise_5.0.0-ubuntu14.04_amd64.deb
   - sleep 4
   - sudo service couchbase-server status
   - /opt/couchbase/bin/couchbase-cli cluster-init -c 127.0.0.1:8091 --cluster-username=admin --cluster-password=password --cluster-ramsize=320 --cluster-index-ramsize=256 --cluster-fts-ramsize=256 --services=data,index,query,fts
   - sleep 4
   - /opt/couchbase/bin/couchbase-cli server-info   -c 127.0.0.1:8091 -u admin -p password
   - /opt/couchbase/bin/couchbase-cli bucket-create -c 127.0.0.1:8091 -u admin -p password --bucket=default --bucket-type=couchbase --bucket-ramsize=160 --bucket-replica=0 --wait
-  - /opt/couchbase/bin/couchbase-cli bucket-create -c 127.0.0.1:8091 -u admin -p password --bucket=test    --bucket-type=couchbase --bucket-ramsize=160 --bucket-replica=0 --bucket-password=password123 --enable-flush=1 --wait
+  - /opt/couchbase/bin/couchbase-cli bucket-create -c 127.0.0.1:8091 -u admin -p password --bucket=test    --bucket-type=couchbase --bucket-ramsize=160 --bucket-replica=0 --enable-flush=1 --wait
+  - sleep 1
+  - /opt/couchbase/bin/couchbase-cli user-manage   -c 127.0.0.1:8091 -u admin -p password --set --rbac-username tester --rbac-password password123 --rbac-name "Auto Tester" --roles admin --auth-domain local
   - /opt/couchbase/bin/cbrestore -x rehash=1 -b default -B default -u admin -p password ./spec/seed http://127.0.0.1:8091
 before_script:
   - rake compile
@@ -31,5 +33,6 @@ matrix:
     - rvm: jruby-head
     - rvm: ruby-head
     - rvm: rubinius
+    - rvm: rubinius-3.86
 sudo: required
 dist: trusty

data/ext/libcouchbase/CMakeLists.txt

@@ -21,7 +21,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8.9)
 # These variables can be modified as needed
 
 # Couchbase mock path to download
-SET(COUCHBASE_MOCK_VERSION CouchbaseMock-LATEST.jar)
+SET(COUCHBASE_MOCK_VERSION CouchbaseMock-1.5.12.jar)
 # Maven repository where ${COUCHBASE_MOCK_VERSION} is to be found
 SET(COUCHBASE_MOCK_DLSERVER http://packages.couchbase.com/clients/c/mock)
 project(libcouchbase)

data/ext/libcouchbase/README.markdown

@@ -1,7 +1,5 @@
 # Couchbase C Client
 
-[![Build Status](https://travis-ci.org/couchbase/libcouchbase.png?branch=master)](https://travis-ci.org/couchbase/libcouchbase)
-
 This is the C client library for [Couchbase](http://www.couchbase.com)
 It communicates with the cluster and speaks the relevant protocols
 necessary to connect to the cluster and execute data operations.
@@ -23,7 +21,7 @@ necessary to connect to the cluster and execute data operations.
 ## Building
 
 Before you build from this repository, please check the
-[installation page](http://developer.couchbase.com/server/other-products/release-notes-archives/c-sdk)
+[installation page](https://developer.couchbase.com/server/other-products/release-notes-archives/c-sdk)
 to see if there is a binary or release tarball available for your needs. Since the code here is
 not part of an official release it has therefore not gone through our
 release testing process.
@@ -76,6 +74,40 @@ If you wish to link against OpenSSL, you should set the value of
 `OPENSSL_ROOT_DIR` to the location of the installation path, as described
 [here](https://github.com/Kitware/CMake/blob/master/Modules/FindOpenSSL.cmake)
 
+## Running tests
+
+To run tests, you can use either ctest directly or generated build targets.
+For Unix-like:
+
+```shell
+make test
+```
+
+For windows:
+
+```batchfile
+cmake --build . --target alltests
+ctest -C debug
+```
+
+By default tests will use [CouchbaseMock](https://github.com/couchbase/CouchbaseMock) project to simulate the Couchbase
+Cluster. It allows to cover more different failure scenarios, although does not implement all kinds of APIs provided
+by real server.
+
+If you need to test against real server, you have to provide comma-separated configuration in `LCB_TEST_CLUSTER_CONF`
+environment variable. For example, the following command will run tests against local cluster and bucket `default` using
+administrator credentials:
+
+```shell
+export LCB_TEST_CLUSTER_CONF=couchbase://localhost,default,Administrator,password
+make test
+```
+Note that specifying username will automatically switch to RBAC mode, which supported by Couchbase Server 5.0+. For old
+servers the spec will look like `couchbase://localhost,default` or `couchbase://localhost,protected,,secret`.
+
+Also tests expecting `beer-sample` bucket loaded. It comes with the server. Look at "Sample buckets" section of Admin
+Console.
+
 ## Bugs, Support, Issues
 You may report issues in the library in our issue tracked at
 <https://issues.couchbase.com>. Sign up for an account and file an issue
@@ -91,18 +123,18 @@ irc.freenode.net.
 * Official client libraries using libcouchbase
     * [node.js](http://github.com/couchbase/couchnode)
     * [Python](http://github.com/couchbase/couchbase-python-client)
-    * [Ruby](http://github.com/couchbase/couchbase-ruby-client) (uses the old < 2.6 API)
-    * [PHP](http://github.com/couchbase/php-couchbase) (uses the old < 2.6 API)
+    * [PHP](http://github.com/couchbase/php-couchbase)
 * Community projects using libcouchbase
     * [C++11 wrapper](https://github.com/couchbaselabs/libcouchbase-cxx)
     * [cberl - Couchbase NIF](https://github.com/wcummings/cberl)
     * [Perl client](https://github.com/mnunberg/perl-Couchbase-Client)
+    * [Ruby](http://github.com/couchbase/couchbase-ruby-client) (uses the old < 2.6 API)
 
 ## Documentation
 
 Documentation is available in guide format (introducing the basic concepts of
 Couchbase and the library). It is recommended for first-time users, and can
-be accessed at our [Documentation Site](http://developer.couchbase.com/documentation/server/4.5/sdk/c/start-using-sdk.html).
+be accessed at our [Documentation Site](https://developer.couchbase.com/documentation/server/current/sdk/c/start-using-sdk.html).
 
 API documentation is also available and is generated from the library's headers.
 It may contain references to more advanced features not found in the guide.

data/ext/libcouchbase/RELEASE_NOTES.markdown

@@ -1,5 +1,156 @@
 # Release Notes
 
+## 2.8.2 (October 17 2017)
+
+* [CCBC-833](https://issues.couchbase.com/browse/CCBC-833), [CCBC-834](https://issues.couchbase.com/browse/CCBC-834):
+  Update real cluster integration in the test suite.
+
+* [CCBC-860](https://issues.couchbase.com/browse/CCBC-860): cbc-connstr: Do not zero out C++ instances.
+
+* [CCBC-859](https://issues.couchbase.com/browse/CCBC-859): Fix libm shared object detection on Debian 9.
+
+* Bugs reported by [clang analyzer](http://clang-analyzer.llvm.org/):
+
+  * [CCBC-858](https://issues.couchbase.com/browse/CCBC-858): Fix memory leak for compressed packet.
+  * [CCBC-857](https://issues.couchbase.com/browse/CCBC-857): Fix possible NULL pointer dereference in `mcreq_reserve_key`.
+  * [CCBC-856](https://issues.couchbase.com/browse/CCBC-856): Initialize response struct in `H_config`.
+  * [CCBC-855](https://issues.couchbase.com/browse/CCBC-855): Fix dead assignments in `contrib/genhash`.
+  * [CCBC-854](https://issues.couchbase.com/browse/CCBC-854): Init vbguess array before entry lookup.
+  * [CCBC-853](https://issues.couchbase.com/browse/CCBC-853): cbc-proxy: do not use client object after free.
+  * [CCBC-852](https://issues.couchbase.com/browse/CCBC-852): Do not free memory twice in N1QL index manager.
+
+## 2.8.1 (September 20 2017)
+
+* Check nodes number for durability checks. The store with durability
+  requirements will report more specific error when the library cannot
+  fulfill the condition during failover.
+  * Issues: [CCBC-817](https://issues.couchbase.com/browse/CCBC-817)
+
+* Handle enhanced error messages for subdoc operations. The subdoc
+  responses will now expose context and reference ID if present.
+  * Issues: [CCBC-846](https://issues.couchbase.com/browse/CCBC-846)
+
+* Discover and bootstrap analytics service from cluster configuration.
+  * Issues: [CCBC-840](https://issues.couchbase.com/browse/CCBC-840)
+
+* Improve documentation of configuration parameters.
+  * Issues: [CCBC-835](https://issues.couchbase.com/browse/CCBC-835)
+
+* Enable Error Map feature by default.
+  * Issues: [CCBC-838](https://issues.couchbase.com/browse/CCBC-838)
+
+* Cleanup and extend `minimal`, `libeventdirect`, `instancepool` examples
+
+* Tools:
+  * improve error reporting
+  * experimental subcommand `cbc-proxy`
+  * fix memory leaks
+  * retry store operations during population phase in `cbc-pillowfight`
+
+## 2.8.0 (August 31 2017)
+
+* Add support for OpenSSL-1.1.
+  * Issues: [CCBC-814](https://issues.couchbase.com/browse/CCBC-814)
+
+* Mask `LOCKED` status code for backward compatibility. This code
+  (as well as others possible codes with 'item-locked' attribute)
+  replaced with `LCB_KEY_EEXISTS` for `SET`, `REPLACE` and `DELETE`
+  operations, and with `LCB_ETMPFAIL` for the rest.
+  * Issues: [CCBC-832](https://issues.couchbase.com/browse/CCBC-832)
+
+* Stop enumerating bootstrap nodes and mechanisms when the server
+  returns authentication error.
+  * Issues: [CCBC-825](https://issues.couchbase.com/browse/CCBC-825)
+
+* Fixed double free error with `lcb_ping3`.
+  * Issues: [CCBC-826](https://issues.couchbase.com/browse/CCBC-826)
+
+* Exposed additional N1QL query parameters: `lcb_n1p_readonly`,
+  `lcb_n1p_scancap`, `lcb_n1p_pipelinecap`.
+  * Issues: [CCBC-823](https://issues.couchbase.com/browse/CCBC-823)
+
+* Fixed `cbc-subdoc/upsert` without XATTR.
+  * Issues: [CCBC-823](https://issues.couchbase.com/browse/CCBC-823)
+
+* XERROR attributes synchronized with recent list on server.
+  * Issues: [CCBC-828](https://issues.couchbase.com/browse/CCBC-828)
+
+* Add missing documentation, and update stability of the API.
+  * Issues:
+  [CCBC-830](https://issues.couchbase.com/browse/CCBC-830),
+  [CCBC-831](https://issues.couchbase.com/browse/CCBC-831),
+  [CCBC-827](https://issues.couchbase.com/browse/CCBC-827)
+
+* Do not throttle background configuration polling by throttle interval
+  of configuration error handler.
+  * Issues: [CCBC-829](https://issues.couchbase.com/browse/CCBC-829)
+
+* Turn on background polling by default. The library will try
+  to schedule configuration update every 2.5 seconds. To disable it
+  use `config_poll_interval=0`.
+  * Issues: [CCBC-836](https://issues.couchbase.com/browse/CCBC-836)
+
+## 2.7.7 (August 17 2017)
+
+* Implement new function `lcb_ping3`, which sends NOOP-like message to
+  each service in the cluster and allows to measure latency along with
+  health status of the connection. Might be useful for application-side
+  keep-alive mechanisms.
+  * Issues: [CCBC-801](https://issues.couchbase.com/browse/CCBC-801)
+
+* Detect and expose bucket type through `LCB_CNTL_BUCKETTYPE`:
+
+        lcb_BTYPE type;
+        lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_BUCKETTYPE, &type);
+
+  * Issues: [CCBC-790](https://issues.couchbase.com/browse/CCBC-790)
+
+* Fixed setting expiration in subdoc mutations.
+  * Issues: [CCBC-799](https://issues.couchbase.com/browse/CCBC-816)
+
+* Fixed DNS SRV support of Fedora 26 and FreeBSD.
+  * Issues: [CCBC-816](https://issues.couchbase.com/browse/CCBC-816)
+
+* Fixed DNS SRV with SSL connections.
+  * Issues: [CCBC-794](https://issues.couchbase.com/browse/CCBC-794)
+
+* Define EREMOTEIO in libuv
+  * Issues: [CCBC-812](https://issues.couchbase.com/browse/CCBC-812)
+
+* New subdocument command to remove whole document
+  * Issues: [CCBC-811](https://issues.couchbase.com/browse/CCBC-811)
+
+* New cbc command: `cbc-subdoc`. It provides interactive shell, where
+  all subdocument commands accessible to inspect and modify documents
+  in the cluster.
+
+* New cbc command: `cbc-ping`. It sends NOOP-like messages to all accessible
+  services in the cluster, and displays the status along with latency.
+  * Issues: [CCBC-801](https://issues.couchbase.com/browse/CCBC-801)
+
+* Fix `cbc-cat --replica`, which now allows reading documents from replicas.
+  * Issues: [CCBC-820](https://issues.couchbase.com/browse/CCBC-820)
+
+* Implement NOOP command and `cbc-pillowfight --noop`, which sends NOOP
+  instead of data manipulation commands.
+  * Issues: [CCBC-801](https://issues.couchbase.com/browse/CCBC-801)
+
+* Clarify errors found in `.cbcrc`. Now it will display configuration path
+  along with error message.
+  * Issues: [CCBC-759](https://issues.couchbase.com/browse/CCBC-759]
+
+* Update examples:
+  * Support username/password in subdoc and libeventdirect examples
+  * Added example for subdoc XATTRs
+
+* Integrate fix for parallel build with dtrace on FreeBSD
+  https://github.com/freebsd/freebsd-ports/commit/a71e1a86b851d42cd08319d9b28a4424e508e216
+
+* Make enhanced errors API public
+  * Issues: [CCBC-803](https://issues.couchbase.com/browse/CCBC-803)
+
+* Fixed various compiler and cppcheck warnings and documentation update.
+
 ## 2.7.6 (July 11 2017)
 
 * Expose enhanced errors for data commands. Couchbase Server 5 might return

data/ext/libcouchbase/cmake/Modules/GenerateConfigDotH.cmake

@@ -9,7 +9,7 @@ IF(UNIX)
     CHECK_FUNCTION_EXISTS(clock_gettime HAVE_CLOCK_GETTIME)
     CHECK_FUNCTION_EXISTS(setitimer HAVE_SETITIMER)
     CHECK_SYMBOL_EXISTS(htonll arpa/inet.h HAVE_HTONLL)
-    CHECK_SYMBOL_EXISTS(res_search resolv.h HAVE_RES_SEARCH)
+    CHECK_SYMBOL_EXISTS(res_search "netinet/in.h;resolv.h" HAVE_RES_SEARCH)
     CHECK_INCLUDE_FILES(dlfcn.h HAVE_DLFCN_H)
     CHECK_INCLUDE_FILES(netdb.h HAVE_NETDB_H)
     CHECK_INCLUDE_FILES(stdint.h HAVE_STDINT_H)
@@ -36,7 +36,7 @@ ELSEIF (CMAKE_SYSTEM_NAME STREQUAL "Linux")
     OUTPUT_VARIABLE LIBM_SO_TRACE
     ERROR_QUIET
     OUTPUT_STRIP_TRAILING_WHITESPACE)
-  STRING(REGEX MATCH [a-z0-9/]+libm.so[.0-9]* LIBM_SO_PATH ${LIBM_SO_TRACE})
+  STRING(REGEX MATCH [-_a-z0-9/]+libm.so[.0-9]* LIBM_SO_PATH ${LIBM_SO_TRACE})
   IF (EXISTS "${LIBM_SO_PATH}")
     GET_FILENAME_COMPONENT(CMAKE_TEST_SHARED_OBJECT ${LIBM_SO_PATH} NAME)
   ENDIF()

data/ext/libcouchbase/cmake/Modules/GetVersionInfo.cmake

@@ -42,13 +42,13 @@ ENDIF()
 
 IF (NOT LCB_VERSION)
     SET(LCB_NOGITVERSION ON)
-    SET(LCB_VERSION "2.7.6")
+    SET(LCB_VERSION "2.8.2")
 ENDIF()
 IF (NOT LCB_VERSION_CHANGESET)
     SET(LCB_VERSION_CHANGESET "0xdeadbeef")
 ENDIF()
 IF (NOT LCB_VERSION_HEX)
-    SET(LCB_VERSION_HEX 0x020706)
+    SET(LCB_VERSION_HEX 0x020802)
 ENDIF()
 
 # Now parse the version string
@@ -63,7 +63,7 @@ IF(APPLE)
 ELSE()
     SET(LCB_SONAME_MAJOR "2")
 ENDIF()
-SET(LCB_SONAME_FULL "${LCB_SONAME_MAJOR}.0.46")
+SET(LCB_SONAME_FULL "${LCB_SONAME_MAJOR}.0.50")
 
 MESSAGE(STATUS
     "libcouchbase ${LCB_VERSION_MAJOR},${LCB_VERSION_MINOR},${LCB_VERSION_PATCH}")

data/ext/libcouchbase/cmake/source_files.cmake

@@ -84,6 +84,7 @@ SET(LCB_CORE_CXXSRC
     src/operations/store.cc
     src/operations/subdoc.cc
     src/operations/touch.cc
+    src/operations/ping.cc
     src/mcserver/mcserver.cc
     src/mcserver/negotiate.cc
     src/retrychk.cc

data/ext/libcouchbase/contrib/cJSON/cJSON.c

@@ -33,28 +33,34 @@
 #include <assert.h>
 #include "cJSON.h"
 
-static int cJSON_strcasecmp(const char *s1,const char *s2)
+static int cJSON_strcasecmp(const char *s1, const char *s2)
 {
-    if (!s1) return (s1==s2)?0:1;if (!s2) return 1;
-    for(; tolower(*s1) == tolower(*s2); ++s1, ++s2) if(*s1 == 0)    return 0;
+    if (!s1)
+        return (s1 == s2) ? 0 : 1;
+    if (!s2)
+        return 1;
+    for (; tolower(*s1) == tolower(*s2); ++s1, ++s2)
+        if (*s1 == 0)
+            return 0;
     return tolower(*(const unsigned char *)s1) - tolower(*(const unsigned char *)s2);
 }
 
 static void *(*cJSON_malloc)(size_t sz) = malloc;
 static void (*cJSON_free)(void *ptr) = free;
 
-static char* cJSON_strdup(const char* str)
+static char *cJSON_strdup(const char *str)
 {
-      size_t len;
-      char* copy;
+    size_t len;
+    char *copy;
 
-      len = strlen(str) + 1;
-      if (!(copy = (char*)cJSON_malloc(len))) return 0;
-      memcpy(copy,str,len);
-      return copy;
+    len = strlen(str) + 1;
+    if (!(copy = (char *)cJSON_malloc(len)))
+        return 0;
+    memcpy(copy, str, len);
+    return copy;
 }
 
-void cJSON_InitHooks(cJSON_Hooks* hooks)
+void cJSON_InitHooks(cJSON_Hooks *hooks)
 {
     if (!hooks) { /* Reset hooks */
         cJSON_malloc = malloc;
@@ -62,8 +68,8 @@ void cJSON_InitHooks(cJSON_Hooks* hooks)
         return;
     }
 
-    cJSON_malloc = (hooks->malloc_fn)?hooks->malloc_fn:malloc;
-    cJSON_free   = (hooks->free_fn)?hooks->free_fn:free;
+    cJSON_malloc = (hooks->malloc_fn) ? hooks->malloc_fn : malloc;
+    cJSON_free = (hooks->free_fn) ? hooks->free_fn : free;
 }
 
 /* The size of pool allocation groups.  Note that the allocation
@@ -72,7 +78,7 @@ void cJSON_InitHooks(cJSON_Hooks* hooks)
     evidence of best performance with Couchbase configuration
     data */
 #ifndef CJSON_POOL_ALLOC_SIZE
-    #define CJSON_POOL_ALLOC_SIZE 1024
+#define CJSON_POOL_ALLOC_SIZE 1024
 #endif
 
 /* Creates a new allocation pool. */
@@ -86,21 +92,19 @@ static cJSON_PoolBlock *cJSON_New_PoolBlock(cJSON_Pool *pool)
         return 0;
     }
 
-    new_block = (cJSON_PoolBlock*)cJSON_malloc(
-        sizeof(cJSON_PoolBlock) + sizeof(cJSON)*CJSON_POOL_ALLOC_SIZE);
+    new_block = (cJSON_PoolBlock *)cJSON_malloc(sizeof(cJSON_PoolBlock) + sizeof(cJSON) * CJSON_POOL_ALLOC_SIZE);
     if (!new_block) {
         return 0;
     }
 
-    new_alloc = (cJSON*)(new_block+1);
+    new_alloc = (cJSON *)(new_block + 1);
 
-    memset(new_block, 0,
-        sizeof(cJSON_PoolBlock) + sizeof(cJSON)*CJSON_POOL_ALLOC_SIZE);
+    memset(new_block, 0, sizeof(cJSON_PoolBlock) + sizeof(cJSON) * CJSON_POOL_ALLOC_SIZE);
 
     new_block->next = pool->blocks;
     pool->blocks = new_block;
 
-    for (i=0, item=new_alloc; i<CJSON_POOL_ALLOC_SIZE; ++i, ++item) {
+    for (i = 0, item = new_alloc; i < CJSON_POOL_ALLOC_SIZE; ++i, ++item) {
         item->next = pool->free_items;
         pool->free_items = item;
     }
@@ -109,12 +113,12 @@ static cJSON_PoolBlock *cJSON_New_PoolBlock(cJSON_Pool *pool)
 }
 
 /* This will create an allocation pool */
-static cJSON_Pool * cJSON_New_Pool(void)
+static cJSON_Pool *cJSON_New_Pool(void)
 {
     if (CJSON_POOL_ALLOC_SIZE <= 0) {
         return 0;
     } else {
-        cJSON_Pool * pool = (cJSON_Pool*)cJSON_malloc(sizeof(cJSON_Pool));
+        cJSON_Pool *pool = (cJSON_Pool *)cJSON_malloc(sizeof(cJSON_Pool));
         if (!pool) {
             return 0;
         }
@@ -175,14 +179,14 @@ static void cJSON_Pool_Free_Item(cJSON_Pool *pool, cJSON *node)
 /* Internal constructor. */
 static cJSON *cJSON_New_Item(cJSON *parent)
 {
-    cJSON* node = 0;
+    cJSON *node = 0;
     if (parent && parent->alloc_pool) {
         node = cJSON_Pool_New_Item(parent->alloc_pool);
     }
     if (!node) {
-        node = (cJSON*)cJSON_malloc(sizeof(cJSON));
+        node = (cJSON *)cJSON_malloc(sizeof(cJSON));
         if (node) {
-            memset(node,0,sizeof(cJSON));
+            memset(node, 0, sizeof(cJSON));
         }
     }
     return node;
@@ -202,37 +206,56 @@ static void cJSON_Free_Item(cJSON *node)
 void cJSON_Delete(cJSON *c)
 {
     cJSON *next;
-    while (c)
-    {
-        next=c->next;
-        if (!(c->type&cJSON_IsReference) && c->child) cJSON_Delete(c->child);
-        if (!(c->type&cJSON_IsReference) && c->valuestring) cJSON_free(c->valuestring);
-        if (c->string) cJSON_free(c->string);
+    while (c) {
+        next = c->next;
+        if (!(c->type & cJSON_IsReference) && c->child)
+            cJSON_Delete(c->child);
+        if (!(c->type & cJSON_IsReference) && c->valuestring)
+            cJSON_free(c->valuestring);
+        if (c->string)
+            cJSON_free(c->string);
         cJSON_Free_Item(c);
-        c=next;
+        c = next;
     }
 }
 
 /* Parse the input text to generate a number, and populate the result into item. */
-static const char *parse_number(cJSON *item,const char *num)
+static const char *parse_number(cJSON *item, const char *num)
 {
-    double n=0,sign=1,scale=0;int subscale=0,signsubscale=1;
+    double n = 0, sign = 1, scale = 0;
+    int subscale = 0, signsubscale = 1;
 
     /* Could use sscanf for this? */
-    if (*num=='-') sign=-1,num++;   /* Has sign? */
-    if (*num=='0') num++;           /* is zero */
-    if (*num>='1' && *num<='9') do  n=(n*10.0)+(*num++ -'0');   while (*num>='0' && *num<='9'); /* Number? */
-    if (*num=='.') {num++;      do  n=(n*10.0)+(*num++ -'0'),scale--; while (*num>='0' && *num<='9');}  /* Fractional part? */
-    if (*num=='e' || *num=='E')     /* Exponent? */
-    {   num++;if (*num=='+') num++; else if (*num=='-') signsubscale=-1,num++;      /* With sign? */
-        while (*num>='0' && *num<='9') subscale=(subscale*10)+(*num++ - '0');   /* Number? */
+    if (*num == '-')
+        sign = -1, num++; /* Has sign? */
+    if (*num == '0')
+        num++; /* is zero */
+    if (*num >= '1' && *num <= '9')
+        do
+            n = (n * 10.0) + (*num++ - '0');
+        while (*num >= '0' && *num <= '9'); /* Number? */
+    if (*num == '.') {
+        num++;
+        do
+            n = (n * 10.0) + (*num++ - '0'), scale--;
+        while (*num >= '0' && *num <= '9');
+    }                               /* Fractional part? */
+    if (*num == 'e' || *num == 'E') /* Exponent? */
+    {
+        num++;
+        if (*num == '+')
+            num++;
+        else if (*num == '-')
+            signsubscale = -1, num++; /* With sign? */
+        while (*num >= '0' && *num <= '9')
+            subscale = (subscale * 10) + (*num++ - '0'); /* Number? */
     }
 
-    n=sign*n*pow(10.0,(scale+subscale*signsubscale));   /* number = +/- number.fraction * 10^+/- exponent */
+    n = sign * n * pow(10.0, (scale + subscale * signsubscale)); /* number = +/- number.fraction * 10^+/- exponent */
 
-    item->valuedouble=n;
-    item->valueint=(int)n;
-    item->type=cJSON_Number;
+    item->valuedouble = n;
+    item->valueint = (int)n;
+    item->type = cJSON_Number;
     return num;
 }
 
@@ -240,117 +263,180 @@ static const char *parse_number(cJSON *item,const char *num)
 static char *print_number(cJSON *item)
 {
     char *str;
-    double d=item->valuedouble;
-    if (fabs(((double)item->valueint)-d)<=DBL_EPSILON && d<=INT_MAX && d>=INT_MIN)
-    {
-        str=(char*)cJSON_malloc(21);    /* 2^64+1 can be represented in 21 chars. */
-        sprintf(str,"%d",item->valueint);
-    }
-    else
-    {
-        str=(char*)cJSON_malloc(64);    /* This is a nice tradeoff. */
-        if (fabs(floor(d)-d)<=DBL_EPSILON)          sprintf(str,"%.0f",d);
-        else if (fabs(d)<1.0e-6 || fabs(d)>1.0e9)   sprintf(str,"%e",d);
-        else                                        sprintf(str,"%f",d);
+    double d = item->valuedouble;
+    if (fabs(((double)item->valueint) - d) <= DBL_EPSILON && d <= INT_MAX && d >= INT_MIN) {
+        str = (char *)cJSON_malloc(21); /* 2^64+1 can be represented in 21 chars. */
+        sprintf(str, "%d", item->valueint);
+    } else {
+        str = (char *)cJSON_malloc(64); /* This is a nice tradeoff. */
+        if (fabs(floor(d) - d) <= DBL_EPSILON)
+            sprintf(str, "%.0f", d);
+        else if (fabs(d) < 1.0e-6 || fabs(d) > 1.0e9)
+            sprintf(str, "%e", d);
+        else
+            sprintf(str, "%f", d);
     }
     return str;
 }
 
 /* Parse the input text into an unescaped cstring, and populate item. */
-static const unsigned char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
-static const char *parse_string(cJSON *item,const char *str)
+static const unsigned char firstByteMark[7] = {0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC};
+static const char *parse_string(cJSON *item, const char *str)
 {
-    const char *ptr=str+1;char *ptr2;char *out;int len=0;unsigned uc;
-    if (*str!='\"') return 0;   /* not a string! */
-
-    while (*ptr!='\"' && (unsigned char)*ptr>31 && ++len) if (*ptr++ == '\\') ptr++;    /* Skip escaped quotes. */
-
-    out=(char*)cJSON_malloc(len+1); /* This is how long we need for the string, roughly. */
-    if (!out) return 0;
+    const char *ptr = str + 1;
+    char *ptr2;
+    char *out;
+    int len = 0;
+    unsigned uc;
+    if (*str != '\"')
+        return 0; /* not a string! */
+
+    while (*ptr != '\"' && (unsigned char)*ptr > 31 && ++len)
+        if (*ptr++ == '\\')
+            ptr++; /* Skip escaped quotes. */
+
+    out = (char *)cJSON_malloc(len + 1); /* This is how long we need for the string, roughly. */
+    if (!out)
+        return 0;
 
-    ptr=str+1;ptr2=out;
-    while (*ptr!='\"' && (unsigned char)*ptr>31)
-    {
-        if (*ptr!='\\') *ptr2++=*ptr++;
-        else
-        {
+    ptr = str + 1;
+    ptr2 = out;
+    while (*ptr != '\"' && (unsigned char)*ptr > 31) {
+        if (*ptr != '\\')
+            *ptr2++ = *ptr++;
+        else {
             ptr++;
-            switch (*ptr)
-            {
-                case 'b': *ptr2++='\b'; break;
-                case 'f': *ptr2++='\f'; break;
-                case 'n': *ptr2++='\n'; break;
-                case 'r': *ptr2++='\r'; break;
-                case 't': *ptr2++='\t'; break;
-                case 'u':    /* transcode utf16 to utf8. DOES NOT SUPPORT SURROGATE PAIRS CORRECTLY. */
-                    sscanf(ptr+1,"%4x",&uc);    /* get the unicode char. */
-                    len=3;if (uc<0x80) len=1;else if (uc<0x800) len=2;ptr2+=len;
+            switch (*ptr) {
+                case 'b':
+                    *ptr2++ = '\b';
+                    break;
+                case 'f':
+                    *ptr2++ = '\f';
+                    break;
+                case 'n':
+                    *ptr2++ = '\n';
+                    break;
+                case 'r':
+                    *ptr2++ = '\r';
+                    break;
+                case 't':
+                    *ptr2++ = '\t';
+                    break;
+                case 'u': /* transcode utf16 to utf8. DOES NOT SUPPORT SURROGATE PAIRS CORRECTLY. */
+                    sscanf(ptr + 1, "%4x", &uc); /* get the unicode char. */
+                    len = 3;
+                    if (uc < 0x80)
+                        len = 1;
+                    else if (uc < 0x800)
+                        len = 2;
+                    ptr2 += len;
 
                     switch (len) {
-                        case 3: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
-                        case 2: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
-                        case 1: *--ptr2 =(uc | firstByteMark[len]);
+                        case 3:
+                            *--ptr2 = ((uc | 0x80) & 0xBF);
+                            uc >>= 6; /* fall through */
+                        case 2:
+                            *--ptr2 = ((uc | 0x80) & 0xBF);
+                            uc >>= 6; /* fall through */
+                        case 1:
+                            *--ptr2 = (uc | firstByteMark[len]); /* fall through */
                     }
-                    ptr2+=len;ptr+=4;
+                    ptr2 += len;
+                    ptr += 4;
+                    break;
+                default:
+                    *ptr2++ = *ptr;
                     break;
-                default:  *ptr2++=*ptr; break;
             }
             ptr++;
         }
     }
-    *ptr2=0;
-    if (*ptr=='\"') ptr++;
-    item->valuestring=out;
-    item->type=cJSON_String;
+    *ptr2 = 0;
+    if (*ptr == '\"')
+        ptr++;
+    item->valuestring = out;
+    item->type = cJSON_String;
     return ptr;
 }
 
 /* Render the cstring provided to an escaped version that can be printed. */
 static char *print_string_ptr(const char *str)
 {
-    const char *ptr;char *ptr2,*out;int len=0;
-
-    if (!str) return cJSON_strdup("");
-    ptr=str;while (*ptr && ++len) {if ((unsigned char)*ptr<32 || *ptr=='\"' || *ptr=='\\') len++;ptr++;}
+    const char *ptr;
+    char *ptr2, *out;
+    int len = 0;
+
+    if (!str)
+        return cJSON_strdup("");
+    ptr = str;
+    while (*ptr && ++len) {
+        if ((unsigned char)*ptr < 32 || *ptr == '\"' || *ptr == '\\')
+            len++;
+        ptr++;
+    }
 
-    out=(char*)cJSON_malloc(len+3);
-    ptr2=out;ptr=str;
-    *ptr2++='\"';
-    while (*ptr)
-    {
-        if ((unsigned char)*ptr>31 && *ptr!='\"' && *ptr!='\\') *ptr2++=*ptr++;
-        else
-        {
-            *ptr2++='\\';
-            switch (*ptr++)
-            {
-                case '\\':  *ptr2++='\\';   break;
-                case '\"':  *ptr2++='\"';   break;
-                case '\b':  *ptr2++='b';    break;
-                case '\f':  *ptr2++='f';    break;
-                case '\n':  *ptr2++='n';    break;
-                case '\r':  *ptr2++='r';    break;
-                case '\t':  *ptr2++='t';    break;
-                default: ptr2--;    break;  /* eviscerate with prejudice. */
+    out = (char *)cJSON_malloc(len + 3);
+    ptr2 = out;
+    ptr = str;
+    *ptr2++ = '\"';
+    while (*ptr) {
+        if ((unsigned char)*ptr > 31 && *ptr != '\"' && *ptr != '\\')
+            *ptr2++ = *ptr++;
+        else {
+            *ptr2++ = '\\';
+            switch (*ptr++) {
+                case '\\':
+                    *ptr2++ = '\\';
+                    break;
+                case '\"':
+                    *ptr2++ = '\"';
+                    break;
+                case '\b':
+                    *ptr2++ = 'b';
+                    break;
+                case '\f':
+                    *ptr2++ = 'f';
+                    break;
+                case '\n':
+                    *ptr2++ = 'n';
+                    break;
+                case '\r':
+                    *ptr2++ = 'r';
+                    break;
+                case '\t':
+                    *ptr2++ = 't';
+                    break;
+                default:
+                    ptr2--;
+                    break; /* eviscerate with prejudice. */
             }
         }
     }
-    *ptr2++='\"';*ptr2++=0;
+    *ptr2++ = '\"';
+    *ptr2++ = 0;
     return out;
 }
 /* Invote print_string_ptr (which is useful) on an item. */
-static char *print_string(cJSON *item)  {return print_string_ptr(item->valuestring);}
+static char *print_string(cJSON *item)
+{
+    return print_string_ptr(item->valuestring);
+}
 
 /* Predeclare these prototypes. */
-static const char *parse_value(cJSON *item,const char *value);
-static char *print_value(cJSON *item,int depth,int fmt);
-static const char *parse_array(cJSON *item,const char *value);
-static char *print_array(cJSON *item,int depth,int fmt);
-static const char *parse_object(cJSON *item,const char *value);
-static char *print_object(cJSON *item,int depth,int fmt);
+static const char *parse_value(cJSON *item, const char *value);
+static char *print_value(cJSON *item, int depth, int fmt);
+static const char *parse_array(cJSON *item, const char *value);
+static char *print_array(cJSON *item, int depth, int fmt);
+static const char *parse_object(cJSON *item, const char *value);
+static char *print_object(cJSON *item, int depth, int fmt);
 
 /* Utility to jump whitespace and cr/lf */
-static const char *skip(const char *in) {while (in && *in && (unsigned char)*in<=32) in++; return in;}
+static const char *skip(const char *in)
+{
+    while (in && *in && (unsigned char)*in <= 32)
+        in++;
+    return in;
+}
 
 /* Parse an object - create a new root, and populate. */
 cJSON *cJSON_Parse(const char *value)
@@ -363,262 +449,574 @@ cJSON *cJSON_Parse(const char *value)
     if (!c) {
         c = cJSON_New_Item(0);
     }
-    if (!c) return 0;       /* memory fail */
+    if (!c)
+        return 0; /* memory fail */
 
     c->alloc_pool = pool;
 
-    if (!parse_value(c,skip(value))) {cJSON_Delete(c);return 0;}
+    if (!parse_value(c, skip(value))) {
+        cJSON_Delete(c);
+        return 0;
+    }
     return c;
 }
 
 /* Render a cJSON item/entity/structure to text. */
-char *cJSON_Print(cJSON *item)              {return print_value(item,0,1);}
-char *cJSON_PrintUnformatted(cJSON *item)   {return print_value(item,0,0);}
+char *cJSON_Print(cJSON *item)
+{
+    return print_value(item, 0, 1);
+}
+char *cJSON_PrintUnformatted(cJSON *item)
+{
+    return print_value(item, 0, 0);
+}
 
 /* Parser core - when encountering text, process appropriately. */
-static const char *parse_value(cJSON *item,const char *value)
+static const char *parse_value(cJSON *item, const char *value)
 {
-    if (!value)                     return 0;   /* Fail on null. */
-    if (!strncmp(value,"null",4))   { item->type=cJSON_NULL;  return value+4; }
-    if (!strncmp(value,"false",5))  { item->type=cJSON_False; return value+5; }
-    if (!strncmp(value,"true",4))   { item->type=cJSON_True; item->valueint=1;  return value+4; }
-    if (*value=='\"')               { return parse_string(item,value); }
-    if (*value=='-' || (*value>='0' && *value<='9'))    { return parse_number(item,value); }
-    if (*value=='[')                { return parse_array(item,value); }
-    if (*value=='{')                { return parse_object(item,value); }
+    if (!value)
+        return 0; /* Fail on null. */
+    if (!strncmp(value, "null", 4)) {
+        item->type = cJSON_NULL;
+        return value + 4;
+    }
+    if (!strncmp(value, "false", 5)) {
+        item->type = cJSON_False;
+        return value + 5;
+    }
+    if (!strncmp(value, "true", 4)) {
+        item->type = cJSON_True;
+        item->valueint = 1;
+        return value + 4;
+    }
+    if (*value == '\"') {
+        return parse_string(item, value);
+    }
+    if (*value == '-' || (*value >= '0' && *value <= '9')) {
+        return parse_number(item, value);
+    }
+    if (*value == '[') {
+        return parse_array(item, value);
+    }
+    if (*value == '{') {
+        return parse_object(item, value);
+    }
 
-    return 0;   /* failure. */
+    return 0; /* failure. */
 }
 
 /* Render a value to text. */
-static char *print_value(cJSON *item,int depth,int fmt)
+static char *print_value(cJSON *item, int depth, int fmt)
 {
-    char *out=0;
-    if (!item) return 0;
-    switch ((item->type)&255)
-    {
-        case cJSON_NULL:    out=cJSON_strdup("null");   break;
-        case cJSON_False:   out=cJSON_strdup("false");break;
-        case cJSON_True:    out=cJSON_strdup("true"); break;
-        case cJSON_Number:  out=print_number(item);break;
-        case cJSON_String:  out=print_string(item);break;
-        case cJSON_Array:   out=print_array(item,depth,fmt);break;
-        case cJSON_Object:  out=print_object(item,depth,fmt);break;
+    char *out = 0;
+    if (!item)
+        return 0;
+    switch ((item->type) & 255) {
+        case cJSON_NULL:
+            out = cJSON_strdup("null");
+            break;
+        case cJSON_False:
+            out = cJSON_strdup("false");
+            break;
+        case cJSON_True:
+            out = cJSON_strdup("true");
+            break;
+        case cJSON_Number:
+            out = print_number(item);
+            break;
+        case cJSON_String:
+            out = print_string(item);
+            break;
+        case cJSON_Array:
+            out = print_array(item, depth, fmt);
+            break;
+        case cJSON_Object:
+            out = print_object(item, depth, fmt);
+            break;
     }
     return out;
 }
 
 /* Build an array from input text. */
-static const char *parse_array(cJSON *item,const char *value)
+static const char *parse_array(cJSON *item, const char *value)
 {
     cJSON *child;
-    if (*value!='[')    return 0;   /* not an array! */
-
-    item->type=cJSON_Array;
-    value=skip(value+1);
-    if (*value==']') return value+1;    /* empty array. */
-
-    item->child=child=cJSON_New_Item(item);
-    if (!item->child) return 0;      /* memory fail */
-    value=skip(parse_value(child,skip(value))); /* skip any spacing, get the value. */
-    if (!value) return 0;
+    if (*value != '[')
+        return 0; /* not an array! */
+
+    item->type = cJSON_Array;
+    value = skip(value + 1);
+    if (*value == ']')
+        return value + 1; /* empty array. */
+
+    item->child = child = cJSON_New_Item(item);
+    if (!item->child)
+        return 0;                                  /* memory fail */
+    value = skip(parse_value(child, skip(value))); /* skip any spacing, get the value. */
+    if (!value)
+        return 0;
 
-    while (*value==',')
-    {
+    while (*value == ',') {
         cJSON *new_item;
-        if (!(new_item=cJSON_New_Item(item))) return 0;     /* memory fail */
-        child->next=new_item;new_item->prev=child;child=new_item;
-        value=skip(parse_value(child,skip(value+1)));
-        if (!value) return 0;   /* memory fail */
+        if (!(new_item = cJSON_New_Item(item)))
+            return 0; /* memory fail */
+        child->next = new_item;
+        new_item->prev = child;
+        child = new_item;
+        value = skip(parse_value(child, skip(value + 1)));
+        if (!value)
+            return 0; /* memory fail */
     }
 
-    if (*value==']') return value+1;    /* end of array */
-    return 0;   /* malformed. */
+    if (*value == ']')
+        return value + 1; /* end of array */
+    return 0;             /* malformed. */
 }
 
 /* Render an array to text */
-static char *print_array(cJSON *item,int depth,int fmt)
+static char *print_array(cJSON *item, int depth, int fmt)
 {
     char **entries;
-    char *out=0,*ptr,*ret;size_t len=5;
-    cJSON *child=item->child;
-    int numentries=0,i=0,fail=0;
+    char *out = 0, *ptr, *ret;
+    size_t len = 5;
+    cJSON *child = item->child;
+    int numentries = 0, i = 0, fail = 0;
 
     /* How many entries in the array? */
-    while (child) numentries++,child=child->next;
+    while (child)
+        numentries++, child = child->next;
     /* Allocate an array to hold the values for each */
-    entries=(char**)cJSON_malloc(numentries*sizeof(char*));
-    if (!entries) return 0;
-    memset(entries,0,numentries*sizeof(char*));
+    entries = (char **)cJSON_malloc(numentries * sizeof(char *));
+    if (!entries)
+        return 0;
+    memset(entries, 0, numentries * sizeof(char *));
     /* Retrieve all the results: */
-    child=item->child;
-    while (child && !fail)
-    {
-        ret=print_value(child,depth+1,fmt);
-        entries[i++]=ret;
-        if (ret) len+=strlen(ret)+2+(fmt?1:0); else fail=1;
-        child=child->next;
+    child = item->child;
+    while (child && !fail) {
+        ret = print_value(child, depth + 1, fmt);
+        entries[i++] = ret;
+        if (ret)
+            len += strlen(ret) + 2 + (fmt ? 1 : 0);
+        else
+            fail = 1;
+        child = child->next;
     }
 
     /* If we didn't fail, try to malloc the output string */
-    if (!fail) out=cJSON_malloc(len);
+    if (!fail)
+        out = cJSON_malloc(len);
     /* If that fails, we fail. */
-    if (!out) fail=1;
+    if (!out)
+        fail = 1;
 
     /* Handle failure. */
-    if (fail)
-    {
-        for (i=0;i<numentries;i++) if (entries[i]) cJSON_free(entries[i]);
+    if (fail) {
+        for (i = 0; i < numentries; i++)
+            if (entries[i])
+                cJSON_free(entries[i]);
         cJSON_free(entries);
         return 0;
     }
 
     /* Compose the output array. */
-    *out='[';
-    ptr=out+1;*ptr=0;
-    for (i=0;i<numentries;i++)
-    {
-        strcpy(ptr,entries[i]);ptr+=strlen(entries[i]);
-        if (i!=numentries-1) {*ptr++=',';if(fmt)*ptr++=' ';*ptr=0;}
+    *out = '[';
+    ptr = out + 1;
+    *ptr = 0;
+    for (i = 0; i < numentries; i++) {
+        strcpy(ptr, entries[i]);
+        ptr += strlen(entries[i]);
+        if (i != numentries - 1) {
+            *ptr++ = ',';
+            if (fmt)
+                *ptr++ = ' ';
+            *ptr = 0;
+        }
         cJSON_free(entries[i]);
     }
     cJSON_free(entries);
-    *ptr++=']';*ptr++=0;
+    *ptr++ = ']';
+    *ptr++ = 0;
     return out;
 }
 
 /* Build an object from the text. */
-static const char *parse_object(cJSON *item,const char *value)
+static const char *parse_object(cJSON *item, const char *value)
 {
     cJSON *child;
-    if (*value!='{')    return 0;   /* not an object! */
+    if (*value != '{')
+        return 0; /* not an object! */
 
-    item->type=cJSON_Object;
-    value=skip(value+1);
-    if (*value=='}') return value+1;    /* empty array. */
+    item->type = cJSON_Object;
+    value = skip(value + 1);
+    if (*value == '}')
+        return value + 1; /* empty array. */
 
-    item->child=child=cJSON_New_Item(item);
-    value=skip(parse_string(child,skip(value)));
-    if (!value) return 0;
-    child->string=child->valuestring;child->valuestring=0;
-    if (*value!=':') return 0;  /* fail! */
-    value=skip(parse_value(child,skip(value+1)));   /* skip any spacing, get the value. */
-    if (!value) return 0;
+    item->child = child = cJSON_New_Item(item);
+    value = skip(parse_string(child, skip(value)));
+    if (!value)
+        return 0;
+    child->string = child->valuestring;
+    child->valuestring = 0;
+    if (*value != ':')
+        return 0;                                      /* fail! */
+    value = skip(parse_value(child, skip(value + 1))); /* skip any spacing, get the value. */
+    if (!value)
+        return 0;
 
-    while (*value==',')
-    {
+    while (*value == ',') {
         cJSON *new_item;
-        if (!(new_item=cJSON_New_Item(item)))   return 0; /* memory fail */
-        child->next=new_item;new_item->prev=child;child=new_item;
-        value=skip(parse_string(child,skip(value+1)));
-        if (!value) return 0;
-        child->string=child->valuestring;child->valuestring=0;
-        if (*value!=':') return 0;  /* fail! */
-        value=skip(parse_value(child,skip(value+1)));   /* skip any spacing, get the value. */
-        if (!value) return 0;
+        if (!(new_item = cJSON_New_Item(item)))
+            return 0; /* memory fail */
+        child->next = new_item;
+        new_item->prev = child;
+        child = new_item;
+        value = skip(parse_string(child, skip(value + 1)));
+        if (!value)
+            return 0;
+        child->string = child->valuestring;
+        child->valuestring = 0;
+        if (*value != ':')
+            return 0;                                      /* fail! */
+        value = skip(parse_value(child, skip(value + 1))); /* skip any spacing, get the value. */
+        if (!value)
+            return 0;
     }
 
-    if (*value=='}') return value+1;    /* end of array */
-    return 0;   /* malformed. */
+    if (*value == '}')
+        return value + 1; /* end of array */
+    return 0;             /* malformed. */
 }
 
 /* Render an object to text. */
-static char *print_object(cJSON *item,int depth,int fmt)
+static char *print_object(cJSON *item, int depth, int fmt)
 {
-    char **entries=0,**names=0;
-    char *out=0,*ptr,*ret,*str;size_t len=7; int i=0,j;
-    cJSON *child=item->child;
-    int numentries=0,fail=0;
+    char **entries = 0, **names = 0;
+    char *out = 0, *ptr, *ret, *str;
+    size_t len = 7;
+    int i = 0, j;
+    cJSON *child = item->child;
+    int numentries = 0, fail = 0;
     /* Count the number of entries. */
-    while (child) numentries++,child=child->next;
+    while (child)
+        numentries++, child = child->next;
     /* Allocate space for the names and the objects */
-    entries=(char**)cJSON_malloc(numentries*sizeof(char*));
-    if (!entries) return 0;
-    names=(char**)cJSON_malloc(numentries*sizeof(char*));
-    if (!names) {cJSON_free(entries);return 0;}
-    memset(entries,0,sizeof(char*)*numentries);
-    memset(names,0,sizeof(char*)*numentries);
+    entries = (char **)cJSON_malloc(numentries * sizeof(char *));
+    if (!entries)
+        return 0;
+    names = (char **)cJSON_malloc(numentries * sizeof(char *));
+    if (!names) {
+        cJSON_free(entries);
+        return 0;
+    }
+    memset(entries, 0, sizeof(char *) * numentries);
+    memset(names, 0, sizeof(char *) * numentries);
 
     /* Collect all the results into our arrays: */
-    child=item->child;depth++;if (fmt) len+=depth;
-    while (child)
-    {
-        names[i]=str=print_string_ptr(child->string);
-        entries[i++]=ret=print_value(child,depth,fmt);
-        if (str && ret) len+=strlen(ret)+strlen(str)+2+(fmt?2+depth:0); else fail=1;
-        child=child->next;
+    child = item->child;
+    depth++;
+    if (fmt)
+        len += depth;
+    while (child) {
+        names[i] = str = print_string_ptr(child->string);
+        entries[i++] = ret = print_value(child, depth, fmt);
+        if (str && ret)
+            len += strlen(ret) + strlen(str) + 2 + (fmt ? 2 + depth : 0);
+        else
+            fail = 1;
+        child = child->next;
     }
 
     /* Try to allocate the output string */
-    if (!fail) out=(char*)cJSON_malloc(len);
-    if (!out) fail=1;
+    if (!fail)
+        out = (char *)cJSON_malloc(len);
+    if (!out)
+        fail = 1;
 
     /* Handle failure */
-    if (fail)
-    {
-        for (i=0;i<numentries;i++) {if (names[i]) free(names[i]);if (entries[i]) free(entries[i]);}
-        free(names);free(entries);
+    if (fail) {
+        for (i = 0; i < numentries; i++) {
+            if (names[i])
+                free(names[i]);
+            if (entries[i])
+                free(entries[i]);
+        }
+        free(names);
+        free(entries);
         return 0;
     }
 
     /* Compose the output: */
-    *out='{';ptr=out+1;if (fmt)*ptr++='\n';*ptr=0;
-    for (i=0;i<numentries;i++)
-    {
-        if (fmt) for (j=0;j<depth;j++) *ptr++='\t';
-        strcpy(ptr,names[i]);ptr+=strlen(names[i]);
-        *ptr++=':';if (fmt) *ptr++='\t';
-        strcpy(ptr,entries[i]);ptr+=strlen(entries[i]);
-        if (i!=numentries-1) *ptr++=',';
-        if (fmt) *ptr++='\n';*ptr=0;
-        cJSON_free(names[i]);cJSON_free(entries[i]);
-    }
-
-    cJSON_free(names);cJSON_free(entries);
-    if (fmt) for (i=0;i<depth-1;i++) *ptr++='\t';
-    *ptr++='}';*ptr++=0;
+    *out = '{';
+    ptr = out + 1;
+    if (fmt)
+        *ptr++ = '\n';
+    *ptr = 0;
+    for (i = 0; i < numentries; i++) {
+        if (fmt)
+            for (j = 0; j < depth; j++)
+                *ptr++ = '\t';
+        strcpy(ptr, names[i]);
+        ptr += strlen(names[i]);
+        *ptr++ = ':';
+        if (fmt)
+            *ptr++ = '\t';
+        strcpy(ptr, entries[i]);
+        ptr += strlen(entries[i]);
+        if (i != numentries - 1)
+            *ptr++ = ',';
+        if (fmt)
+            *ptr++ = '\n';
+        *ptr = 0;
+        cJSON_free(names[i]);
+        cJSON_free(entries[i]);
+    }
+
+    cJSON_free(names);
+    cJSON_free(entries);
+    if (fmt)
+        for (i = 0; i < depth - 1; i++)
+            *ptr++ = '\t';
+    *ptr++ = '}';
+    *ptr++ = 0;
     return out;
 }
 
 /* Get Array size/item / object item. */
-int    cJSON_GetArraySize(cJSON *array)                         {cJSON *c=array->child;int i=0;while(c)i++,c=c->next;return i;}
-cJSON *cJSON_GetArrayItem(cJSON *array,int item)                {cJSON *c=array->child;  while (c && item>0) item--,c=c->next; return c;}
-cJSON *cJSON_GetObjectItem(cJSON *object,const char *string)    {cJSON *c=object->child; while (c && cJSON_strcasecmp(c->string,string)) c=c->next; return c;}
+int cJSON_GetArraySize(cJSON *array)
+{
+    cJSON *c = array->child;
+    int i = 0;
+    while (c)
+        i++, c = c->next;
+    return i;
+}
+cJSON *cJSON_GetArrayItem(cJSON *array, int item)
+{
+    cJSON *c = array->child;
+    while (c && item > 0)
+        item--, c = c->next;
+    return c;
+}
+cJSON *cJSON_GetObjectItem(cJSON *object, const char *string)
+{
+    cJSON *c = object->child;
+    while (c && cJSON_strcasecmp(c->string, string))
+        c = c->next;
+    return c;
+}
 
 /* Utility for array list handling. */
-static void suffix_object(cJSON *prev,cJSON *item) {prev->next=item;item->prev=prev;}
+static void suffix_object(cJSON *prev, cJSON *item)
+{
+    prev->next = item;
+    item->prev = prev;
+}
 /* Utility for handling references. */
-static cJSON *create_reference(cJSON *item) {cJSON *ref=cJSON_New_Item(item);memcpy(ref,item,sizeof(cJSON));ref->string=0;ref->type|=cJSON_IsReference;ref->next=ref->prev=0;return ref;}
+static cJSON *create_reference(cJSON *item)
+{
+    cJSON *ref = cJSON_New_Item(item);
+    memcpy(ref, item, sizeof(cJSON));
+    ref->string = 0;
+    ref->type |= cJSON_IsReference;
+    ref->next = ref->prev = 0;
+    return ref;
+}
 
 /* Add item to array/object. */
-void   cJSON_AddItemToArray(cJSON *array, cJSON *item)                      {cJSON *c=array->child;if (!c) {array->child=item;} else {while (c && c->next) c=c->next; suffix_object(c,item);}}
-void   cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item)  {if (item->string) cJSON_free(item->string);item->string=cJSON_strdup(string);cJSON_AddItemToArray(object,item);}
-void    cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)                        {cJSON_AddItemToArray(array,create_reference(item));}
-void    cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item)    {cJSON_AddItemToObject(object,string,create_reference(item));}
+void cJSON_AddItemToArray(cJSON *array, cJSON *item)
+{
+    cJSON *c = array->child;
+    if (!c) {
+        array->child = item;
+    } else {
+        while (c && c->next)
+            c = c->next;
+        suffix_object(c, item);
+    }
+}
+void cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item)
+{
+    if (item->string)
+        cJSON_free(item->string);
+    item->string = cJSON_strdup(string);
+    cJSON_AddItemToArray(object, item);
+}
+void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)
+{
+    cJSON_AddItemToArray(array, create_reference(item));
+}
+void cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item)
+{
+    cJSON_AddItemToObject(object, string, create_reference(item));
+}
 
-cJSON *cJSON_DetachItemFromArray(cJSON *array,int which)            {cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return 0;
-    if (c->prev) c->prev->next=c->next;if (c->next) c->next->prev=c->prev;if (c==array->child) array->child=c->next;c->prev=c->next=0;return c;}
-void   cJSON_DeleteItemFromArray(cJSON *array,int which)            {cJSON_Delete(cJSON_DetachItemFromArray(array,which));}
-cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string) {int i=0;cJSON *c=object->child;while (c && cJSON_strcasecmp(c->string,string)) i++,c=c->next;if (c) return cJSON_DetachItemFromArray(object,i);return 0;}
-void   cJSON_DeleteItemFromObject(cJSON *object,const char *string) {cJSON_Delete(cJSON_DetachItemFromObject(object,string));}
+cJSON *cJSON_DetachItemFromArray(cJSON *array, int which)
+{
+    cJSON *c = array->child;
+    while (c && which > 0)
+        c = c->next, which--;
+    if (!c)
+        return 0;
+    if (c->prev)
+        c->prev->next = c->next;
+    if (c->next)
+        c->next->prev = c->prev;
+    if (c == array->child)
+        array->child = c->next;
+    c->prev = c->next = 0;
+    return c;
+}
+void cJSON_DeleteItemFromArray(cJSON *array, int which)
+{
+    cJSON_Delete(cJSON_DetachItemFromArray(array, which));
+}
+cJSON *cJSON_DetachItemFromObject(cJSON *object, const char *string)
+{
+    int i = 0;
+    cJSON *c = object->child;
+    while (c && cJSON_strcasecmp(c->string, string))
+        i++, c = c->next;
+    if (c)
+        return cJSON_DetachItemFromArray(object, i);
+    return 0;
+}
+void cJSON_DeleteItemFromObject(cJSON *object, const char *string)
+{
+    cJSON_Delete(cJSON_DetachItemFromObject(object, string));
+}
 
 /* Replace array/object items with new ones. */
-void   cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem)      {cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return;
-    newitem->next=c->next;newitem->prev=c->prev;if (newitem->next) newitem->next->prev=newitem;
-    if (c==array->child) array->child=newitem; else newitem->prev->next=newitem;c->next=c->prev=0;cJSON_Delete(c);}
-void   cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem){int i=0;cJSON *c=object->child;while(c && cJSON_strcasecmp(c->string,string))i++,c=c->next;if(c){newitem->string=cJSON_strdup(string);cJSON_ReplaceItemInArray(object,i,newitem);}}
+void cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem)
+{
+    cJSON *c = array->child;
+    while (c && which > 0)
+        c = c->next, which--;
+    if (!c)
+        return;
+    newitem->next = c->next;
+    newitem->prev = c->prev;
+    if (newitem->next)
+        newitem->next->prev = newitem;
+    if (c == array->child)
+        array->child = newitem;
+    else
+        newitem->prev->next = newitem;
+    c->next = c->prev = 0;
+    cJSON_Delete(c);
+}
+void cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem)
+{
+    int i = 0;
+    cJSON *c = object->child;
+    while (c && cJSON_strcasecmp(c->string, string))
+        i++, c = c->next;
+    if (c) {
+        newitem->string = cJSON_strdup(string);
+        cJSON_ReplaceItemInArray(object, i, newitem);
+    }
+}
 
 /* Create basic types: */
-cJSON *cJSON_CreateNull()                       {cJSON *item=cJSON_New_Item(0);item->type=cJSON_NULL;return item;}
-cJSON *cJSON_CreateTrue()                       {cJSON *item=cJSON_New_Item(0);item->type=cJSON_True;return item;}
-cJSON *cJSON_CreateFalse()                      {cJSON *item=cJSON_New_Item(0);item->type=cJSON_False;return item;}
-cJSON *cJSON_CreateNumber(double num)           {cJSON *item=cJSON_New_Item(0);item->type=cJSON_Number;item->valuedouble=num;item->valueint=(int)num;return item;}
-cJSON *cJSON_CreateString(const char *string)   {cJSON *item=cJSON_New_Item(0);item->type=cJSON_String;item->valuestring=cJSON_strdup(string);return item;}
-cJSON *cJSON_CreateArray()                      {cJSON *item=cJSON_New_Item(0);item->type=cJSON_Array;return item;}
-cJSON *cJSON_CreateObject()                     {cJSON *item=cJSON_New_Item(0);item->type=cJSON_Object;return item;}
+cJSON *cJSON_CreateNull()
+{
+    cJSON *item = cJSON_New_Item(0);
+    item->type = cJSON_NULL;
+    return item;
+}
+cJSON *cJSON_CreateTrue()
+{
+    cJSON *item = cJSON_New_Item(0);
+    item->type = cJSON_True;
+    return item;
+}
+cJSON *cJSON_CreateFalse()
+{
+    cJSON *item = cJSON_New_Item(0);
+    item->type = cJSON_False;
+    return item;
+}
+cJSON *cJSON_CreateNumber(double num)
+{
+    cJSON *item = cJSON_New_Item(0);
+    item->type = cJSON_Number;
+    item->valuedouble = num;
+    item->valueint = (int)num;
+    return item;
+}
+cJSON *cJSON_CreateString(const char *string)
+{
+    cJSON *item = cJSON_New_Item(0);
+    item->type = cJSON_String;
+    item->valuestring = cJSON_strdup(string);
+    return item;
+}
+cJSON *cJSON_CreateArray()
+{
+    cJSON *item = cJSON_New_Item(0);
+    item->type = cJSON_Array;
+    return item;
+}
+cJSON *cJSON_CreateObject()
+{
+    cJSON *item = cJSON_New_Item(0);
+    item->type = cJSON_Object;
+    return item;
+}
 
 /* Create Arrays: */
-cJSON *cJSON_CreateIntArray(int *numbers,int count)             {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
-cJSON *cJSON_CreateFloatArray(float *numbers,int count)         {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
-cJSON *cJSON_CreateDoubleArray(double *numbers,int count)       {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
-cJSON *cJSON_CreateStringArray(const char **strings,int count)  {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;i<count;i++){n=cJSON_CreateString(strings[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
+cJSON *cJSON_CreateIntArray(int *numbers, int count)
+{
+    int i;
+    cJSON *n = 0, *p = 0, *a = cJSON_CreateArray();
+    for (i = 0; i < count; i++) {
+        n = cJSON_CreateNumber(numbers[i]);
+        if (!i)
+            a->child = n;
+        else
+            suffix_object(p, n);
+        p = n;
+    }
+    return a;
+}
+cJSON *cJSON_CreateFloatArray(float *numbers, int count)
+{
+    int i;
+    cJSON *n = 0, *p = 0, *a = cJSON_CreateArray();
+    for (i = 0; i < count; i++) {
+        n = cJSON_CreateNumber(numbers[i]);
+        if (!i)
+            a->child = n;
+        else
+            suffix_object(p, n);
+        p = n;
+    }
+    return a;
+}
+cJSON *cJSON_CreateDoubleArray(double *numbers, int count)
+{
+    int i;
+    cJSON *n = 0, *p = 0, *a = cJSON_CreateArray();
+    for (i = 0; i < count; i++) {
+        n = cJSON_CreateNumber(numbers[i]);
+        if (!i)
+            a->child = n;
+        else
+            suffix_object(p, n);
+        p = n;
+    }
+    return a;
+}
+cJSON *cJSON_CreateStringArray(const char **strings, int count)
+{
+    int i;
+    cJSON *n = 0, *p = 0, *a = cJSON_CreateArray();
+    for (i = 0; i < count; i++) {
+        n = cJSON_CreateString(strings[i]);
+        if (!i)
+            a->child = n;
+        else
+            suffix_object(p, n);
+        p = n;
+    }
+    return a;
+}