【cJSON】 源码解析

关于cjson的介绍和使用方法就不在这里介绍了，详情请查看上一篇博客cjson使用方法。

JSON的内存结构像广义表，可以认为是有层次的双向链表。

 

cJSON程序中的细节点如下：

  • 大量宏替换
  • 大量静态函数
  • 错误处理机制
  • 字符串处理时存在utf16转utf9，编码转换
  • 用函数指针封装malloc，free，方便用于处理，比如在申请后初始化，或者释放前进行一些处理等。

cJSON中的重要接口函数如下：

 

解析函数
cJSON * cJSON_Parse(const char *value);
打印函数
char * cJSON_Print(cJSON * item);
删除函数
void  cJSON_Delete(cJSON * c);
构造函数
create系列和add系列
解析字符串
char *parse_string(cJSON*item,const char *str)
解析数字
char *parse_number(cJSON *item,const char *num)
解析数组
char *parse_array(cJSON *item,const char *value)
解析对象
char *parse_object(cJSON *item,const char *value)
......

 

cjosn有两个相关的文件，一个cJSON.c和cJSON.h。我们先从头文件开始分析。

首先，我们会看到头文件的开头和结尾这样的语句：

 

  1. #ifndef cJSON__h  
  2. #define cJSON__h  
  3.   
  4. #ifdef __cplusplus  
  5. extern "C"  
  6. {  
  7. #endif 

...

...

  1. #ifdef __cplusplus  
  2. }  
  3. #endif  
  4.   
  5. #endif  




#ifndef cJSON_h,#define cJSON_h,#endif . 这是为了防止头文件被重复引用。

extern "C"的主要作用就是为了能够正确实现C++代码调用其他C语言代码。加上extern "C"后，会指示编译器这部分代码按C语言的进行编译，而不是C++的。由于C++支持函数重载，因此编译器编译函数的过程中会将函数的参数类型也加到编译后的代码中，而不仅仅是函数名；而C语言并不支持函数重载，因此编译C语言代码的函数时不会带上函数的参数类型，一般之包括函数名。


接着往下看，就会看到cjson的结构体的定义，cjson对象存储结构实际是一个结构体。

  1. // JSON的一个value的结构体  
  2. typedef struct cJSON  
  3. {  
  4.     struct cJSON *next,*prev;    // 同一级的元素使用双向列表存储  
  5.     struct cJSON *child;           // 如果是一个object或array的话，child为第一个儿子的指针  
  6.   
  7.     int type;                            // value的类型  
  8.   
  9.     char *valuestring;             // 如果这个value是字符串类型，则此处为字符串值  
  10.     int valueint;                      // 如果是数字的话，整数值  
  11.     double valuedouble;            // 如果是数字的话，读点数值  
  12.   
  13.     char *string;                      // json对象的名称  
  14. } cJSON;  






前面提到过，cjson的存储结构像一个广义表，其实也可以说是一个树，不过兄弟结点之间都通过prev和next两个指针连接起来。

prev和next分别是cjson对象的前驱和后继，属于同一级别的对象。chid则指向孩子结点，并且是第一个孩子的指针。


示例图如下：



cjson的类型宏定义：

  1. /* cJSON Types: */  
  2. #define cJSON_False  (1 << 0)  
  3. #define cJSON_True   (1 << 1)  
  4. #define cJSON_NULL   (1 << 2)  
  5. #define cJSON_Number (1 << 3)  
  6. #define cJSON_String (1 << 4)  
  7. #define cJSON_Array  (1 << 5)  
  8. #define cJSON_Object (1 << 6)  
  9.       
  10. #define cJSON_IsReference 256  
  11. #define cJSON_StringIsConst 512  


这些宏定义是对结构体type的值定义，处理时只需要将type的值&255进行位运算，即可得到json里储存的数据类型。


cjson的创建：

cjson的创建的过程就是创建一个cjson结构体，再通过add一系列函数将其他孩子结点数据或同等级结点加入，将相关结点通过指针链起来。

cjson_create一系列函数:cJSON_CreateArray(),cJSON_CreateObject(),cJSON_CreateString()等函数，都是调用cJSON_New_Item()函数创建对应节点信息。函数返回一个json结构体指针。

相关函数如下:

  1. static cJSON *cJSON_New_Item(void)   //创建json结构体  
  2. {  
  3.     cJSON *node = (cJSON *) cJSON_malloc(sizeof(cJSON));  
  4.   
  5.     if (node)  
  6.         memset(node, 0, sizeof(cJSON));   //初始化结构体  
  7.     return node;  
  8. }  
  9. cJSON *cJSON_CreateNull(void)  
  10. {  
  11.     cJSON *item = cJSON_New_Item();  
  12.   
  13.     if (item)  
  14.         item->type = cJSON_NULL;  
  15.     return item;  
  16. }  
  17.   
  18. cJSON *cJSON_CreateTrue(void)  
  19. {  
  20.     cJSON *item = cJSON_New_Item();  
  21.   
  22.     if (item)  
  23.         item->type = cJSON_True;  
  24.     return item;  
  25. }  
  26.   
  27. cJSON *cJSON_CreateFalse(void)  
  28. {  
  29.     cJSON *item = cJSON_New_Item();  
  30.   
  31.     if (item)  
  32.         item->type = cJSON_False;  
  33.     return item;  
  34. }  
  35.   
  36. cJSON *cJSON_CreateBool(int b)  
  37. {  
  38.     cJSON *item = cJSON_New_Item();  
  39.   
  40.     if (item)  
  41.         item->type = b ? cJSON_True : cJSON_False;  
  42.     return item;  
  43. }  
  44.   
  45. cJSON *cJSON_CreateNumber(double num)  
  46. {  
  47.     cJSON *item = cJSON_New_Item();  
  48.   
  49.     if (item) {  
  50.         item->type = cJSON_Number;  
  51.         item->valuedouble = num;  
  52.         item->valueint = (int) num;  
  53.     }  
  54.     return item;  
  55. }  
  56.   
  57. cJSON *cJSON_CreateString(const char *string)  
  58. {  
  59.     cJSON *item = cJSON_New_Item();  
  60.   
  61.     if (item) {  
  62.         item->type = cJSON_String;  
  63.         item->valuestring = cJSON_strdup(string);  
  64.     }  
  65.     return item;  
  66. }  
  67.   
  68. cJSON *cJSON_CreateArray(void)  
  69. {  
  70.     cJSON *item = cJSON_New_Item();  
  71.   
  72.     if (item)  
  73.         item->type = cJSON_Array;  
  74.     return item;  
  75. }  
  76.   
  77. cJSON *cJSON_CreateObject(void)  
  78. {  
  79.     cJSON *item = cJSON_New_Item();  
  80.   
  81.     if (item)  
  82.         item->type = cJSON_Object;  
  83.     return item;  
  84. }  


创建完一个根结点结构体后，接下来就是向根结点中加入元素。

从头文件我们发现，

  • // 创建一个string值为name的cJSON_Null节点，并添加到object  
  • #define cJSON_AddNullToObject(object,name)      cJSON_AddItemToObject(object, name, cJSON_CreateNull())  
  • // 创建一个string值为name的cJSON_True节点，并添加到object  
  • #define cJSON_AddTrueToObject(object,name)      cJSON_AddItemToObject(object, name, cJSON_CreateTrue())  
  • // 创建一个string值为name的cJSON_False节点，并添加到object  
  • #define cJSON_AddFalseToObject(object,name)     cJSON_AddItemToObject(object, name, cJSON_CreateFalse())  
  • // 创建一个string值为name的cJSON_CreateBool节点，并添加到object。b非0为cJSON_True，0为cJSON_False。  
  • #define cJSON_AddBoolToObject(object,name,b)    cJSON_AddItemToObject(object, name, cJSON_CreateBool(b))  
  • // 创建一个string值为name，valuedouble为n，valueint为（int）n的cJSON_Number节点，并添加到object。  
  • #define cJSON_AddNumberToObject(object,name,n)  cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))  
  • // 创建一个string值为name，valuestring为s的cJSON_String节点，并添加到object。  
  • #define cJSON_AddStringToObject(object,name,s)  cJSON_AddItemToObject(object, name, cJSON_CreateString(s))  


过程是调用cJSON_AddItemToObject()并结合不同的对象类型增加节点名称和子节点。然后在其中调用cJSON_AddItemToArray()函数来添加信息，此函数中判断对象孩子结点是否为NULL，如果是NULL，则直接插入，否则找到最后一个孩子，调用suffix_object()函数添加到双向链表的尾部。

示例图如下:



相关代码如下:

  1. // 将字符串添加进对象  
  2. void cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item)  
  3. {  
  4.     if (!item)  
  5.      return;  
  6.     if (item->string)  
  7.         cJSON_free(item->string);         // 这个儿子之前有key，先清理  
  8.     item->string=cJSON_strdup(string);    // 设置key值  
  9.     cJSON_AddItemToArray(object,item);    // 添加儿子  
  10. }  
  11.   
  12. // 将传入的字符串复制一副本并返回新的字符串指针  
  13. static char* cJSON_strdup(const char* str)  
  14. {  
  15.       size_t len;  
  16.       char* copy;  
  17.   
  18.       len = strlen(str) + 1;  
  19.             // 分配空间  
  20.       if (!(copy = (char*)cJSON_malloc(len)))  
  21.                 return 0;  
  22.             // 执行复制操作  
  23.       memcpy(copy,str,len);  
  24.             // 返回复制的副本  
  25.       return copy;  
  26. }  
  27.   
  28. // 添加节点到object或array中  
  29. void cJSON_AddItemToArray(cJSON *array, cJSON *item)  
  30. {  
  31.     cJSON *c=array->child;  
  32.     if (!item)  
  33.         return;  
  34.     if (!c)  
  35.     {  
  36.         array->child=item;     // 之前不存在儿子节点，直接添加  
  37.     }  
  38.     else  
  39.     {  
  40.         while (c && c->next)   // 先找到最后一个儿子  
  41.             c=c->next;  
  42.         suffix_object(c,item); // 添加儿子，c是item的兄弟节点  
  43.     }  
  44. }  
  45.   
  46. // array的处理  
  47. static void suffix_object(cJSON *prev,cJSON *item)  
  48. {  
  49.     // 两个兄弟的指针互相指向对方  
  50.     prev->next=item;  
  51.     item->prev=prev;  
  52. }  

cjson打印：

cjson打印就是从根对象的结构体开始遍历，得到每个item结点的名称和数据，并经过处理成特定的cjson字符串的输出形式。

cJSON_Print(root)和cJSON_PrintUnformatted(root) 函数都是打印成json字符串的函数，两者的区别就是

cJSON_PrintUnformatted(root) 处理成的字符串里没有\t\n这类的格式，我们在这里以分析cJSON_Print(root)函数

为例，进行分析。


相关函数结构图如下：




相关函数如下：

  1. typedef struct {  
  2.     char *buffer;  
  3.     int length;  
  4.     int offset;  
  5. } printbuffer;  
  6.   
  7.   
  8.   
  9. static int pow2gt(int x)        /*返回 一个比x的n(其中n是2的幂),并且是最小的幂，说白了就是将一个数后边所有的位都置1然后再+1*/  
  10. {  
  11.     --x;  
  12.     x |= x >> 1;  
  13.     x |= x >> 2;  
  14.     x |= x >> 4;  
  15.     x |= x >> 8;  
  16.     x |= x >> 16;  
  17.     return x + 1;  
  18. }  
  19.   
  20. /* ensure 函数 是一个 协助 printbuffer 分配内存的一个函数   
  21.  * len 表示当前字符串的字符串起始偏移量 即 newbuffer+p->offset 起始的 
  22.  */  
  23.   
  24. static char* ensure(printbuffer *p,int needed)  
  25. {  
  26.     char *newbuffer;int newsize;  
  27.     if (!p || !p->buffer) return 0;//传入参数合法性检测  
  28.     needed+=p->offset;//需要额外分配的内存 也就是偏移量  
  29.     if (needed<=p->length) return p->buffer+p->offset;//内存够用直接返回  
  30.     newsize=pow2gt(needed);  
  31.     newbuffer=(char*)cJSON_malloc(newsize);//malloc出新内存 放buffer里面的内容  
  32.     if (!newbuffer) {cJSON_free(p->buffer);p->length=0,p->buffer=0;return 0;}  
  33.     if (newbuffer) memcpy(newbuffer,p->buffer,p->length);//  
  34.     cJSON_free(p->buffer);//  
  35.     p->length=newsize;  
  36.     p->buffer=newbuffer;  
  37.     return newbuffer+p->offset;//  
  38. }  
  39.   
  40. char *cJSON_Print(cJSON * item)  
  41. {  
  42.     return print_value(item, 0, 1, 0);  
  43. }  
  44.   
  45. static char *print_value(cJSON * item, int depth, int fmt, printbuffer * p)  
  46. {  
  47.     char *out = 0;  
  48.   
  49.     if (!item)  
  50.         return 0;  
  51.     if (p) {  
  52.         switch ((item->type) & 255) {  
  53.         case cJSON_NULL:{  
  54.                 out = ensure(p, 5);  
  55.                 if (out)  
  56.                     strcpy(out, "null");  
  57.                 break;  
  58.             }  
  59.         case cJSON_False:{  
  60.                 out = ensure(p, 6);  
  61.                 if (out)  
  62.                     strcpy(out, "false");  
  63.                 break;  
  64.             }  
  65.         case cJSON_True:{  
  66.                 out = ensure(p, 5);  
  67.                 if (out)  
  68.                     strcpy(out, "true");  
  69.                 break;  
  70.             }  
  71.         case cJSON_Number:  
  72.             out = print_number(item, p);  //打印数字函数  
  73.             break;  
  74.         case cJSON_String:  
  75.             out = print_string(item, p);  //打印字符串函数  
  76.             break;  
  77.         case cJSON_Array:  
  78.             out = print_array(item, depth, fmt, p);  //打印数组函数  
  79.             break;  
  80.         case cJSON_Object:  
  81.             out = print_object(item, depth, fmt, p);  //打印object对象类型的函数  
  82.             break;  
  83.         }  
  84.     } else {  
  85.         switch ((item->type) & 255) {  
  86.         case cJSON_NULL:  
  87.             out = cJSON_strdup("null");  
  88.             break;  
  89.         case cJSON_False:  
  90.             out = cJSON_strdup("false");  
  91.             break;  
  92.         case cJSON_True:  
  93.             out = cJSON_strdup("true");  
  94.             break;  
  95.         case cJSON_Number:  
  96.             out = print_number(item, 0);  
  97.             break;  
  98.         case cJSON_String:  
  99.             out = print_string(item, 0);  
  100.             break;  
  101.         case cJSON_Array:  
  102.             out = print_array(item, depth, fmt, 0);  
  103.             break;  
  104.         case cJSON_Object:  
  105.             out = print_object(item, depth, fmt, 0);  
  106.             break;  
  107.         }  
  108.     }  
  109.     return out;  
  110. }  
  111.   
  112.   
  113. static char *print_number(cJSON * item, printbuffer * p)  //打印数字函数  
  114. {  
  115.     char *str = 0;  
  116.     double d = item->valuedouble;  
  117.   
  118.     if (d == 0) {  
  119.         if (p)  
  120.             str = ensure(p, 2);  
  121.         else  
  122.             str = (char *) cJSON_malloc(2); /* special case for 0. */  
  123.         if (str)  
  124.             strcpy(str, "0");  
  125.     } else if (fabs(((double) item->valueint) - d) <= DBL_EPSILON  
  126.            && d <= INT_MAX && d >= INT_MIN) {  
  127.         if (p)  
  128.             str = ensure(p, 21);  
  129.         else  
  130.             str = (char *) cJSON_malloc(21);    /* 2 ^ 64 + 1可以用21个字符表示 */  
  131.         if (str)  
  132.             sprintf(str, "%d", item->valueint);  
  133.     } else {  
  134.         if (p)  
  135.             str = ensure(p, 64);  
  136.         else  
  137.             str = (char *) cJSON_malloc(64);    /* This is a nice tradeoff. */  
  138.         if (str) {  
  139.             if (fpclassify(d) != FP_ZERO && !isnormal(d)) //非正常浮点数  
  140.                 sprintf(str, "null");  
  141.             else if (fabs(floor(d) - d) <= DBL_EPSILON  
  142.                  && fabs(d) < 1.0e60)  
  143.                 sprintf(str, "%.0f", d);  
  144.             else if (fabs(d) < 1.0e-6 || fabs(d) > 1.0e9)  
  145.                 sprintf(str, "%e", d);  
  146.             else  
  147.                 sprintf(str, "%f", d);  
  148.         }  
  149.     }  
  150.     return str;  
  151. }  
  152.   
  153.   
  154. static char *print_string(cJSON * item, printbuffer * p) //打印字符串类型的结点  
  155. {  
  156.     return print_string_ptr(item->valuestring, p);  
  157. }  
  158.   
  159. static char *print_string_ptr(const char *str, printbuffer * p)   //打印字符串类型的结点  
  160. {  
  161.     const char *ptr;  
  162.     char *ptr2, *out;  
  163.     int len = 0, flag = 0;  
  164.     unsigned char token;  
  165.   
  166.     if (!str) {  
  167.         if (p)  
  168.             out = ensure(p, 3);  
  169.         else  
  170.             out = (char *) cJSON_malloc(3);  
  171.         if (!out)  
  172.             return 0;  
  173.         strcpy(out, "\"\"");     //字符串为空  
  174.         return out;  
  175.     }  
  176.   
  177.     for (ptr = str; *ptr; ptr++)  
  178.         flag |= ((*ptr > 0 && *ptr < 32) || (*ptr == '\"')  
  179.              || (*ptr == '\\')) ? 1 : 0;  
  180.     if (!flag) {            //对字符串中不含'\','/'，空格等字符的字符处理  
  181.         len = ptr - str;  
  182.         if (p)  
  183.             out = ensure(p, len + 3);  
  184.         else  
  185.             out = (char *) cJSON_malloc(len + 3);  
  186.         if (!out)  
  187.             return 0;  
  188.         ptr2 = out;  
  189.         *ptr2++ = '\"';  
  190.         strcpy(ptr2, str);  
  191.         ptr2[len] = '\"';  
  192.         ptr2[len + 1] = 0;  
  193.         return out;  
  194.     }  
  195.   
  196.     ptr = str;  
  197.     while ((token = *ptr) && ++len) {  
  198.         if (strchr("\"\\\b\f\n\r\t", token))  
  199.             len++;  
  200.         else if (token < 32)  
  201.             len += 5;  
  202.         ptr++;  
  203.     }  
  204.   
  205.     if (p)  
  206.         out = ensure(p, len + 3);  
  207.     else  
  208.         out = (char *) cJSON_malloc(len + 3);  
  209.     if (!out)  
  210.         return 0;  
  211.   
  212.     ptr2 = out;  
  213.     ptr = str;  
  214.     *ptr2++ = '\"';  
  215.     while (*ptr) {  
  216.         if ((unsigned char) *ptr > 31 && *ptr != '\"'  
  217.             && *ptr != '\\')  
  218.             *ptr2++ = *ptr++;  
  219.         else {  
  220.             *ptr2++ = '\\';  
  221.             switch (token = *ptr++) {  
  222.             case '\\':  
  223.                 *ptr2++ = '\\';  
  224.                 break;  
  225.             case '\"':  
  226.                 *ptr2++ = '\"';  
  227.                 break;  
  228.             case '\b':  
  229.                 *ptr2++ = 'b';  
  230.                 break;  
  231.             case '\f':  
  232.                 *ptr2++ = 'f';  
  233.                 break;  
  234.             case '\n':  
  235.                 *ptr2++ = 'n';  
  236.                 break;  
  237.             case '\r':  
  238.                 *ptr2++ = 'r';  
  239.                 break;  
  240.             case '\t':  
  241.                 *ptr2++ = 't';  
  242.                 break;  
  243.             default:  
  244.                 sprintf(ptr2, "u%04x", token);  
  245.                 ptr2 += 5;  
  246.                 break;  /* escape and print */  
  247.             }  
  248.         }  
  249.     }  
  250.     *ptr2++ = '\"';  
  251.     *ptr2++ = 0;  
  252.     return out;  
  253. }  
  254.   
  255.   
  256. static char *print_array(cJSON * item, int depth, int fmt, printbuffer * p)   //打印数组类型结点函数  
  257. {  
  258.     char **entries;  
  259.     char *out = 0, *ptr, *ret;  
  260.     int len = 5;  
  261.     cJSON *child = item->child;  
  262.     int numentries = 0, i = 0, fail = 0;  
  263.     size_t tmplen = 0;  
  264.   
  265.     /* 数组里有多少个元素 */  
  266.     while (child)  
  267.         numentries++, child = child->next;  
  268.     /* 明确处理numentries = = 0 */   //处理空数组  
  269.     if (!numentries) {  
  270.         if (p)  
  271.             out = ensure(p, 3);  
  272.         else  
  273.             out = (char *) cJSON_malloc(3);  
  274.         if (out)  
  275.             strcpy(out, "[]");  
  276.         return out;  
  277.     }  
  278.   
  279.     if (p) {  
  280.         /* 组成数组的输出形式 */  
  281.         i = p->offset;  
  282.         ptr = ensure(p, 1);  
  283.         if (!ptr)  
  284.             return 0;  
  285.         *ptr = '[';  
  286.         p->offset++;  
  287.         child = item->child;  
  288.         while (child && !fail) {  
  289.             print_value(child, depth + 1, fmt, p);  
  290.             p->offset = update(p);  
  291.             if (child->next) {  
  292.                 len = fmt ? 2 : 1;  
  293.                 ptr = ensure(p, len + 1);  
  294.                 if (!ptr)  
  295.                     return 0;  
  296.                 *ptr++ = ',';  
  297.                 if (fmt)  
  298.                     *ptr++ = ' ';  
  299.                 *ptr = 0;  
  300.                 p->offset += len;  
  301.             }  
  302.             child = child->next;  
  303.         }  
  304.         ptr = ensure(p, 2);  
  305.         if (!ptr)  
  306.             return 0;  
  307.         *ptr++ = ']';  
  308.         *ptr = 0;  
  309.         out = (p->buffer) + i;  
  310.     } else {  
  311.         /* 分配一个指针数组存储数组里的每一个元素的打印结果 */  
  312.         entries =  
  313.             (char **) cJSON_malloc(numentries * sizeof(char *));  
  314.         if (!entries)  
  315.             return 0;  
  316.         memset(entries, 0, numentries * sizeof(char *));  
  317.         /* 检索所有结果: */  
  318.         child = item->child;  
  319.         while (child && !fail) {  
  320.             ret = print_value(child, depth + 1, fmt, 0);  
  321.             entries[i++] = ret;  
  322.             if (ret)  
  323.                 len += strlen(ret) + 2 + (fmt ? 1 : 0);  
  324.             else  
  325.                 fail = 1;  
  326.             child = child->next;  
  327.         }  
  328.   
  329.           
  330.         if (!fail)  
  331.             out = (char *) cJSON_malloc(len);  
  332.           
  333.         if (!out)  
  334.             fail = 1;  
  335.   
  336.       
  337.         if (fail) {  
  338.             for (i = 0; i < numentries; i++)  
  339.                 if (entries[i])  
  340.                     cJSON_free(entries[i]);  
  341.             cJSON_free(entries);  
  342.             return 0;  
  343.         }  
  344.   
  345.         /* 组成数组的输出形式. */  
  346.         *out = '[';  
  347.         ptr = out + 1;  
  348.         *ptr = 0;  
  349.         for (i = 0; i < numentries; i++) {  
  350.             tmplen = strlen(entries[i]);  
  351.             memcpy(ptr, entries[i], tmplen);  
  352.             ptr += tmplen;  
  353.             if (i != numentries - 1) {  
  354.                 *ptr++ = ',';  
  355.                 if (fmt)  
  356.                     *ptr++ = ' ';  
  357.                 *ptr = 0;  
  358.             }  
  359.             cJSON_free(entries[i]);  
  360.         }  
  361.         cJSON_free(entries);  
  362.         *ptr++ = ']';  
  363.         *ptr++ = 0;  
  364.     }  
  365.     return out;  
  366. }  
  367.   
  368. /* 打印object类型结点. */  
  369. static char *print_object(cJSON * item, int depth, int fmt,  printbuffer * p)  
  370. {  
  371.     char **entries = 0, **names = 0;  
  372.     char *out = 0, *ptr, *ret, *str;  
  373.     int len = 7, i = 0, j;  
  374.     cJSON *child = item->child;  
  375.     int numentries = 0, fail = 0;  
  376.     size_t tmplen = 0;  
  377.   
  378.     /* 统计有多少个子结点. */  
  379.     while (child)  
  380.         numentries++, child = child->next;  
  381.     /* 明确处理空对象的情况*/  
  382.     if (!numentries) {  
  383.         if (p)  
  384.             out = ensure(p, fmt ? depth + 4 : 3);  
  385.         else  
  386.             out = (char *) cJSON_malloc(fmt ? depth + 4 : 3);  
  387.         if (!out)  
  388.             return 0;  
  389.         ptr = out;  
  390.         *ptr++ = '{';  
  391.         if (fmt) {  
  392.             *ptr++ = '\n';  
  393.             for (i = 0; i < depth; i++)  
  394.                 *ptr++ = '\t';  
  395.         }  
  396.         *ptr++ = '}';  
  397.         *ptr++ = 0;  
  398.         return out;  
  399.     }  
  400.     if (p) {  
  401.         /* 组成输出形式: */  
  402.         i = p->offset;  
  403.         len = fmt ? 2 : 1;  
  404.         ptr = ensure(p, len + 1);  
  405.         if (!ptr)  
  406.             return 0;  
  407.         *ptr++ = '{';  
  408.         if (fmt)  
  409.             *ptr++ = '\n';  
  410.         *ptr = 0;  
  411.         p->offset += len;  
  412.         child = item->child;  
  413.         depth++;  
  414.         while (child) {  
  415.             if (fmt) {  
  416.                 ptr = ensure(p, depth);  
  417.                 if (!ptr)  
  418.                     return 0;  
  419.                 for (j = 0; j < depth; j++)  
  420.                     *ptr++ = '\t';  
  421.                 p->offset += depth;  
  422.             }  
  423.             print_string_ptr(child->string, p);  
  424.             p->offset = update(p);  
  425.   
  426.             len = fmt ? 2 : 1;  
  427.             ptr = ensure(p, len);  
  428.             if (!ptr)  
  429.                 return 0;  
  430.             *ptr++ = ':';  
  431.             if (fmt)  
  432.                 *ptr++ = '\t';  
  433.             p->offset += len;  
  434.   
  435.             print_value(child, depth, fmt, p);  
  436.             p->offset = update(p);  
  437.   
  438.             len = (fmt ? 1 : 0) + (child->next ? 1 : 0);  
  439.             ptr = ensure(p, len + 1);  
  440.             if (!ptr)  
  441.                 return 0;  
  442.             if (child->next)  
  443.                 *ptr++ = ',';  
  444.             if (fmt)  
  445.                 *ptr++ = '\n';  
  446.             *ptr = 0;  
  447.             p->offset += len;  
  448.             child = child->next;  
  449.         }  
  450.         ptr = ensure(p, fmt ? (depth + 1) : 2);  
  451.         if (!ptr)  
  452.             return 0;  
  453.         if (fmt)  
  454.             for (i = 0; i < depth - 1; i++)  
  455.                 *ptr++ = '\t';  
  456.         *ptr++ = '}';  
  457.         *ptr = 0;  
  458.         out = (p->buffer) + i;  
  459.     } else {  
  460.         /*为对象和名称分配空间 */  
  461.         entries =  
  462.             (char **) cJSON_malloc(numentries * sizeof(char *));  
  463.         if (!entries)  
  464.             return 0;  
  465.         names =  
  466.             (char **) cJSON_malloc(numentries * sizeof(char *));  
  467.         if (!names) {  
  468.             cJSON_free(entries);  
  469.             return 0;  
  470.         }  
  471.         memset(entries, 0, sizeof(char *) * numentries);  
  472.         memset(names, 0, sizeof(char *) * numentries);  
  473.   
  474.         /* 将所有结果收集到数组: */  
  475.         child = item->child;  
  476.         depth++;  
  477.         if (fmt)  
  478.             len += depth;  
  479.         while (child && !fail) {  
  480.             names[i] = str =  
  481.                 print_string_ptr(child->string, 0);  
  482.             entries[i++] = ret =  
  483.                 print_value(child, depth, fmt, 0);  
  484.             if (str && ret)  
  485.                 len +=  
  486.                     strlen(ret) + strlen(str) + 2 +  
  487.                     (fmt ? 2 + depth : 0);  
  488.             else  
  489.                 fail = 1;  
  490.             child = child->next;  
  491.         }  
  492.   
  493.   
  494.         if (!fail)  
  495.             out = (char *) cJSON_malloc(len);  
  496.         if (!out)  
  497.             fail = 1;  
  498.   
  499.       
  500.         if (fail) {  
  501.             for (i = 0; i < numentries; i++) {  
  502.                 if (names[i])  
  503.                     cJSON_free(names[i]);  
  504.                 if (entries[i])  
  505.                     cJSON_free(entries[i]);  
  506.             }  
  507.             cJSON_free(names);  
  508.             cJSON_free(entries);  
  509.             return 0;  
  510.         }  
  511.   
  512.         /* 组成输出形式: */  
  513.         *out = '{';  
  514.         ptr = out + 1;  
  515.         if (fmt)  
  516.             *ptr++ = '\n';  
  517.         *ptr = 0;  
  518.         for (i = 0; i < numentries; i++) {  
  519.             if (fmt)  
  520.                 for (j = 0; j < depth; j++)  
  521.                     *ptr++ = '\t';  
  522.             tmplen = strlen(names[i]);  
  523.             memcpy(ptr, names[i], tmplen);  
  524.             ptr += tmplen;  
  525.             *ptr++ = ':';  
  526.             if (fmt)  
  527.                 *ptr++ = '\t';  
  528.             strcpy(ptr, entries[i]);  
  529.             ptr += strlen(entries[i]);  
  530.             if (i != numentries - 1)  
  531.                 *ptr++ = ',';  
  532.             if (fmt)  
  533.                 *ptr++ = '\n';  
  534.             *ptr = 0;  
  535.             cJSON_free(names[i]);  
  536.             cJSON_free(entries[i]);  
  537.         }  
  538.   
  539.         cJSON_free(names);  
  540.         cJSON_free(entries);  
  541.         if (fmt)  
  542.             for (i = 0; i < depth - 1; i++)  
  543.                 *ptr++ = '\t';  
  544.         *ptr++ = '}';  
  545.         *ptr++ = 0;  
  546.     }  
  547.     return out;  
  548. }  

cJSON解析：

首先，调用cJSON_Parse()函数，此函数是一个二次封装函数，其内部为cJSON_ParseWithOpts()函数，该函数用于提取更多的解析选项，如果需要，最后返回解析结束的位置。而在上面的函数中，调用parse_value()函数进行解析，而该函数首先创建cJSON_NewItem()创建节点，用于存放解析的JSON结构数据，然后根据不同的选项，调用解析函数，其为parse_string()，parse_number()，parse_array()，parse_objec()等。


结构图如下：


相关函数如下：

  1. // cJSON解析的二次封装函数  
  2. cJSON *cJSON_Parse(const char *value)  
  3. {  
  4.     return cJSON_ParseWithOpts(value,0,0);  
  5. }     
  6.   
  7. // 解析对象，创建一个新的根并初始化，返回一个cJSON类型  
  8. cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated)  
  9. {  
  10.     const char *end=0;  
  11.     cJSON *c=cJSON_New_Item();   //创建一个新结点  
  12.     ep=0; //ep为全局变量，错误信息就保存在全局字符串指针ep里，调用cJSON_GetErrorPtr()可以得要错误原因的描述字符串  
  13.     if (!c)  
  14.         return 0;        
  15.   
  16.     end=parse_value(c,skip(value));  
  17.     if (!end)  
  18.     {  
  19.         cJSON_Delete(c);  
  20.         return 0;  
  21.     }   /* parse failure. ep is set. */  
  22.   
  23.     /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */  
  24.     if (require_null_terminated)  
  25.     {  
  26.         end=skip(end);  
  27.         if (*end)  
  28.         {  
  29.             cJSON_Delete(c);  
  30.             ep=end;  
  31.             return 0;  
  32.         }  
  33.     }  
  34.     if (return_parse_end)  
  35.         *return_parse_end=end;  
  36.     return c;  
  37. }  
  38.   
  39. // 解析器核心函数  
  40. static const char *parse_value(cJSON *item,const char *value)  
  41. {  
  42.     if (!value)  
  43.         return 0;   /* Fail on null. */  
  44.     if (!strncmp(value,"null",4))  
  45.     {  
  46.         item->type=cJSON_NULL;  
  47.         return value+4;  
  48.     }  
  49.     if (!strncmp(value,"false",5))  
  50.     {  
  51.         item->type=cJSON_False;  
  52.         return value+5;  
  53.     }  
  54.     if (!strncmp(value,"true",4))  
  55.     {  
  56.         item->type=cJSON_True;  
  57.         item->valueint=1;  
  58.         return value+4;  
  59.     }  
  60.     if (*value=='\"')  
  61.     {  
  62.         return parse_string(item,value);  
  63.     }  
  64.     if (*value=='-' || (*value>='0' && *value<='9'))  
  65.     {  
  66.         return parse_number(item,value);  
  67.     }  
  68.     if (*value=='[')  
  69.     {  
  70.         return parse_array(item,value);  
  71.     }  
  72.     if (*value=='{')  
  73.     {  
  74.         return parse_object(item,value);  
  75.     }  
  76.   
  77.     ep=value;  
  78.     return 0;   /* failure. */  
  79. }  
  80.   
  81. static const char *parse_string(cJSON *item,const char *str)   //解析字符串函数  
  82. {  
  83.     const char *ptr=str+1;  
  84.     char *ptr2;  
  85.     char *out;  
  86.     int len=0;  
  87.     unsigned uc,uc2;  
  88.     if (*str!='\"')    // 不是字符串情况  
  89.     {  
  90.         ep=str;  
  91.         return 0;  
  92.     }   /* not a string! */  
  93.   
  94.     while (*ptr!='\"' && *ptr && ++len)  
  95.         if (*ptr++ == '\\')  
  96.             ptr++;   // 跳出前面的引用  
  97.   
  98.     out=(char*)cJSON_malloc(len+1); /* This is how long we need for the string, roughly. */  
  99.     if (!out)  
  100.         return 0;  
  101.   
  102.     ptr=str+1;  
  103.     ptr2=out;  
  104.     while (*ptr!='\"' && *ptr)  
  105.     {  
  106.         if (*ptr!='\\')  
  107.             *ptr2++=*ptr++;  
  108.         else  
  109.         {  
  110.             ptr++;  
  111.             switch (*ptr)  
  112.             {  
  113.                 case 'b': *ptr2++='\b'; break;  
  114.                 case 'f': *ptr2++='\f'; break;  
  115.                 case 'n': *ptr2++='\n'; break;  
  116.                 case 'r': *ptr2++='\r'; break;  
  117.                 case 't': *ptr2++='\t'; break;  
  118.                 case 'u':    /* transcode utf16 to utf8. */  
  119.                     uc=parse_hex4(ptr+1);  
  120.                         ptr+=4; /* get the unicode char. */  
  121.   
  122.                     if ((uc>=0xDC00 && uc<=0xDFFF) || uc==0)  
  123.                         break;  /* check for invalid.   */  
  124.   
  125.                     if (uc>=0xD800 && uc<=0xDBFF)   /* UTF16 surrogate pairs.   */  
  126.                     {  
  127.                         if (ptr[1]!='\\' || ptr[2]!='u')  
  128.                             break;  /* missing second-half of surrogate.    */  
  129.                         uc2=parse_hex4(ptr+3);ptr+=6;  
  130.                         if (uc2<0xDC00 || uc2>0xDFFF)  
  131.                             break;  /* invalid second-half of surrogate.    */  
  132.                         uc=0x10000 + (((uc&0x3FF)<<10) | (uc2&0x3FF));  
  133.                     }  
  134.   
  135.                     len=4;  
  136.                     if (uc<0x80)  
  137.                         len=1;  
  138.                     else if (uc<0x800)  
  139.                         len=2;  
  140.                     else if (uc<0x10000)  
  141.                         len=3;  
  142.                     ptr2+=len;  
  143.   
  144.                     switch (len)  
  145.                     {  
  146.                         case 4: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;  
  147.                         case 3: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;  
  148.                         case 2: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;  
  149.                         case 1: *--ptr2 =(uc | firstByteMark[len]);  
  150.                     }  
  151.                     ptr2+=len;  
  152.                     break;  
  153.                 default:  *ptr2++=*ptr; break;  
  154.             }  
  155.             ptr++;  
  156.         }  
  157.     }  
  158.     *ptr2=0;  
  159.     if (*ptr=='\"') ptr++;  
  160.     item->valuestring=out;  
  161.     item->type=cJSON_String;  
  162.     return ptr;  
  163. }  
  164.   
  165. // 跳过这些空格，这里跳过了ascii值小于32的。  
  166. static const char *skip(const char *in)  
  167. {  
  168.     while (in && *in && (unsigned char)*in<=32)  
  169.         in++;  
  170.     return in;  
  171. }  
  172.   
  173. // parse_number函数功能：解析数字，对输入的文本生成一个数字，并填充结果项，传入参数有两  
  174. // 个，这里先只关注num，返回值是一个字符串  
  175. static const char *parse_number(cJSON *item,const char *num)  
  176. {  
  177.     double n=0,sign=1,scale=0;  
  178.     int subscale=0,signsubscale=1;  
  179.   
  180.     if (*num=='-') sign=-1,num++;      // 判断数字是否是有符号数字  
  181.     if (*num=='0') num++;                  // 判断数字是否为0  
  182.     if (*num>='1' && *num<='9')  
  183.         do                               // 转换数字  
  184.             n=(n*10.0)+(*num++ -'0');  
  185.         while (*num>='0' && *num<='9');  
  186.     if (*num=='.' && num[1]>='0' && num[1]<='9') // 对小数点后边的部分进行处理，scale记录小数点后边的位数  
  187.     {  
  188.         num++;  
  189.         do  
  190.             n=(n*10.0)+(*num++ -'0'),scale--;       // scale为小数点后的位数  
  191.         while (*num>='0' && *num<='9');  
  192.     }  
  193.     if (*num=='e' || *num=='E')        // 是否为指数，科学计数法  
  194.     {  
  195.         num++;  
  196.         if (*num=='+')                 // 判断指数后边幂的正负号  
  197.             num++;  
  198.         else if (*num=='-')  
  199.             signsubscale=-1,num++;  
  200.         while (*num>='0' && *num<='9') // 处理指数后边10的幂  
  201.             subscale=(subscale*10)+(*num++ - '0');  
  202.     }  
  203.     // 将字符串转换为相应的数值  
  204.     n=sign*n*pow(10.0,(scale+subscale*signsubscale));   /* number = +/- number.fraction * 10^+/- exponent */  
  205.   
  206.     item->valuedouble=n;             // 将算出来的值存入缓存  
  207.     item->valueint=(int)n;           // 将算出来的值存入缓存  
  208.     item->type=cJSON_Number;         // 目标类型为数字  
  209.     return num;  
  210. }  
  211.   
  212. // 从输入文本中构建array  
  213. static const char *parse_array(cJSON *item,const char *value)  
  214. {  
  215.     cJSON *child;  
  216.     if (*value!='[')    {ep=value;return 0;}    /* not an array! */  
  217.   
  218.     item->type=cJSON_Array;  
  219.     value=skip(value+1);  
  220.     if (*value==']') return value+1;    /* empty array. */  
  221.   
  222.     item->child=child=cJSON_New_Item();  
  223.     if (!item->child) return 0;      /* memory fail */  
  224.     value=skip(parse_value(child,skip(value))); /* skip any spacing, get the value. */  
  225.     if (!value) return 0;  
  226.   
  227.     while (*value==',')  
  228.     {  
  229.         cJSON *new_item;  
  230.         if (!(new_item=cJSON_New_Item())) return 0;     /* memory fail */  
  231.         child->next=new_item;new_item->prev=child;child=new_item;  
  232.         value=skip(parse_value(child,skip(value+1)));  
  233.         if (!value) return 0;   /* memory fail */  
  234.     }  
  235.   
  236.     if (*value==']') return value+1;    /* end of array */  
  237.     ep=value;return 0;  /* malformed. */  
  238. }  
  239. // 从输入文本中构建object  
  240. static const char *parse_object(cJSON *item,const char *value)  
  241. {  
  242.     cJSON *child;  
  243.     if (*value!='{')    {ep=value;return 0;}    /* not an object! */  
  244.   
  245.     item->type=cJSON_Object;  
  246.     value=skip(value+1);  
  247.     if (*value=='}') return value+1;    /* empty array. */  
  248.   
  249.     item->child=child=cJSON_New_Item();  
  250.     if (!item->child) return 0;  
  251.     value=skip(parse_string(child,skip(value)));  
  252.     if (!value) return 0;  
  253.     child->string=child->valuestring;child->valuestring=0;  
  254.     if (*value!=':') {ep=value;return 0;}   /* fail! */  
  255.     value=skip(parse_value(child,skip(value+1)));   /* skip any spacing, get the value. */  
  256.     if (!value) return 0;  
  257.   
  258.     while (*value==',')  
  259.     {  
  260.         cJSON *new_item;  
  261.         if (!(new_item=cJSON_New_Item()))   return 0; /* memory fail */  
  262.         child->next=new_item;new_item->prev=child;child=new_item;  
  263.         value=skip(parse_string(child,skip(value+1)));  
  264.         if (!value) return 0;  
  265.         child->string=child->valuestring;child->valuestring=0;  
  266.         if (*value!=':') {ep=value;return 0;}   /* fail! */  
  267.         value=skip(parse_value(child,skip(value+1)));   /* skip any spacing, get the value. */  
  268.         if (!value) return 0;  
  269.     }  
  270.   
  271.     if (*value=='}') return value+1;    /* end of array */  
  272.     ep=value;return 0;  /* malformed. */  
  273. }  
  274.   
  275. // 将十六进制的字符串转换为数字表示！  
  276. static unsigned parse_hex4(const char *str)  
  277. {  
  278.     unsigned h=0;  
  279.     if (*str>='0' && *str<='9')  
  280.         h+=(*str)-'0';  
  281.     else if (*str>='A' && *str<='F')  
  282.         h+=10+(*str)-'A';  
  283.     else if (*str>='a' && *str<='f')  
  284.         h+=10+(*str)-'a';  
  285.     else  
  286.         return 0;  
  287.     h=h<<4;str++;  
  288.     if (*str>='0' && *str<='9')  
  289.         h+=(*str)-'0';  
  290.     else if (*str>='A' && *str<='F')  
  291.         h+=10+(*str)-'A';  
  292.     else if (*str>='a' && *str<='f')  
  293.         h+=10+(*str)-'a';  
  294.     else  
  295.         return 0;  
  296.     h=h<<4;str++;  
  297.     if (*str>='0' && *str<='9')  
  298.         h+=(*str)-'0';  
  299.     else if (*str>='A' && *str<='F')  
  300.         h+=10+(*str)-'A';  
  301.     else if (*str>='a' && *str<='f')  
  302.         h+=10+(*str)-'a';  
  303.     else  
  304.         return 0;  
  305.     h=h<<4;str++;  
  306.     if (*str>='0' && *str<='9')  
  307.         h+=(*str)-'0';  
  308.     else if (*str>='A' && *str<='F')  
  309.         h+=10+(*str)-'A';  
  310.     else if (*str>='a' && *str<='f')  
  311.         h+=10+(*str)-'a';  
  312.     else  
  313.         return 0;  
  314.     return h;  
  315. }  

cJSON内存管理：

hook管理函数：

在 c 语言中内存一般是 malloc 和 free 的。
为了方便用户自由的管理内存， cjson 使用 Hook 技术来让使用者可以自定义内存管理函数。
即用户自定义 malloc 和 free.
具体实现方式可以参考下面的代码， 默认使用系统的 malloc 和 free 函数， 用过 cJSON_InitHooks 函数可以替换成用户自定义的 malloc 和 free 函数。

  1. typedef struct cJSON_Hooks  
  2. {  
  3.   void *(*malloc_fn)(size_t sz);  
  4.   void (*free_fn)(void *ptr);  
  5. } cJSON_Hooks;  
  6.   
  7. // 对cJSON提供的分配，再分配，释放内存初始化函数  
  8. extern void cJSON_InitHooks(cJSON_Hooks* hooks);  
  9.   
  10. // 默认将分配和释放空间函数指针指向malloc和free  
  11. static void *(*cJSON_malloc)(size_t sz) = malloc;  
  12. static void (*cJSON_free)(void *ptr) = free;  
  13. // 其使用Hook技术来让使用者可以自定义内存管理函数。其中默认系统使用的内存分配和释放函数是malloc  
  14. // 和free函数，利用cJSON_InitHooks函数可以替换成用户自定义的malloc和free函数。  
  15. void cJSON_InitHooks(cJSON_Hooks* hooks)  
  16. {  
  17.         // 如果未定义，则使用默认的malloc和free函数  
  18.     if (!hooks) { /* Reset hooks */  
  19.         cJSON_malloc = malloc;  
  20.         cJSON_free = free;  
  21.         return;  
  22.     }  
  23.     // 定义了，则使用用户自定义的malloc和free函数  
  24.     cJSON_malloc = (hooks->malloc_fn)?hooks->malloc_fn:malloc;  
  25.     cJSON_free   = (hooks->free_fn)?hooks->free_fn:free;  
  26. }  

cJSON的删除:

删除节点很简单， 先删除儿子，然后清理内存即可。
总结一下就是对于 object 和 array 需要先删除儿子，然后删除自己。
对于 字符串， 需要先释放字符串的内存， 再释放自己这块内存。
对于其他节点，直接释放自己这块内存。

  1. /*删除结点函数*/  
  2. void cJSON_Delete(cJSON *c) {  
  3.     cJSON *next;  
  4.     while (c) {  
  5.         next=c->next;  
  6.         if (!(c->type&cJSON_IsReference) && c->child) cJSON_Delete(c->child);  
  7.         if (!(c->type&cJSON_IsReference) && c->valuestring) cJSON_free(c->valuestring);  
  8.         if (c->string) cJSON_free(c->string);  
  9.         cJSON_free(c);  
  10.         c=next;  
  11.     }  
  12. }  
  13.   
  14.   
  15. /*删除儿子结点函数*/  
  16. 删除也是从 array 和 object 中删除，实现就比较简洁了。  
  17. void   cJSON_DeleteItemFromArray(cJSON *array,int which) {  
  18.     cJSON_Delete(cJSON_DetachItemFromArray(array,which));  
  19. }  
  20. void   cJSON_DeleteItemFromObject(cJSON *object,const char *string) {  
  21.     cJSON_Delete(cJSON_DetachItemFromObject(object,string));  
  22. }  


Detach 又是什么东西呢？
我们把一个节点从 json 树中删除， 但是不释放内存，而是先保留这个节点的指针， 这样储存在这个节点的信息都保留了下来。
接下来我们就可以做很多事了， 合适的时候添加到其他对象中， 合适的时候释放内存。
比如上面的 delete 函数， 就需要真实的删除了， 这个时候我们删除即可。
而 detach 实现也比较简单， 只是少了一步删除操作。

  1. // 节点从双向链表中删除即可  
  2. cJSON *cJSON_DetachItemFromArray(cJSON *array,int which) {  
  3.     cJSON *c=array->child;  
  4.     while (c && which>0) c=c->next,which--;  
  5.     if (!c) return 0;  
  6.     if (c->prev) c->prev->next=c->next;  
  7.     if (c->next) c->next->prev=c->prev;  
  8.     if (c==array->child) array->child=c->next;  
  9.     c->prev=c->next=0;  
  10.     return c;  
  11. }  
  12. cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string) {  
  13.     int i=0;  
  14.     cJSON *c=object->child;  
  15.     while (c && cJSON_strcasecmp(c->string,string)) i++,c=c->next;  
  16.     if (c) return cJSON_DetachItemFromArray(object,i);  
  17.     return 0;  
  18. }  


其他函数：

前面我们已经将json功能分为三大块进行了解析，现在把剩余的一些函数贴上，这些函数单独分析即可。

    1. // 返回节点的个数  
    2. int cJSON_GetArraySize(cJSON *array)  
    3. {  
    4.     cJSON *c=array->child;  
    5.     int i=0;  
    6.     while(c)  
    7.         i++,c=c->next;  
    8.     return i;  
    9. }  
    10.   
    11. // 返回array中第item个节点的地址  
    12. cJSON *cJSON_GetArrayItem(cJSON *array,int item)  
    13. {  
    14.     cJSON *c=array->child;  
    15.     while (c && item>0)  
    16.         item--,c=c->next;  
    17.     return c;  
    18. }  
    19.   
    20.   
    21. // 返回Object中第item个节点的地址  
    22. cJSON *cJSON_GetObjectItem(cJSON *object,const char *string)  
    23. {  
    24.     cJSON *c=object->child;  
    25.     while (c && cJSON_strcasecmp(c->string,string))  
    26.         c=c->next;  
    27.     return c;  
    28. }  
    29.   
    30. //在链表中插入一个新结点  
    31. void cJSON_InsertItemInArray(cJSON *array,int which,cJSON *newitem)  
    32. {  
    33.     cJSON *c=array->child;  
    34.     // 找到which位置  
    35.     while (c && which>0)  
    36.      c=c->next,which--;  
    37.     // 添加新的节点到array中  
    38.     if (!c)  
    39.     {  
    40.         cJSON_AddItemToArray(array,newitem);  
    41.         return;  
    42.     }  
    43.     // 将链表节点进行挂接  
    44.     newitem->next=c;  
    45.     newitem->prev=c->prev;  
    46.     c->prev=newitem;  
    47.     // 处理arrya的孩子节点  
    48.     if (c==array->child)  
    49.         array->child=newitem;  
    50.     else  
    51.         newitem->prev->next=newitem;  
    52. }  
    53.   
    54.   
    55. // 替换节点操作，用新的节点替换原有的某一个节点  
    56. void cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem)  
    57. {  
    58.     cJSON *c=array->child;  
    59.     // 找到which位置  
    60.     while (c && which>0)  
    61.         c=c->next,which--;  
    62.     if (!c)  
    63.         return;  
    64.     // 进行挂接  
    65.     newitem->next=c->next;  
    66.     newitem->prev=c->prev;  
    67.     // 处理NULL情况  
    68.     if (newitem->next)  
    69.         newitem->next->prev=newitem;  
    70.     // 处理孩子节点  
    71.     if (c==array->child)  
    72.         array->child=newitem;  
    73.     else  
    74.         newitem->prev->next=newitem;  
    75.     c->next=c->prev=0;  
    76.     // 删除替换的节点  
    77.     cJSON_Delete(c);  
    78. }  
    79.   
    80.   
    81. // 替换节点操作  
    82. // 用原有节点替换现有节点  
    83. void cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem)  
    84. {  
    85.     int i=0;  
    86.     cJSON *c=object->child;  
    87.     while(c && cJSON_strcasecmp(c->string,string))  
    88.         i++,c=c->next;  
    89.     if(c)  
    90.     {  
    91.         newitem->string=cJSON_strdup(string);  
    92.         cJSON_ReplaceItemInArray(object,i,newitem);  
    93.     }  
    94. }  
    95.   
    96.   
    97. // 拷贝副本操作  
    98. cJSON *cJSON_Duplicate(cJSON *item,int recurse)  
    99. {  
    100.     cJSON *newitem,*cptr,*nptr=0,*newchild;  
    101.     /* Bail on bad ptr */  
    102.     if (!item)  
    103.         return 0;  
    104.     /* Create new item */  
    105.     newitem=cJSON_New_Item();  
    106.     if (!newitem)  
    107.         return 0;  
    108.     /* Copy over all vars */  
    109.     newitem->type=item->type&(~cJSON_IsReference),newitem->valueint=item->valueint,newitem->valuedouble=item->valuedouble;  
    110.     if (item->valuestring)  
    111.     {  
    112.         newitem->valuestring=cJSON_strdup(item->valuestring);  
    113.         if (!newitem->valuestring)  
    114.         {  
    115.             cJSON_Delete(newitem);  
    116.             return 0;  
    117.         }  
    118.     }  
    119.     if (item->string)  
    120.     {  
    121.         newitem->string=cJSON_strdup(item->string);  
    122.         if (!newitem->string)  
    123.         {  
    124.             cJSON_Delete(newitem);  
    125.             return 0;  
    126.         }  
    127.     }  
    128.     /* If non-recursive, then we're done! */  
    129.     if (!recurse)  
    130.         return newitem;  
    131.     /* Walk the ->next chain for the child. */  
    132.     cptr=item->child;  
    133.     while (cptr)  
    134.     {  
    135.         newchild=cJSON_Duplicate(cptr,1);       /* Duplicate (with recurse) each item in the ->next chain */  
    136.         if (!newchild)  
    137.         {  
    138.             cJSON_Delete(newitem);  
    139.             return 0;  
    140.         }  
    141.         if (nptr)  
    142.         {  
    143.             nptr->next=newchild,newchild->prev=nptr;  
    144.             nptr=newchild;  
    145.         }   /* If newitem->child already set, then crosswire ->prev and ->next and move on */  
    146.         else  
    147.         {  
    148.             newitem->child=newchild;  
    149.             nptr=newchild;  
    150.         }                   /* Set newitem->child and move to it */  
    151.         cptr=cptr->next;  
    152.     }  
    153.     return newitem;  
    154. }

原文出处

posted @ 2017-12-31 01:37  壹点灵异  阅读(5076)  评论(0)  编辑  收藏  举报