rel_1.6.0 init

Living_SDK/utility/cjson/README

@@ -0,0 +1,258 @@
+apps/netutils/json/README.txt
+=============================
+
+This directory contains logic taken from the cJSON project:
+
+http://sourceforge.net/projects/cjson/
+
+This corresponds to SVN revision r42 (with lots of changes for NuttX coding
+standards).  As of r42, the SVN repository was last updated on 2011-10-10
+so I presume that the code is stable and there is no risk of maintaining
+duplicate logic in the NuttX repository.
+
+Contents
+========
+
+  o License
+  o Welcome to cJSON
+
+License
+=======
+
+  Copyright (c) 2009 Dave Gamble
+
+  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.
+
+Welcome to cJSON
+================
+
+cJSON aims to be the dumbest possible parser that you can get your job done with.
+It's a single file of C, and a single header file.
+
+JSON is described best here: http://www.json.org/
+It's like XML, but fat-free. You use it to move data around, store things, or just
+generally represent your program's state.
+
+First up, how do I build?
+Add cJSON.c to your project, and put cJSON.h somewhere in the header search path.
+For example, to build the test app:
+
+gcc cJSON.c test.c -o test -lm
+./test
+
+As a library, cJSON exists to take away as much legwork as it can, but not get in your way.
+As a point of pragmatism (i.e. ignoring the truth), I'm going to say that you can use it
+in one of two modes: Auto and Manual. Let's have a quick run-through.
+
+I lifted some JSON from this page: http://www.json.org/fatfree.html
+That page inspired me to write cJSON, which is a parser that tries to share the same
+philosophy as JSON itself. Simple, dumb, out of the way.
+
+Some JSON:
+{
+    "name": "Jack (\"Bee\") Nimble",
+    "format": {
+        "type":       "rect",
+        "width":      1920,
+        "height":     1080,
+        "interlace":  false,
+        "frame rate": 24
+    }
+}
+
+Assume that you got this from a file, a webserver, or magic JSON elves, whatever,
+you have a char * to it. Everything is a cJSON struct.
+Get it parsed:
+    cJSON *root = cJSON_Parse(my_json_string);
+
+This is an object. We're in C. We don't have objects. But we do have structs.
+What's the framerate?
+
+    cJSON *format = cJSON_GetObjectItem(root,"format");
+    int framerate = cJSON_GetObjectItem(format,"frame rate")->valueint;
+
+Want to change the framerate?
+    cJSON_GetObjectItem(format,"frame rate")->valueint=25;
+
+Back to disk?
+    char *rendered=cJSON_Print(root);
+
+Finished? Delete the root (this takes care of everything else).
+    cJSON_Delete(root);
+
+That's AUTO mode. If you're going to use Auto mode, you really ought to check pointers
+before you dereference them. If you want to see how you'd build this struct in code?
+    cJSON *root,*fmt;
+    root=cJSON_CreateObject();
+    cJSON_AddItemToObject(root, "name", cJSON_CreateString("Jack (\"Bee\") Nimble"));
+    cJSON_AddItemToObject(root, "format", fmt=cJSON_CreateObject());
+    cJSON_AddStringToObject(fmt,"type",        "rect");
+    cJSON_AddNumberToObject(fmt,"width",        1920);
+    cJSON_AddNumberToObject(fmt,"height",        1080);
+    cJSON_AddFalseToObject (fmt,"interlace");
+    cJSON_AddNumberToObject(fmt,"frame rate",    24);
+
+Hopefully we can agree that's not a lot of code? There's no overhead, no unnecessary setup.
+Look at test.c for a bunch of nice examples, mostly all ripped off the json.org site, and
+a few from elsewhere.
+
+What about manual mode? First up you need some detail.
+Let's cover how the cJSON objects represent the JSON data.
+cJSON doesn't distinguish arrays from objects in handling; just type.
+Each cJSON has, potentially, a child, siblings, value, a name.
+
+The root object has: Object Type and a Child
+The Child has name "name", with value "Jack ("Bee") Nimble", and a sibling:
+Sibling has type Object, name "format", and a child.
+That child has type String, name "type", value "rect", and a sibling:
+Sibling has type Number, name "width", value 1920, and a sibling:
+Sibling has type Number, name "height", value 1080, and a sibling:
+Sibling hs type False, name "interlace", and a sibling:
+Sibling has type Number, name "frame rate", value 24
+
+Here's the structure:
+typedef struct cJSON {
+    struct cJSON *next,*prev;
+    struct cJSON *child;
+
+    int type;
+
+    char *valuestring;
+    int valueint;
+    double valuedouble;
+
+    char *string;
+} cJSON;
+
+By default all values are 0 unless set by virtue of being meaningful.
+
+next/prev is a doubly linked list of siblings. next takes you to your sibling,
+prev takes you back from your sibling to you.
+Only objects and arrays have a "child", and it's the head of the doubly linked list.
+A "child" entry will have prev==0, but next potentially points on. The last sibling has next=0.
+The type expresses Null/True/False/Number/String/Array/Object, all of which are #defined in
+cJSON.h
+
+A Number has valueint and valuedouble. If you're expecting an int, read valueint, if not read
+valuedouble.
+
+Any entry which is in the linked list which is the child of an object will have a "string"
+which is the "name" of the entry. When I said "name" in the above example, that's "string".
+"string" is the JSON name for the 'variable name' if you will.
+
+Now you can trivially walk the lists, recursively, and parse as you please.
+You can invoke cJSON_Parse to get cJSON to parse for you, and then you can take
+the root object, and traverse the structure (which is, formally, an N-tree),
+and tokenise as you please. If you wanted to build a callback style parser, this is how
+you'd do it (just an example, since these things are very specific):
+
+void parse_and_callback(cJSON *item,const char *prefix)
+{
+    while (item)
+    {
+        char *newprefix=malloc(strlen(prefix)+strlen(item->name)+2);
+        sprintf(newprefix,"%s/%s",prefix,item->name);
+        int dorecurse=callback(newprefix, item->type, item);
+        if (item->child && dorecurse) parse_and_callback(item->child,newprefix);
+        item=item->next;
+        free(newprefix);
+    }
+}
+
+The prefix process will build you a separated list, to simplify your callback handling.
+The 'dorecurse' flag would let the callback decide to handle sub-arrays on it's own, or
+let you invoke it per-item. For the item above, your callback might look like this:
+
+int callback(const char *name,int type,cJSON *item)
+{
+    if (!strcmp(name,"name"))    { /* populate name */ }
+    else if (!strcmp(name,"format/type")    { /* handle "rect" */ }
+    else if (!strcmp(name,"format/width")    { /* 800 */ }
+    else if (!strcmp(name,"format/height")    { /* 600 */ }
+    else if (!strcmp(name,"format/interlace")    { /* false */ }
+    else if (!strcmp(name,"format/frame rate")    { /* 24 */ }
+    return 1;
+}
+
+Alternatively, you might like to parse iteratively.
+You'd use:
+
+void parse_object(cJSON *item)
+{
+    int i; for (i=0;i<cJSON_GetArraySize(item);i++)
+    {
+        cJSON *subitem=cJSON_GetArrayItem(item,i);
+        // handle subitem.
+    }
+}
+
+Or, for PROPER manual mode:
+
+void parse_object(cJSON *item)
+{
+    cJSON *subitem=item->child;
+    while (subitem)
+    {
+        // handle subitem
+        if (subitem->child) parse_object(subitem->child);
+
+        subitem=subitem->next;
+    }
+}
+
+Of course, this should look familiar, since this is just a stripped-down version
+of the callback-parser.
+
+This should cover most uses you'll find for parsing. The rest should be possible
+to infer.. and if in doubt, read the source! There's not a lot of it! ;)
+
+In terms of constructing JSON data, the example code above is the right way to do it.
+You can, of course, hand your sub-objects to other functions to populate.
+Also, if you find a use for it, you can manually build the objects.
+For instance, suppose you wanted to build an array of objects?
+
+cJSON *objects[24];
+
+cJSON *Create_array_of_anything(cJSON **items,int num)
+{
+    int i;cJSON *prev, *root=cJSON_CreateArray();
+    for (i=0;i<24;i++)
+    {
+        if (!i)    root->child=objects[i];
+        else    prev->next=objects[i], objects[i]->prev=prev;
+        prev=objects[i];
+    }
+    return root;
+}
+
+and simply: Create_array_of_anything(objects,24);
+
+cJSON doesn't make any assumptions about what order you create things in.
+You can attach the objects, as above, and later add children to each
+of those objects.
+
+As soon as you call cJSON_Print, it renders the structure to text.
+
+The test.c code shows how to handle a bunch of typical cases. If you uncomment
+the code, it'll load, parse and print a bunch of test files, also from json.org,
+which are more complex than I'd care to try and stash into a const char array[].
+
+Enjoy cJSON!
+
+- Dave Gamble, Aug 2009

Living_SDK/utility/cjson/cJSON_Utils.c

@@ -0,0 +1,828 @@
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "cJSON_Utils.h"
+
+static char* cJSONUtils_strdup(const char* str)
+{
+    size_t len = 0;
+    char *copy = NULL;
+
+    len = strlen(str) + 1;
+    if (!(copy = (char*)malloc(len)))
+    {
+        return NULL;
+    }
+    memcpy(copy, str, len);
+
+    return copy;
+}
+
+static int cJSONUtils_strcasecmp(const char *s1, const char *s2)
+{
+    if (!s1)
+    {
+        return (s1 == s2) ? 0 : 1; /* both NULL? */
+    }
+    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);
+}
+
+/* JSON Pointer implementation: */
+static int cJSONUtils_Pstrcasecmp(const char *a, const char *e)
+{
+    if (!a || !e)
+    {
+        return (a == e) ? 0 : 1; /* both NULL? */
+    }
+    for (; *a && *e && (*e != '/'); a++, e++) /* compare until next '/' */
+    {
+        if (*e == '~')
+        {
+            /* check for escaped '~' (~0) and '/' (~1) */
+            if (!((e[1] == '0') && (*a == '~')) && !((e[1] == '1') && (*a == '/')))
+            {
+                /* invalid escape sequence or wrong character in *a */
+                return 1;
+            }
+            else
+            {
+                e++;
+            }
+        }
+        else if (tolower(*a) != tolower(*e))
+        {
+            return 1;
+        }
+    }
+    if (((*e != 0) && (*e != '/')) != (*a != 0))
+    {
+        /* one string has ended, the other not */
+        return 1;
+    }
+
+    return 0;
+}
+
+static int cJSONUtils_PointerEncodedstrlen(const char *s)
+{
+    int l = 0;
+    for (; *s; s++, l++)
+    {
+        if ((*s == '~') || (*s == '/'))
+        {
+            l++;
+        }
+    }
+
+    return l;
+}
+
+static void cJSONUtils_PointerEncodedstrcpy(char *d, const char *s)
+{
+    for (; *s; s++)
+    {
+        if (*s == '/')
+        {
+            *d++ = '~';
+            *d++ = '1';
+        }
+        else if (*s == '~')
+        {
+            *d++ = '~';
+            *d++ = '0';
+        }
+        else
+        {
+            *d++ = *s;
+        }
+    }
+
+    *d = '\0';
+}
+
+char *cJSONUtils_FindPointerFromObjectTo(cJSON *object, cJSON *target)
+{
+    int type = object->type;
+    int c = 0;
+    cJSON *obj = 0;
+
+    if (object == target)
+    {
+        /* found */
+        return cJSONUtils_strdup("");
+    }
+
+    /* recursively search all children of the object */
+    for (obj = object->child; obj; obj = obj->next, c++)
+    {
+        char *found = cJSONUtils_FindPointerFromObjectTo(obj, target);
+        if (found)
+        {
+            if ((type & 0xFF) == cJSON_Array)
+            {
+                /* reserve enough memory for a 64 bit integer + '/' and '\0' */
+                char *ret = (char*)malloc(strlen(found) + 23);
+                sprintf(ret, "/%d%s", c, found); /* /<array_index><path> */
+                free(found);
+
+                return ret;
+            }
+            else if ((type & 0xFF) == cJSON_Object)
+            {
+                char *ret = (char*)malloc(strlen(found) + cJSONUtils_PointerEncodedstrlen(obj->string) + 2);
+                *ret = '/';
+                cJSONUtils_PointerEncodedstrcpy(ret + 1, obj->string);
+                strcat(ret, found);
+                free(found);
+
+                return ret;
+            }
+
+            /* reached leaf of the tree, found nothing */
+            free(found);
+            return NULL;
+        }
+    }
+
+    /* not found */
+    return NULL;
+}
+
+cJSON *cJSONUtils_GetPointer(cJSON *object, const char *pointer)
+{
+    /* follow path of the pointer */
+    while ((*pointer++ == '/') && object)
+    {
+        if ((object->type & 0xFF) == cJSON_Array)
+        {
+            int which = 0;
+            /* parse array index */
+            while ((*pointer >= '0') && (*pointer <= '9'))
+            {
+                which = (10 * which) + (*pointer++ - '0');
+            }
+            if (*pointer && (*pointer != '/'))
+            {
+                /* not end of string or new path token */
+                return NULL;
+            }
+            object = cJSON_GetArrayItem(object, which);
+        }
+        else if ((object->type & 0xFF) == cJSON_Object)
+        {
+            object = object->child;
+            /* GetObjectItem. */
+            while (object && cJSONUtils_Pstrcasecmp(object->string, pointer))
+            {
+                object = object->next;
+            }
+            /* skip to the next path token or end of string */
+            while (*pointer && (*pointer != '/'))
+            {
+                pointer++;
+            }
+        }
+        else
+        {
+            return NULL;
+        }
+    }
+
+    return object;
+}
+
+/* JSON Patch implementation. */
+static void cJSONUtils_InplaceDecodePointerString(char *string)
+{
+    char *s2 = string;
+    for (; *string; s2++, string++)
+    {
+        *s2 = (*string != '~')
+            ? (*string)
+            : ((*(++string) == '0')
+                    ? '~'
+                    : '/');
+    }
+
+    *s2 = '\0';
+}
+
+static cJSON *cJSONUtils_PatchDetach(cJSON *object, const char *path)
+{
+    char *parentptr = NULL;
+    char *childptr = NULL;
+    cJSON *parent = NULL;
+    cJSON *ret = NULL;
+
+    /* copy path and split it in parent and child */
+    parentptr = cJSONUtils_strdup(path);
+    childptr = strrchr(parentptr, '/'); /* last '/' */
+    if (childptr)
+    {
+        /* split strings */
+        *childptr++ = '\0';
+    }
+    parent = cJSONUtils_GetPointer(object, parentptr);
+    cJSONUtils_InplaceDecodePointerString(childptr);
+
+    if (!parent)
+    {
+        /* Couldn't find object to remove child from. */
+        ret = NULL;
+    }
+    else if ((parent->type & 0xFF) == cJSON_Array)
+    {
+        ret = cJSON_DetachItemFromArray(parent, atoi(childptr));
+    }
+    else if ((parent->type & 0xFF) == cJSON_Object)
+    {
+        ret = cJSON_DetachItemFromObject(parent, childptr);
+    }
+    free(parentptr);
+
+    /* return the detachted item */
+    return ret;
+}
+
+static int cJSONUtils_Compare(cJSON *a, cJSON *b)
+{
+    if ((a->type & 0xFF) != (b->type & 0xFF))
+    {
+        /* mismatched type. */
+        return -1;
+    }
+    switch (a->type & 0xFF)
+    {
+        case cJSON_Number:
+            /* numeric mismatch. */
+            return ((a->valueint != b->valueint) || (a->valuedouble != b->valuedouble)) ? -2 : 0;
+        case cJSON_String:
+            /* string mismatch. */
+            return (strcmp(a->valuestring, b->valuestring) != 0) ? -3 : 0;
+        case cJSON_Array:
+            for (a = a->child, b = b->child; a && b; a = a->next, b = b->next)
+            {
+                int err = cJSONUtils_Compare(a, b);
+                if (err)
+                {
+                    return err;
+                }
+            }
+            /* array size mismatch? (one of both children is not NULL) */
+            return (a || b) ? -4 : 0;
+        case cJSON_Object:
+            cJSONUtils_SortObject(a);
+            cJSONUtils_SortObject(b);
+            a = a->child;
+            b = b->child;
+            while (a && b)
+            {
+                int err = 0;
+                /* compare object keys */
+                if (cJSONUtils_strcasecmp(a->string, b->string))
+                {
+                    /* missing member */
+                    return -6;
+                }
+                err = cJSONUtils_Compare(a, b);
+                if (err)
+                {
+                    return err;
+                }
+                a = a->next;
+                b = b->next;
+            }
+            /* object length mismatch (one of both children is not null) */
+            return (a || b) ? -5 : 0;
+
+        default:
+            break;
+    }
+    /* null, true or false */
+    return 0;
+}
+
+static int cJSONUtils_ApplyPatch(cJSON *object, cJSON *patch)
+{
+    cJSON *op = NULL;
+    cJSON *path = NULL;
+    cJSON *value = NULL;
+    cJSON *parent = NULL;
+    int opcode = 0;
+    char *parentptr = NULL;
+    char *childptr = NULL;
+
+    op = cJSON_GetObjectItem(patch, "op");
+    path = cJSON_GetObjectItem(patch, "path");
+    if (!op || !path)
+    {
+        /* malformed patch. */
+        return 2;
+    }
+
+    /* decode operation */
+    if (!strcmp(op->valuestring, "add"))
+    {
+        opcode = 0;
+    }
+    else if (!strcmp(op->valuestring, "remove"))
+    {
+        opcode = 1;
+    }
+    else if (!strcmp(op->valuestring, "replace"))
+    {
+        opcode = 2;
+    }
+    else if (!strcmp(op->valuestring, "move"))
+    {
+        opcode = 3;
+    }
+    else if (!strcmp(op->valuestring, "copy"))
+    {
+        opcode = 4;
+    }
+    else if (!strcmp(op->valuestring, "test"))
+    {
+        /* compare value: {...} with the given path */
+        return cJSONUtils_Compare(cJSONUtils_GetPointer(object, path->valuestring), cJSON_GetObjectItem(patch, "value"));
+    }
+    else
+    {
+        /* unknown opcode. */
+        return 3;
+    }
+
+    /* Remove/Replace */
+    if ((opcode == 1) || (opcode == 2))
+    {
+        /* Get rid of old. */
+        cJSON_Delete(cJSONUtils_PatchDetach(object, path->valuestring));
+        if (opcode == 1)
+        {
+            /* For Remove, this is job done. */
+            return 0;
+        }
+    }
+
+    /* Copy/Move uses "from". */
+    if ((opcode == 3) || (opcode == 4))
+    {
+        cJSON *from = cJSON_GetObjectItem(patch, "from");
+        if (!from)
+        {
+            /* missing "from" for copy/move. */
+            return 4;
+        }
+
+        if (opcode == 3)
+        {
+            /* move */
+            value = cJSONUtils_PatchDetach(object, from->valuestring);
+        }
+        if (opcode == 4)
+        {
+            /* copy */
+            value = cJSONUtils_GetPointer(object, from->valuestring);
+        }
+        if (!value)
+        {
+            /* missing "from" for copy/move. */
+            return 5;
+        }
+        if (opcode == 4)
+        {
+            value = cJSON_Duplicate(value, 1);
+        }
+        if (!value)
+        {
+            /* out of memory for copy/move. */
+            return 6;
+        }
+    }
+    else /* Add/Replace uses "value". */
+    {
+        value = cJSON_GetObjectItem(patch, "value");
+        if (!value)
+        {
+            /* missing "value" for add/replace. */
+            return 7;
+        }
+        value = cJSON_Duplicate(value, 1);
+        if (!value)
+        {
+            /* out of memory for add/replace. */
+            return 8;
+        }
+    }
+
+    /* Now, just add "value" to "path". */
+
+    /* split pointer in parent and child */
+    parentptr = cJSONUtils_strdup(path->valuestring);
+    childptr = strrchr(parentptr, '/');
+    if (childptr)
+    {
+        *childptr++ = '\0';
+    }
+    parent = cJSONUtils_GetPointer(object, parentptr);
+    cJSONUtils_InplaceDecodePointerString(childptr);
+
+    /* add, remove, replace, move, copy, test. */
+    if (!parent)
+    {
+        /* Couldn't find object to add to. */
+        free(parentptr);
+        cJSON_Delete(value);
+        return 9;
+    }
+    else if ((parent->type & 0xFF) == cJSON_Array)
+    {
+        if (!strcmp(childptr, "-"))
+        {
+            cJSON_AddItemToArray(parent, value);
+        }
+        else
+        {
+            cJSON_InsertItemInArray(parent, atoi(childptr), value);
+        }
+    }
+    else if ((parent->type & 0xFF) == cJSON_Object)
+    {
+        cJSON_DeleteItemFromObject(parent, childptr);
+        cJSON_AddItemToObject(parent, childptr, value);
+    }
+    else
+    {
+        cJSON_Delete(value);
+    }
+    free(parentptr);
+
+    return 0;
+}
+
+int cJSONUtils_ApplyPatches(cJSON *object, cJSON *patches)
+{
+    int err = 0;
+    if ((patches->type & 0xFF) != cJSON_Array)
+    {
+        /* malformed patches. */
+        return 1;
+    }
+    if (patches)
+    {
+        patches = patches->child;
+    }
+    while (patches)
+    {
+        if ((err = cJSONUtils_ApplyPatch(object, patches)))
+        {
+            return err;
+        }
+        patches = patches->next;
+    }
+
+    return 0;
+}
+
+static void cJSONUtils_GeneratePatch(cJSON *patches, const char *op, const char *path, const char *suffix, cJSON *val)
+{
+    cJSON *patch = cJSON_CreateObject();
+    cJSON_AddItemToObject(patch, "op", cJSON_CreateString(op));
+    if (suffix)
+    {
+        char *newpath = (char*)malloc(strlen(path) + cJSONUtils_PointerEncodedstrlen(suffix) + 2);
+        cJSONUtils_PointerEncodedstrcpy(newpath + sprintf(newpath, "%s/", path), suffix);
+        cJSON_AddItemToObject(patch, "path", cJSON_CreateString(newpath));
+        free(newpath);
+    }
+    else
+    {
+        cJSON_AddItemToObject(patch, "path", cJSON_CreateString(path));
+    }
+    if (val)
+    {
+        cJSON_AddItemToObject(patch, "value", cJSON_Duplicate(val, 1));
+    }
+    cJSON_AddItemToArray(patches, patch);
+}
+
+void cJSONUtils_AddPatchToArray(cJSON *array, const char *op, const char *path, cJSON *val)
+{
+    cJSONUtils_GeneratePatch(array, op, path, 0, val);
+}
+
+static void cJSONUtils_CompareToPatch(cJSON *patches, const char *path, cJSON *from, cJSON *to)
+{
+    if ((from->type & 0xFF) != (to->type & 0xFF))
+    {
+        cJSONUtils_GeneratePatch(patches, "replace", path, 0, to);
+        return;
+    }
+
+    switch ((from->type & 0xFF))
+    {
+        case cJSON_Number:
+            if ((from->valueint != to->valueint) || (from->valuedouble != to->valuedouble))
+            {
+                cJSONUtils_GeneratePatch(patches, "replace", path, 0, to);
+            }
+            return;
+
+        case cJSON_String:
+            if (strcmp(from->valuestring, to->valuestring) != 0)
+            {
+                cJSONUtils_GeneratePatch(patches, "replace", path, 0, to);
+            }
+            return;
+
+        case cJSON_Array:
+        {
+            int c = 0;
+            char *newpath = (char*)malloc(strlen(path) + 23); /* Allow space for 64bit int. */
+            /* generate patches for all array elements that exist in "from" and "to" */
+            for (c = 0, from = from->child, to = to->child; from && to; from = from->next, to = to->next, c++)
+            {
+                sprintf(newpath, "%s/%d", path, c); /* path of the current array element */
+                cJSONUtils_CompareToPatch(patches, newpath, from, to);
+            }
+            /* remove leftover elements from 'from' that are not in 'to' */
+            for (; from; from = from->next, c++)
+            {
+                sprintf(newpath, "%d", c);
+                cJSONUtils_GeneratePatch(patches, "remove", path, newpath, 0);
+            }
+            /* add new elements in 'to' that were not in 'from' */
+            for (; to; to = to->next, c++)
+            {
+                cJSONUtils_GeneratePatch(patches, "add", path, "-", to);
+            }
+            free(newpath);
+            return;
+        }
+
+        case cJSON_Object:
+        {
+            cJSON *a = NULL;
+            cJSON *b = NULL;
+            cJSONUtils_SortObject(from);
+            cJSONUtils_SortObject(to);
+
+            a = from->child;
+            b = to->child;
+            /* for all object values in the object with more of them */
+            while (a || b)
+            {
+                int diff = (!a) ? 1 : ((!b) ? -1 : cJSONUtils_strcasecmp(a->string, b->string));
+                if (!diff)
+                {
+                    /* both object keys are the same */
+                    char *newpath = (char*)malloc(strlen(path) + cJSONUtils_PointerEncodedstrlen(a->string) + 2);
+                    cJSONUtils_PointerEncodedstrcpy(newpath + sprintf(newpath, "%s/", path), a->string);
+                    /* create a patch for the element */
+                    cJSONUtils_CompareToPatch(patches, newpath, a, b);
+                    free(newpath);
+                    a = a->next;
+                    b = b->next;
+                }
+                else if (diff < 0)
+                {
+                    /* object element doesn't exist in 'to' --> remove it */
+                    cJSONUtils_GeneratePatch(patches, "remove", path, a->string, 0);
+                    a = a->next;
+                }
+                else
+                {
+                    /* object element doesn't exist in 'from' --> add it */
+                    cJSONUtils_GeneratePatch(patches, "add", path, b->string, b);
+                    b = b->next;
+                }
+            }
+            return;
+        }
+
+        default:
+            break;
+    }
+}
+
+cJSON* cJSONUtils_GeneratePatches(cJSON *from, cJSON *to)
+{
+    cJSON *patches = cJSON_CreateArray();
+    cJSONUtils_CompareToPatch(patches, "", from, to);
+
+    return patches;
+}
+
+/* sort lists using mergesort */
+static cJSON *cJSONUtils_SortList(cJSON *list)
+{
+    cJSON *first = list;
+    cJSON *second = list;
+    cJSON *ptr = list;
+
+    if (!list || !list->next)
+    {
+        /* One entry is sorted already. */
+        return list;
+    }
+
+    while (ptr && ptr->next && (cJSONUtils_strcasecmp(ptr->string, ptr->next->string) < 0))
+    {
+        /* Test for list sorted. */
+        ptr = ptr->next;
+    }
+    if (!ptr || !ptr->next)
+    {
+        /* Leave sorted lists unmodified. */
+        return list;
+    }
+
+    /* reset ptr to the beginning */
+    ptr = list;
+    while (ptr)
+    {
+        /* Walk two pointers to find the middle. */
+        second = second->next;
+        ptr = ptr->next;
+        /* advances ptr two steps at a time */
+        if (ptr)
+        {
+            ptr = ptr->next;
+        }
+    }
+    if (second && second->prev)
+    {
+        /* Split the lists */
+        second->prev->next = NULL;
+    }
+
+    /* Recursively sort the sub-lists. */
+    first = cJSONUtils_SortList(first);
+    second = cJSONUtils_SortList(second);
+    list = ptr = NULL;
+
+    while (first && second) /* Merge the sub-lists */
+    {
+        if (cJSONUtils_strcasecmp(first->string, second->string) < 0)
+        {
+            if (!list)
+            {
+                /* start merged list with the first element of the first list */
+                list = ptr = first;
+            }
+            else
+            {
+                /* add first element of first list to merged list */
+                ptr->next = first;
+                first->prev = ptr;
+                ptr = first;
+            }
+            first = first->next;
+        }
+        else
+        {
+            if (!list)
+            {
+                /* start merged list with the first element of the second list */
+                list = ptr = second;
+            }
+            else
+            {
+                /* add first element of second list to merged list */
+                ptr->next = second;
+                second->prev = ptr;
+                ptr = second;
+            }
+            second = second->next;
+        }
+    }
+    if (first)
+    {
+        /* Append rest of first list. */
+        if (!list)
+        {
+            return first;
+        }
+        ptr->next = first;
+        first->prev = ptr;
+    }
+    if (second)
+    {
+        /* Append rest of second list */
+        if (!list)
+        {
+            return second;
+        }
+        ptr->next = second;
+        second->prev = ptr;
+    }
+
+    return list;
+}
+
+void cJSONUtils_SortObject(cJSON *object)
+{
+    object->child = cJSONUtils_SortList(object->child);
+}
+
+cJSON* cJSONUtils_MergePatch(cJSON *target, cJSON *patch)
+{
+    if (!patch || ((patch->type & 0xFF) != cJSON_Object))
+    {
+        /* scalar value, array or NULL, just duplicate */
+        cJSON_Delete(target);
+        return cJSON_Duplicate(patch, 1);
+    }
+
+    if (!target || ((target->type & 0xFF) != cJSON_Object))
+    {
+        cJSON_Delete(target);
+        target = cJSON_CreateObject();
+    }
+
+    patch = patch->child;
+    while (patch)
+    {
+        if ((patch->type & 0xFF) == cJSON_NULL)
+        {
+            /* NULL is the indicator to remove a value, see RFC7396 */
+            cJSON_DeleteItemFromObject(target, patch->string);
+        }
+        else
+        {
+            cJSON *replaceme = cJSON_DetachItemFromObject(target, patch->string);
+            cJSON_AddItemToObject(target, patch->string, cJSONUtils_MergePatch(replaceme, patch));
+        }
+        patch = patch->next;
+    }
+    return target;
+}
+
+cJSON *cJSONUtils_GenerateMergePatch(cJSON *from, cJSON *to)
+{
+    cJSON *patch = NULL;
+    if (!to)
+    {
+        /* patch to delete everything */
+        return cJSON_CreateNull();
+    }
+    if (((to->type & 0xFF) != cJSON_Object) || !from || ((from->type & 0xFF) != cJSON_Object))
+    {
+        return cJSON_Duplicate(to, 1);
+    }
+
+    cJSONUtils_SortObject(from);
+    cJSONUtils_SortObject(to);
+
+    from = from->child;
+    to = to->child;
+    patch = cJSON_CreateObject();
+    while (from || to)
+    {
+        int compare = from ? (to ? strcmp(from->string, to->string) : -1) : 1;
+        if (compare < 0)
+        {
+            /* from has a value that to doesn't have -> remove */
+            cJSON_AddItemToObject(patch, from->string, cJSON_CreateNull());
+            from = from->next;
+        }
+        else if (compare > 0)
+        {
+            /* to has a value that from doesn't have -> add to patch */
+            cJSON_AddItemToObject(patch, to->string, cJSON_Duplicate(to, 1));
+            to = to->next;
+        }
+        else
+        {
+            /* object key exists in both objects */
+            if (cJSONUtils_Compare(from, to))
+            {
+                /* not identical --> generate a patch */
+                cJSON_AddItemToObject(patch, to->string, cJSONUtils_GenerateMergePatch(from, to));
+            }
+            /* next key in the object */
+            from = from->next;
+            to = to->next;
+        }
+    }
+    if (!patch->child)
+    {
+        cJSON_Delete(patch);
+        return NULL;
+    }
+
+    return patch;
+}

Living_SDK/utility/cjson/cJSON_Utils.h

@@ -0,0 +1,44 @@
+#include "cJSON.h"
+
+/* Implement RFC6901 (https://tools.ietf.org/html/rfc6901) JSON Pointer spec. */
+cJSON *cJSONUtils_GetPointer(cJSON *object, const char *pointer);
+
+/* Implement RFC6902 (https://tools.ietf.org/html/rfc6902) JSON Patch spec. */
+cJSON* cJSONUtils_GeneratePatches(cJSON *from, cJSON *to);
+/* Utility for generating patch array entries. */
+void cJSONUtils_AddPatchToArray(cJSON *array, const char *op, const char *path, cJSON *val);
+/* Returns 0 for success. */
+int cJSONUtils_ApplyPatches(cJSON *object, cJSON *patches);
+
+/*
+// Note that ApplyPatches is NOT atomic on failure. To implement an atomic ApplyPatches, use:
+//int cJSONUtils_AtomicApplyPatches(cJSON **object, cJSON *patches)
+//{
+//    cJSON *modme = cJSON_Duplicate(*object, 1);
+//    int error = cJSONUtils_ApplyPatches(modme, patches);
+//    if (!error)
+//    {
+//        cJSON_Delete(*object);
+//        *object = modme;
+//    }
+//    else
+//    {
+//        cJSON_Delete(modme);
+//    }
+//
+//    return error;
+//}
+// Code not added to library since this strategy is a LOT slower.
+*/
+
+/* Implement RFC7386 (https://tools.ietf.org/html/rfc7396) JSON Merge Patch spec. */
+/* target will be modified by patch. return value is new ptr for target. */
+cJSON* cJSONUtils_MergePatch(cJSON *target, cJSON *patch);
+/* generates a patch to move from -> to */
+cJSON *cJSONUtils_GenerateMergePatch(cJSON *from, cJSON *to);
+
+/* Given a root object and a target object, construct a pointer from one to the other. */
+char *cJSONUtils_FindPointerFromObjectTo(cJSON *object, cJSON *target);
+
+/* Sorts the members of the object into alphabetical order. */
+void cJSONUtils_SortObject(cJSON *object);

Living_SDK/utility/cjson/cjson.mk

@@ -0,0 +1,8 @@
+NAME := cjson
+
+$(NAME)_TYPE := share
+GLOBAL_INCLUDES += include
+# don't modify to L_CFLAGS, because CONFIG_CJSON_WITHOUT_DOUBLE should enable global
+#$(NAME)_CFLAGS  += -DCONFIG_CJSON_WITHOUT_DOUBLE
+
+$(NAME)_SOURCES := cJSON.c cJSON_Utils.c

Living_SDK/utility/cjson/include/cJSON.h

@@ -0,0 +1,268 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  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.
+*/
+
+#ifndef cJSON__h
+#define cJSON__h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* project version */
+#define CJSON_VERSION_MAJOR 1
+#define CJSON_VERSION_MINOR 6
+#define CJSON_VERSION_PATCH 0
+
+#include <stddef.h>
+
+/* cJSON Types: */
+#define cJSON_Invalid (0)
+#define cJSON_False  (1 << 0)
+#define cJSON_True   (1 << 1)
+#define cJSON_NULL   (1 << 2)
+#define cJSON_Number (1 << 3)
+#define cJSON_String (1 << 4)
+#define cJSON_Array  (1 << 5)
+#define cJSON_Object (1 << 6)
+#define cJSON_Raw    (1 << 7) /* raw json */
+
+#define cJSON_IsReference 256
+#define cJSON_StringIsConst 512
+
+/* The cJSON structure: */
+typedef struct cJSON {
+    /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+    struct cJSON* next;
+    struct cJSON* prev;
+    /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+    struct cJSON* child;
+
+    /* The type of the item, as above. */
+    int type;
+
+    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    char* valuestring;
+#ifdef CJSON_STRING_ZEROCOPY
+    size_t valuestring_length;
+#endif
+    /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
+    int valueint;
+
+    /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+    char* string;
+#ifdef CJSON_STRING_ZEROCOPY
+    size_t string_length;
+#endif
+    /* The item's number, if type==cJSON_Number */
+    double valuedouble;
+} cJSON;
+
+typedef struct cJSON_Hooks {
+    void* (*malloc_fn)(size_t sz);
+    void (*free_fn)(void* ptr);
+} cJSON_Hooks;
+
+typedef int cJSON_bool;
+
+#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
+#define __WINDOWS__
+#endif
+#ifdef __WINDOWS__
+
+/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention.  For windows you have 2 define options:
+
+CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
+CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
+CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
+
+For *nix builds that support visibility attribute, you can define similar behavior by
+
+setting default visibility to hidden by adding
+-fvisibility=hidden (for gcc)
+or
+-xldscope=hidden (for sun cc)
+to CFLAGS
+
+then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
+
+*/
+
+/* export symbols by default, this is necessary for copy pasting the C and header file */
+#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_EXPORT_SYMBOLS
+#endif
+
+#if defined(CJSON_HIDE_SYMBOLS)
+#define CJSON_PUBLIC(type)   type __stdcall
+#elif defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllexport) type __stdcall
+#elif defined(CJSON_IMPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllimport) type __stdcall
+#endif
+#else /* !WIN32 */
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
+#define CJSON_PUBLIC(type)   __attribute__((visibility("default"))) type
+#else
+#define CJSON_PUBLIC(type) type
+#endif
+#endif
+
+/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_NESTING_LIMIT
+#define CJSON_NESTING_LIMIT 1000
+#endif
+
+/* returns the version of cJSON as a string */
+CJSON_PUBLIC(const char*) cJSON_Version(void);
+
+/* Supply malloc, realloc and free functions to cJSON */
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);
+
+/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
+/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
+CJSON_PUBLIC(cJSON*) cJSON_Parse(const char* value);
+/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
+/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
+CJSON_PUBLIC(cJSON*) cJSON_ParseWithOpts(const char* value, const char** return_parse_end,
+        cJSON_bool require_null_terminated);
+
+/* Render a cJSON entity to text for transfer/storage. */
+CJSON_PUBLIC(char*) cJSON_Print(const cJSON* item);
+/* Render a cJSON entity to text for transfer/storage without any formatting. */
+CJSON_PUBLIC(char*) cJSON_PrintUnformatted(const cJSON* item);
+/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
+CJSON_PUBLIC(char*) cJSON_PrintBuffered(const cJSON* item, int prebuffer, cJSON_bool fmt);
+/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
+/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON* item, char* buffer, const int length, const cJSON_bool format);
+/* Delete a cJSON entity and all subentities. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON* c);
+
+/* Returns the number of items in an array (or object). */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON* array);
+/* Retrieve item number "item" from array "array". Returns NULL if unsuccessful. */
+CJSON_PUBLIC(cJSON*) cJSON_GetArrayItem(const cJSON* array, int index);
+/* Get item "string" from object. Case insensitive. */
+CJSON_PUBLIC(cJSON*) cJSON_GetObjectItem(const cJSON* const object, const char* const string);
+CJSON_PUBLIC(cJSON*) cJSON_GetObjectItemCaseSensitive(const cJSON* const object, const char* const string);
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON* object, const char* string);
+/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
+CJSON_PUBLIC(const char*) cJSON_GetErrorPtr(void);
+
+/* These functions check the type of an item */
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON* const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON* const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON* const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON* const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON* const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON* const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON* const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON* const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON* const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON* const item);
+
+/* These calls create a cJSON item of the appropriate type. */
+CJSON_PUBLIC(cJSON*) cJSON_CreateNull(void);
+CJSON_PUBLIC(cJSON*) cJSON_CreateTrue(void);
+CJSON_PUBLIC(cJSON*) cJSON_CreateFalse(void);
+CJSON_PUBLIC(cJSON*) cJSON_CreateBool(cJSON_bool boolean);
+CJSON_PUBLIC(cJSON*) cJSON_CreateNumber(double num);
+CJSON_PUBLIC(cJSON*) cJSON_CreateString(const char* string);
+/* raw json */
+CJSON_PUBLIC(cJSON*) cJSON_CreateRaw(const char* raw);
+CJSON_PUBLIC(cJSON*) cJSON_CreateArray(void);
+CJSON_PUBLIC(cJSON*) cJSON_CreateObject(void);
+
+/* These utilities create an Array of count items. */
+CJSON_PUBLIC(cJSON*) cJSON_CreateIntArray(const int* numbers, int count);
+CJSON_PUBLIC(cJSON*) cJSON_CreateFloatArray(const float* numbers, int count);
+CJSON_PUBLIC(cJSON*) cJSON_CreateDoubleArray(const double* numbers, int count);
+CJSON_PUBLIC(cJSON*) cJSON_CreateStringArray(const char** strings, int count);
+
+/* Append item to the specified array/object. */
+CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON* array, cJSON* item);
+CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON* object, const char* string, cJSON* item);
+/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
+ * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
+ * writing to `item->string` */
+CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON* object, const char* string, cJSON* item);
+/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
+CJSON_PUBLIC(void) cJSON_AddItemReferenceToArray(cJSON* array, cJSON* item);
+CJSON_PUBLIC(void) cJSON_AddItemReferenceToObject(cJSON* object, const char* string, cJSON* item);
+
+/* Remove/Detatch items from Arrays/Objects. */
+CJSON_PUBLIC(cJSON*) cJSON_DetachItemViaPointer(cJSON* parent, cJSON* const item);
+CJSON_PUBLIC(cJSON*) cJSON_DetachItemFromArray(cJSON* array, int which);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON* array, int which);
+CJSON_PUBLIC(cJSON*) cJSON_DetachItemFromObject(cJSON* object, const char* string);
+CJSON_PUBLIC(cJSON*) cJSON_DetachItemFromObjectCaseSensitive(cJSON* object, const char* string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON* object, const char* string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON* object, const char* string);
+
+/* Update array items. */
+CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON* array, int which,
+        cJSON* newitem); /* Shifts pre-existing items to the right. */
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON* const parent, cJSON* const item, cJSON* replacement);
+CJSON_PUBLIC(void) cJSON_ReplaceItemInArray(cJSON* array, int which, cJSON* newitem);
+CJSON_PUBLIC(void) cJSON_ReplaceItemInObject(cJSON* object, const char* string, cJSON* newitem);
+CJSON_PUBLIC(void) cJSON_ReplaceItemInObjectCaseSensitive(cJSON* object, const char* string, cJSON* newitem);
+
+/* Duplicate a cJSON item */
+CJSON_PUBLIC(cJSON*) cJSON_Duplicate(const cJSON* item, cJSON_bool recurse);
+/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
+need to be released. With recurse!=0, it will duplicate any children connected to the item.
+The item->next and ->prev pointers are always zero on return from Duplicate. */
+/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
+ * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON* const a, const cJSON* const b, const cJSON_bool case_sensitive);
+
+
+CJSON_PUBLIC(void) cJSON_Minify(char* json);
+
+/* Macros for creating things quickly. */
+#define cJSON_AddNullToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateNull())
+#define cJSON_AddTrueToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateTrue())
+#define cJSON_AddFalseToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateFalse())
+#define cJSON_AddBoolToObject(object,name,b) cJSON_AddItemToObject(object, name, cJSON_CreateBool(b))
+#define cJSON_AddNumberToObject(object,name,n) cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))
+#define cJSON_AddStringToObject(object,name,s) cJSON_AddItemToObject(object, name, cJSON_CreateString(s))
+#define cJSON_AddRawToObject(object,name,s) cJSON_AddItemToObject(object, name, cJSON_CreateRaw(s))
+
+/* When assigning an integer value, it needs to be propagated to valuedouble too. */
+#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
+/* helper for the cJSON_SetNumberValue macro */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON* object, double number);
+#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
+
+/* Macro for iterating over an array or object */
+#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
+
+/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
+CJSON_PUBLIC(void*) cJSON_malloc(size_t size);
+CJSON_PUBLIC(void) cJSON_free(void* object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

Living_SDK/utility/cjson/ucube.py

@@ -0,0 +1,9 @@
+src = Split('''
+    cJSON.c 
+    cJSON_Utils.c
+''')
+component = aos_component('cjson', src)
+
+component.add_global_includes('include')
+
+