cjson库的使用以及源码阅读

cjson是一个用c语言开发的json解析库，免费开源只有一个c文件和一个h文件。
json和xml功能相似，可以用来传输数据，存储数据以及表达程序当前的状态。
1、下载cjson的源码
        https://github.com/DaveGamble/cJSON
2、阅读readme文件可以大概的了解一下cjson的介绍以及使用方法，我尝试着把readme文件做了一下翻译，水平有限，大概意思写在了“cjson工程的readme文件翻译”，可以参考原文来对照看，如果只是想快速应用一下cjson库的话，看完应该能知道如何使用这个cjson库了。
3、源码分析
    如果本着不了解其实现无法安心使用的心态的话，可以看一下下面的源码解析。
    将头文件和源码进行分开，然后注释都添加在了代码里（基本上都是根据自己对英文的理解进行翻译的），至于测试例程，其实cjson的源码提供了一个test.c。这个文件里面里面提供了一个比较全面的测试用例。附件里面是整理完格式和加了注释后的cJSON源码

cJSON.h：
  1. #ifndef cJSON__h
  2. #define cJSON__h
  4. #ifdef __cplusplus
  5. extern "C"
  6. {
  7. #endif
  9. //以宏的方式定义出的几种cJson对象的类型
  10. #define cJSON_False 0
  11. #define cJSON_True 1
  12. #define cJSON_NULL 2
  13. #define cJSON_Number 3
  14. #define cJSON_String 4
  15. #define cJSON_Array 5
  16. #define cJSON_Object 6
  17. 	
  18. #define cJSON_IsReference 256
  19. #define cJSON_StringIsConst 512
  21. //cJSON的数据结构
  22. typedef struct cJSON 
  23. {
  24. 	/* next/prev 用来遍历所有的数组或者对象链表. 一般来说可以调用GetArraySize/GetArrayItem/GetObjectItem 进行操作*/
  25. 	struct cJSON *next,*prev;	
  26. 	/* 一个数组或者对象会有一个孩子节点指针指向一个对象或者数组链 */
  27. 	struct cJSON *child;		
  28. 	/* 这个节点的类型, 为上面定义的宏 */
  29. 	int type;					
  30. 	/* 是节点的值 如果节点的类型是cJSON_String的话 */
  31. 	char *valuestring;			
  32. 	/* 是节点的值 如果节点的类型是cJSON_Number的话 */
  33. 	int valueint;				
  34. 	/* 是节点的值 如果节点的类型是cJSON_Number的话 */
  35. 	double valuedouble;
  36. 	/* 节点的名字*/
  37. 	char *string;				
  38. } cJSON;
  39. //钩子?将申请内存和释放内存的接口进行管理。
  40. typedef struct cJSON_Hooks {
  41.       void *(*malloc_fn)(size_t sz);
  42.       void (*free_fn)(void *ptr);
  43. } cJSON_Hooks;
  46. //为cJSON提供 malloc realloc 和 free函数
  47. extern void cJSON_InitHooks(cJSON_Hooks* hooks);
  49. //提供一个JSON的内存块，返回出从value传入的字符串中携带的json信息使你后续可以进行提取。在完成工作之后要使用cJSON_Delete进行释放
  50. extern cJSON *cJSON_Parse(const char *value);
  52. //将一个json数据转换为文本数据，用来方便转发和存储。在完成工作之后要释放char *
  53. extern char  *cJSON_Print(cJSON *item);
  54. //将一个json数据转换为不含有任何格式的文本数据，用来方便转发和存储。在完成工作之后要释放char *
  55. extern char  *cJSON_PrintUnformatted(cJSON *item);
  56. /* 使用缓存的策略将json数据打印到缓冲区中. prebuffer是预测的缓存大小. 认为可以很好的减少内存重复分配.
  57.  * fmt=0 不含有任何格式,
  58.  *  fmt=1 含有格式
  59.  */
  60. extern char *cJSON_PrintBuffered(cJSON *item,int prebuffer,int fmt);
  61. /* 删除整个json结构体和其所有子项 */
  62. extern void   cJSON_Delete(cJSON *c);
  64. /* 返回一个对象或者数组中所有的元素个数*/
  65. extern int	  cJSON_GetArraySize(cJSON *array);
  66. /* 检索数组array中第item个元素，不成功则返回NULL */
  67. extern cJSON *cJSON_GetArrayItem(cJSON *array,int item);
  68. /*获取"string"指定的对象. 不区分大小写. */
  69. extern cJSON *cJSON_GetObjectItem(cJSON *object,const char *string);
  71. /* 用来分析错误的解析.返回一个指向解析错误位置的指针。你可能需要从这个位置往回检查几个字符. 解析成功则返回0. */
  72. extern const char *cJSON_GetErrorPtr(void);
  74. /*下面的这些调用用来根据指定的类型创建cjson的节点。*/
  75. extern cJSON *cJSON_CreateNull(void);
  76. extern cJSON *cJSON_CreateTrue(void);
  77. extern cJSON *cJSON_CreateFalse(void);
  78. extern cJSON *cJSON_CreateBool(int b);
  79. extern cJSON *cJSON_CreateNumber(double num);
  80. extern cJSON *cJSON_CreateString(const char *string);
  81. extern cJSON *cJSON_CreateArray(void);
  82. extern cJSON *cJSON_CreateObject(void);
  84. /*下面的这些用来建立count个节点*/
  85. extern cJSON *cJSON_CreateIntArray(const int *numbers,int count);
  86. extern cJSON *cJSON_CreateFloatArray(const float *numbers,int count);
  87. extern cJSON *cJSON_CreateDoubleArray(const double *numbers,int count);
  88. extern cJSON *cJSON_CreateStringArray(const char **strings,int count);
  90. /*将指定的节点添加到数组或者对象中 */
  91. extern void cJSON_AddItemToArray(cJSON *array, cJSON *item);
  92. extern void	cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item);
  93. /* 当字符串是常量的时候使用下面这个接口 */
  94. extern void	cJSON_AddItemToObjectCS(cJSON *object,const char *string,cJSON *item);	
  95. /*添加指定的节点到指定的对象或者数组中. 把一个存在的cJSON添加到一个新的cJSON但是又不想销毁已经存在的这个cJSON使用这一组接口*/
  96. extern void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
  97. extern void	cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item);
  99. /* 从一个数组或者对象中删除指定的节点 */
  100. extern cJSON *cJSON_DetachItemFromArray(cJSON *array,int which);
  101. extern void   cJSON_DeleteItemFromArray(cJSON *array,int which);
  102. extern cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string);
  103. extern void   cJSON_DeleteItemFromObject(cJSON *object,const char *string);
  104. 	
  105. /* 更新数组中的节点. */
  106. extern void cJSON_InsertItemInArray(cJSON *array,int which,cJSON *newitem);	/* 将原有的节点右移. */
  107. extern void cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem);
  108. extern void cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
  110. /* 复制一个cJSON对象 */
  111. extern cJSON *cJSON_Duplicate(cJSON *item,int recurse);
  112. /* Duplicate会创建一个与传入参数完全相同的对象, 在新的内存中需要释放。
  113.  *当recurse!=0，将会复制这个对象中的所有的孩子节点。
  114.  *返回对象中的item->next 和 ->prev指针通常是0。
  115.  */
  118. /* ParseWithOpts允许你去指定或者检查字符串是否以NULL结尾, 同时可以检索解析后的字符串的最后一个位置. */
  119. extern cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated);
  120. //一个精简后的解析框架
  121. extern void cJSON_Minify(char *json);
  123. /* 宏，用来做快速建立并添加操作. */
  124. #define cJSON_AddNullToObject(object,name)		cJSON_AddItemToObject(object, name, cJSON_CreateNull())
  125. #define cJSON_AddTrueToObject(object,name)		cJSON_AddItemToObject(object, name, cJSON_CreateTrue())
  126. #define cJSON_AddFalseToObject(object,name)		cJSON_AddItemToObject(object, name, cJSON_CreateFalse())
  127. #define cJSON_AddBoolToObject(object,name,b)	cJSON_AddItemToObject(object, name, cJSON_CreateBool(b))
  128. #define cJSON_AddNumberToObject(object,name,n)	cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))
  129. #define cJSON_AddStringToObject(object,name,s)	cJSON_AddItemToObject(object, name, cJSON_CreateString(s))
  131. /* 当赋值一个整数的时候, 需要对浮点数也进行同时赋值. */
  132. #define cJSON_SetIntValue(object,val)			((object)?(object)->valueint=(object)->valuedouble=(val):(val))
  133. #define cJSON_SetNumberValue(object,val)		((object)?(object)->valueint=(object)->valuedouble=(val):(val))
  135. #ifdef __cplusplus
  136. }
  137. #endif
  139. #endif

    以上为cjson的头文件中的内容，其中定义cjson结构体以及操作json数据的接口，对于cjson结构体来说通过之前的readme文件可以大致的根据一个样例数据进行示例其在内存中的组织方式，而各个接口的实现则在后续的cjson.c的分析中进行展开。
    在绘图时，对于cjson结构的组织如下图所示：

图一：cjson的数据结构示意图
  1. {
  2.     "name": "Jack (\"Bee\") Nimble", 
  3.     "format": {
  4.         "type":       "rect", 
  5.         "width":      1920, 
  6.         "height":     1080, 
  7.         "interlace":  false, 
  8.         "frame rate": 24
  9.     }
  10. }
    cjson将上面所示例的json数据在内存中组织方式如下图所示（char*实际情况应为指向动态申请的内存的指针，但为了方便起见图中约定char*使用值直接替换）：

图二：示例json的组织方式
    下面是对于cJSON.c中的源码分析。
cJSON.c
  1.  
  2. /* cJSON */
  3. /* JSON parser in C. */
  5. #include <string.h>
  6. #include <stdio.h>
  7. #include <math.h>
  8. #include <stdlib.h>
  9. #include <float.h>
  10. #include <limits.h>
  11. #include <ctype.h>
  12. #include "cJSON.h"
  15. /* ep静态全局指针，指向字符串，*/
  16. static const char *ep;
  17. /*返回ep所指向字符串的地址，使用const修饰返回值，说明ep所指向的字符串是常量，
  18.    应该是写死在出错方式上。所以不需要释放其返回的指针的*/
  19. const char *cJSON_GetErrorPtr(void) 
  20. {
  21. 	return ep;
  22. }
  23. /*忽略大小写比较字符串s1和s2, 参数使用const进行修饰，说明内部不会修改这两个值。
  24.  *static说明文件内作用域，返回整数，
  25.  *=0 - 相等；
  26.  *>0 - s1>s2；
  27.  *<0 - s1<s2；
  28.  */
  29. static int cJSON_strcasecmp(const char *s1,const char *s2)
  30. {
  31. 	//s1==NULL的情况下，如果s2也是NULL就相等，不然就是s1<s2;
  32. 	if (!s1) 
  33. 		return (s1==s2)?0:1;
  34. 	//s1不是NULL，但是s2是NULL,那么s1>s2
  35. 	if (!s2) 
  36. 		return 1;
  37. 	//不区分大小写，即都以小写形式进行比较，循环比较每个字符。不相等则跳出循环。
  38. 	for(; tolower(*s1) == tolower(*s2); ++s1, ++s2)	
  39. 		if(*s1 == 0)//如果这个条件为真，说明s1==s2，s1==NULL。即，两个字串不区分大小写相同
  40. 			return 0;
  41. 	//将不相同的那个字符的小写形式进行相减，可以得到两个串的大小。
  42. 	//强制转换防止报错吧。
  43. 	return tolower(*(const unsigned char *)s1) - tolower(*(const unsigned char *)s2);
  44. }
  46. /*对静态全局函数指针变量进行赋值，使cJSON_malloc=malloc，使cJSON_free=free*/
  47. static void *(*cJSON_malloc)(size_t sz) = malloc;
  48. static void (*cJSON_free)(void *ptr) = free;
  49. /*静态作用域，返回char*类型指针，该指针指向从str中复制出内容的一块新申请的内存地址，str为const，不可修改*/
  50. static char* cJSON_strdup(const char* str)
  51. {
  52.       size_t len;
  53.       char* copy;
  54. 	  //获取字符串长度，并考虑了最后一个结束符号。
  55.       len = strlen(str) + 1;
  56. 	  //申请len个长度内存并类型转换和测试是否申请成功，不成功就返回NULL。
  57.       if (!(copy = (char*)cJSON_malloc(len))) return 0;
  58. 	  //申请成功就拷贝len长度个串进去。然后将首地址返回
  59.       memcpy(copy,str,len);
  60.       return copy;
  61. }
  62. /*初始化钩子，其实所谓钩子在这里也就是内存申请和释放接口*/
  63. void cJSON_InitHooks(cJSON_Hooks* hooks)
  64. {
  65. 	//判断传入的指针为NULL，那么就使用系统的申请和释放接口
  66.     if (!hooks) { /* Reset hooks */
  67.         cJSON_malloc = malloc;
  68.         cJSON_free = free;
  69.         return;
  70.     }
  71. 	//然后根据传入参数中是否携带指定的申请和释放接口，进行选择使用哪一个内存接口。
  72. 	cJSON_malloc = (hooks->malloc_fn)?hooks->malloc_fn:malloc;
  73. 	cJSON_free	 = (hooks->free_fn)?hooks->free_fn:free;
  74. }
  76. /*申请一个cJSON结构体大小的内存，初始化为0，静态作用域*/
  77. static cJSON *cJSON_New_Item(void)
  78. {
  79. 	//申请内存，测试，赋值为0，返回指针。
  80. 	cJSON* node = (cJSON*)cJSON_malloc(sizeof(cJSON));
  81. 	if (node)
  82. 		memset(node,0,sizeof(cJSON));
  83. 	return node;
  84. }
  86. /*删除一个cJSON结构体，还应该循环将它的所有子项进行删除清理*/
  87. /*对于c->type的0、1、2、3、4、5、6和256以及512做与预算到底是为什么要这么做呢?*/
  88. void cJSON_Delete(cJSON *c)
  89. {
  90. 	cJSON *next;
  91. 	while (c)
  92. 	{
  93. 		//记录c节点的下一个节点。
  94. 		next=c->next;
  95. 		//c->type&cJSON_IsReference将type与256做与运算，判断有孩子节点则进行递归
  96. 		if (!(c->type&cJSON_IsReference) && c->child) 
  97. 			cJSON_Delete(c->child);
  98. 		//valuestring不为NULL，需要释放内存
  99. 		if (!(c->type&cJSON_IsReference) && c->valuestring)
  100. 			cJSON_free(c->valuestring);
  101. 		//string不为NULL，需要释放内存
  102. 		if (!(c->type&cJSON_StringIsConst) && c->string)
  103. 			cJSON_free(c->string);
  104. 		//删除这个节点
  105. 		cJSON_free(c);
  106. 		//继续下一个节点
  107. 		c=next;
  108. 	}
  109. }
  111. /*将输入的num解析成一个数字，然后将结果填充到节点中
  112.  *静态作用域，const返回值为传入字串解析完后第一个不为数值的位置，解析num到item中
  113.  */
  114. static const char *parse_number(cJSON *item,const char *num)
  115. {
  116. 	double n=0,sign=1,scale=0;
  117. 	int subscale=0,signsubscale=1;
  118. 	//是否为负数
  119. 	if (*num=='-')
  120. 		sign=-1,num++;
  121. 	//是否为0
  122. 	if (*num=='0') 
  123. 		num++;
  124. 	//如果是十进制就进行解析，临时变量存到n中
  125. 	if (*num>='1' && *num<='9')
  126. 		do
  127. 			n=(n*10.0)+(*num++ -'0');	
  128. 		while (*num>='0' && *num<='9');
  129. 	//如果存在小数点，将数字继续转存到n的末尾以整数方式，但是使用scale记录有几位小数
  130. 	if (*num=='.' && num[1]>='0' && num[1]<='9') 
  131. 	{
  132. 		num++;
  133. 		do
  134. 			n=(n*10.0)+(*num++ -'0'),scale--; 
  135. 		while (*num>='0' && *num<='9');
  136. 	}
  137. 	//如果是指数计数方式，记录指数符号，然后将数字进行转存到subscale中
  138. 	if (*num=='e' || *num=='E')
  139. 	{	
  140. 		num++;
  141. 		if (*num=='+')
  142. 			num++;
  143. 		else if (*num=='-') 
  144. 			signsubscale=-1,num++;	
  145. 		while (*num>='0' && *num<='9') 
  146. 			subscale=(subscale*10)+(*num++ - '0');
  147. 	}
  148. 	/* number = +/- number.fraction * 10^+/- exponent */
  149. 	n=sign*n*pow(10.0,(scale+subscale*signsubscale));
  150. 	//将计算到的值赋值到item中，int和double项都要赋值。类型赋值为NUM
  151. 	item->valuedouble=n;
  152. 	item->valueint=(int)n;
  153. 	item->type=cJSON_Number;
  154. 	return num;
  155. }
  156. /*返回大于x的最小的2的幂，静态作用域*/
  157. /*在实现上就是把x占用到的最高位为1的位到第0位，都置位为1*/
  158. static int pow2gt (int x)	
  159. {
  160. 	//--x是为了防止x直接就是2的幂的情况。
  161. 	--x;
  162. 	x|=x>>1;	x|=x>>2;	x|=x>>4;	x|=x>>8;	x|=x>>16;	
  163. 	return x+1;	
  164. }
  165. //定义一个printbuffer类型，主要是用来将json数据打印到缓冲区时，进行提供缓存空间的信息。
  166. typedef struct 
  167. {
  168. 	char *buffer; //缓存地址指针
  169. 	int length;   //缓存当前的长度
  170. 	int offset;  //缓存当前已经使用到的位置。
  171. } printbuffer;
  172. /*
  173.  *ensure 意为确保的意思，这里可以理解为，确保p所指向的缓冲区中能够提供needed大小的缓冲给打印功能使用
  174.  *静态作用域，返回缓冲区中可以继续使用的空间的位置。needed在里面做了局部变量，修改使用均无碍，
  175.  *减少了一个中间变量。
  176.  */
  177. static char* ensure(printbuffer *p,int needed)
  178. {
  179. 	char *newbuffer;int newsize;
  180. 	//如果p=NULL,或者p->buffer=NULL,那么为运行时检查错误，返回空指针
  181. 	if (!p || !p->buffer)
  182. 		return 0;
  183. 	//计算将当前所需的空间加上之前已用的空间一共需要内存的数目
  184. 	needed+=p->offset;
  185. 	//如果现在p->buffer足够容下所有的值，那么就返回当前缓存中最后一个可用的位置
  186. 	if (needed<=p->length) 
  187. 		return p->buffer+p->offset;
  188. 	/*下面为处理当前缓存不能存下所有的信息的时候*/
  189. 	//计算大于当前所需数目的最小2de幂，用来分配内存数目
  190. 	newsize=pow2gt(needed);
  191. 	//申请内存并做错误检查，如果失败那么就置空后返回空指针。
  192. 	newbuffer=(char*)cJSON_malloc(newsize);
  193. 	if (!newbuffer)
  194. 	{
  195. 		cJSON_free(p->buffer);
  196. 		p->length=0,
  197. 		p->buffer=0;
  198. 		return 0;
  199. 	}
  200. 	//申请成功后将原有数据拷贝到新空间中。
  201. 	if (newbuffer) 
  202. 		memcpy(newbuffer,p->buffer,p->length);
  203. 	//释放原指针，并更新新的缓存信息，然后返回缓存中第一个可用的内存位置。
  204. 	cJSON_free(p->buffer);
  205. 	p->length=newsize;
  206. 	p->buffer=newbuffer;
  207. 	return newbuffer+p->offset;
  208. }
  209. /*静态作用域函数，意为更新，传入参数为缓存结构，返回当前缓存区已使用的内存偏移量*/
  210. static int update(printbuffer *p)
  211. {
  212. 	char *str;
  213. 	//运行时错误检查
  214. 	if (!p || !p->buffer) 
  215. 		return 0;
  216. 	//将str定义到新加入缓存的数据的首地址。然后使用strlen计算新添加长度后加上原有的偏移量进行返回。
  217. 	str=p->buffer+p->offset;
  218. 	return p->offset+strlen(str);
  219. }
  221. /*静态作用域，将item中的数字打印成字符串，
  222.  *当p不为NULL时，使用的是p所指向的内存缓冲区，当p为NULL时，使用的是单独申请的内存
  223.  */
  224. static char *print_number(cJSON *item,printbuffer *p)
  225. {
  226. 	char *str=0;
  227. 	double d=item->valuedouble;
  228. 	//如果item的数值为0，使用两个字节，根据p是否为空，决定使用从哪里分配的缓存，并将字符串"0"拷贝到缓存中。
  229. 	if (d==0)
  230. 	{
  231. 		if (p)	str=ensure(p,2);
  232. 		else	str=(char*)cJSON_malloc(2);	/* special case for 0. */
  233. 		if (str) strcpy(str,"0");
  234. 	}
  235. 	//如果item的数值为整数，21个char肯定装的下，并验证数值的正确性。
  236. 	//(fabs(((double)item->valueint)-d)<=DBL_EPSILON，标示差小于最小误差值，即可以理解为整数，并用INT_MAX、INT_MIN，验证合法性数据。
  237. 	else if (fabs(((double)item->valueint)-d)<=DBL_EPSILON && d<=INT_MAX && d>=INT_MIN)
  238. 	{
  239. 		if (p)	str=ensure(p,21);
  240. 		else	str=(char*)cJSON_malloc(21);	/* 2^64+1 can be represented in 21 chars. */
  241. 		if (str)	sprintf(str,"%d",item->valueint);
  242. 	}
  243. 	//走到这里，肯定是小数，选用64个字节较为合适。
  244. 	else
  245. 	{
  246. 		if (p)	str=ensure(p,64);
  247. 		else	str=(char*)cJSON_malloc(64);	/* This is a nice tradeoff. */
  248. 		if (str)
  249. 		{
  250. 			//如果小数值特别接近零，并且整数部分值特别大，那么就以xxxxx.0方式输出
  251. 			if (fabs(floor(d)-d)<=DBL_EPSILON && fabs(d)<1.0e60)sprintf(str,"%.0f",d);
  252. 			//如果数值比1.0e-6小或者比1.0e9数值大，那么比较适合用科学计数法标示
  253. 			else if (fabs(d)<1.0e-6 || fabs(d)>1.0e9)			sprintf(str,"%e",d);
  254. 			//剩余部分直接用小数点形式进行输出
  255. 			else												sprintf(str,"%f",d);
  256. 		}
  257. 	}
  258. 	return str;
  259. }
  260. /*从16进制整数的字符串表达方式转换成无符号整数*/
  261. /*静态作用域，返回无符号整数，参数不可修改*/
  262. static unsigned parse_hex4(const char *str)
  263. {
  264. 	//将字符串的字符逐个取出进行分析，然后计算到整数中。然后将h左移一个直接再进行下一个数字的解析。最后完成4个字节的整数解析
  265. 	unsigned h=0;
  266. 	if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0;
  267. 	h=h<<4;str++;
  268. 	if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0;
  269. 	h=h<<4;str++;
  270. 	if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0;
  271. 	h=h<<4;str++;
  272. 	if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0;
  273. 	return h;
  274. }
  277. /*将输入的文本解析为非转意的c的字符串，然后填充到item中，应该保证str是已经去除开头空字符的串，
  278.  *,此处的静态字符数组，是用来做utf格式转换的，返回值为解析出一个字符串之后的首地址
  279.  */
  280. static const unsigned char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
  281. static const char *parse_string(cJSON *item,const char *str)
  282. {
  283. 	const char *ptr=str+1;
  284. 	char *ptr2;
  285. 	char *out;
  286. 	int len=0;
  287. 	unsigned uc,uc2;
  288. 	//如果str不以"引号，开头，那么不是一个字符串。
  289. 	if (*str!='\"') {ep=str;return 0;}	/* not a string! */
  290. 	
  291. 	while (*ptr!='\"' && *ptr && ++len) 
  292. 		if (*ptr++ == '\\') 
  293. 			ptr++;	/* Skip escaped quotes. */
  294. 	//分配内存并进行检查
  295. 	out=(char*)cJSON_malloc(len+1);	/* This is how long we need for the string, roughly. */
  296. 	if (!out) return 0;
  297. 	
  298. 	ptr=str+1;ptr2=out;
  299. 	while (*ptr!='\"' && *ptr)
  300. 	{
  301. 		if (*ptr!='\\')
  302. 			*ptr2++=*ptr++;
  303. 		else
  304. 		{//如果以反斜杠开头的转义字符，则进行下诉的语义转换。只有utf格式转换不是很了解。
  305. 			ptr++;
  306. 			switch (*ptr)
  307. 			{
  308. 				case 'b': *ptr2++='\b';	break;
  309. 				case 'f': *ptr2++='\f';	break;
  310. 				case 'n': *ptr2++='\n';	break;
  311. 				case 'r': *ptr2++='\r';	break;
  312. 				case 't': *ptr2++='\t';	break;
  313. 				case 'u':	 /* transcode utf16 to utf8. */
  314. 					uc=parse_hex4(ptr+1);ptr+=4;	/* get the unicode char. */
  315. 					//utf16和utf8之间格式的转换
  316. 					if ((uc>=0xDC00 && uc<=0xDFFF) || uc==0)	break;	/* check for invalid.	*/
  318. 					if (uc>=0xD800 && uc<=0xDBFF)	/* UTF16 surrogate pairs.	*/
  319. 					{
  320. 						if (ptr[1]!='\\' || ptr[2]!='u')	break;	/* missing second-half of surrogate.	*/
  321. 						uc2=parse_hex4(ptr+3);ptr+=6;
  322. 						if (uc2<0xDC00 || uc2>0xDFFF)		break;	/* invalid second-half of surrogate.	*/
  323. 						uc=0x10000 + (((uc&0x3FF)<<10) | (uc2&0x3FF));
  324. 					}
  326. 					len=4;if (uc<0x80) len=1;else if (uc<0x800) len=2;else if (uc<0x10000) len=3; ptr2+=len;
  327. 					
  328. 					switch (len) {
  329. 						case 4: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
  330. 						case 3: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
  331. 						case 2: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
  332. 						case 1: *--ptr2 =(uc | firstByteMark[len]);
  333. 					}
  334. 					ptr2+=len;
  335. 					break;
  336. 				default:  *ptr2++=*ptr; break;
  337. 			}
  338. 			ptr++;
  339. 		}
  340. 	}
  341. 	//在结尾填充上'\0'，然后将ptr结尾的引号跳过，并返回跳过后所处的位置。也做了对item中相应值的赋值操作。
  342. 	*ptr2=0;
  343. 	if (*ptr=='\"') ptr++;
  344. 	item->valuestring=out;
  345. 	item->type=cJSON_String;
  346. 	return ptr;
  347. }
  349. /* Render the cstring provided to an escaped version that can be printed. */
  350. /*将提供的c字符串打印成可输出的无转意的版本，str为传入字符串，p为缓存指针，返回解析出的字串地址*/
  351. static char *print_string_ptr(const char *str,printbuffer *p)
  352. {
  353. 	const char *ptr;
  354. 	char *ptr2,*out;
  355. 	int len=0,flag=0;
  356. 	unsigned char token;
  357. 	//测试str中是否携带着空格，引号，以及转义字符反斜杠，结果用flag进行标识
  358. 	for (ptr=str;*ptr;ptr++)
  359. 		flag|=((*ptr>0 && *ptr<32)||(*ptr=='\"')||(*ptr=='\\'))?1:0;
  360. 	//如果没有携带上诉的字符，那么根据p指针使用ensure检查内存或者执行分配内存，并进行内存检查。
  361. 	//然后将str中的字符串前后加上引号，存储到out所指向的内存中，并将地址进行返回。
  362. 	if (!flag)
  363. 	{
  364. 		len=ptr-str;
  365. 		if (p) 
  366. 			out=ensure(p,len+3);
  367. 		else		
  368. 			out=(char*)cJSON_malloc(len+3);
  369. 		if (!out)
  370. 			return 0;
  371. 		ptr2=out;*ptr2++='\"';
  372. 		strcpy(ptr2,str);
  373. 		ptr2[len]='\"';
  374. 		ptr2[len+1]=0;
  375. 		return out;
  376. 	}
  377. 	//如果str为NULL，那么就只填上一个双引号间填充空的打印到内存或者缓存。
  378. 	if (!str)
  379. 	{
  380. 		if (p)	out=ensure(p,3);
  381. 		else	out=(char*)cJSON_malloc(3);
  382. 		if (!out) return 0;
  383. 		strcpy(out,"\"\"");
  384. 		return out;
  385. 	}
  386. 	ptr=str;
  387. 	while ((token=*ptr) && ++len) 
  388. 	{
  389. 		if (strchr("\"\\\b\f\n\r\t",token))
  390. 			len++; 
  391. 		else if (token<32) 
  392. 			len+=5;ptr++;
  394. 	}
  395. 	
  396. 	if (p)	out=ensure(p,len+3);
  397. 	else	out=(char*)cJSON_malloc(len+3);
  398. 	if (!out) return 0;
  399. 	//就是转义字符的处理基本上是按照原样输出到输出结果中的。
  400. 	ptr2=out;ptr=str;
  401. 	*ptr2++='\"';
  402. 	while (*ptr)
  403. 	{
  404. 		if ((unsigned char)*ptr>31 && *ptr!='\"' && *ptr!='\\') *ptr2++=*ptr++;
  405. 		else
  406. 		{
  407. 			*ptr2++='\\';
  408. 			switch (token=*ptr++)
  409. 			{
  410. 				case '\\':	*ptr2++='\\';	break;
  411. 				case '\"':	*ptr2++='\"';	break;
  412. 				case '\b':	*ptr2++='b';	break;
  413. 				case '\f':	*ptr2++='f';	break;
  414. 				case '\n':	*ptr2++='n';	break;
  415. 				case '\r':	*ptr2++='r';	break;
  416. 				case '\t':	*ptr2++='t';	break;
  417. 				default: sprintf(ptr2,"u%04x",token);ptr2+=5;	break;	/* escape and print */
  418. 			}
  419. 		}
  420. 	}
  421. 	*ptr2++='\"';*ptr2++=0;
  422. 	return out;
  423. }
  424. /* 使用一个对象调用 print_string_ptr (很有用的). */
  425. /*将item中的valuestring打印到分配的内存中或者是缓存p中。局部作用域，返回输出值*/
  426. static char *print_string(cJSON *item,printbuffer *p)	{return print_string_ptr(item->valuestring,p);}
  428. /* 声明一些函数原型解析一个值，与打印一个值成对存在。. */
  429. static const char *parse_value(cJSON *item,const char *value);
  430. static char *print_value(cJSON *item,int depth,int fmt,printbuffer *p);
  431. static const char *parse_array(cJSON *item,const char *value);
  432. static char *print_array(cJSON *item,int depth,int fmt,printbuffer *p);
  433. static const char *parse_object(cJSON *item,const char *value);
  434. static char *print_object(cJSON *item,int depth,int fmt,printbuffer *p);
  436. /* Utility to jump whitespace and cr/lf */
  437. /*跳过空字符或者一个控制字符，即在ascii码中小于等于32的字符*/
  438. /*静态作用域，常量返回值，其实还是这个串里面的地址。*/
  439. static const char *skip(const char *in) 
  440. {
  441. 	while (in && *in && (unsigned char)*in<=32)
  442. 		in++;
  443. 	return in;
  445. }
  447. /*解析一个对象-创建一个新的根节点，然后进行填充*/
  448. cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated)
  449. {
  450. 	const char *end=0;
  451. 	//新建一个根节点，初始化错误标识，以及检测内存申请状态
  452. 	cJSON *c=cJSON_New_Item();
  453. 	ep=0;
  454. 	if (!c) return 0;       /* memory fail */
  455. 	//先将传入的值，进行去除开头的不可见字符后，调用parse_value。
  456. 	end=parse_value(c,skip(value));
  457. 	//如果返回值为NULL,说明解析不成功，删除新创建的节点。
  458. 	if (!end)
  459. 	{
  460. 		cJSON_Delete(c);
  461. 		return 0;
  462. 	}	/*如果解析失败，ep已经被指向了错误原因了。 */
  464. 	/* 如果我们要求以NULL结尾，那么检测是否以NULL进行结尾的。不然就释放内存并将ep指向出错的位置*/
  465. 	if (require_null_terminated)
  466. 	{
  467. 		end=skip(end);
  468. 		if (*end) 
  469. 		{
  470. 			cJSON_Delete(c);
  471. 			ep=end;
  472. 			return 0;
  473. 		}
  474. 	}
  475. 	//将当前的结束位置进行赋值回传。
  476. 	if (return_parse_end) 
  477. 		*return_parse_end=end;
  478. 	return c;
  479. }
  480. /* cJSON_Parse 调用缺省的选项进行解析*/
  481. cJSON *cJSON_Parse(const char *value) 
  482. {
  483. 	return cJSON_ParseWithOpts(value,0,0);
  485. }
  487. /* 打印cJSON到文本中调用. print_value*/
  488. char *cJSON_Print(cJSON *item)				{return print_value(item,0,1,0);}
  489. /* 打印无格式的cJSON到文本中调用. print_value*/
  490. char *cJSON_PrintUnformatted(cJSON *item)	{return print_value(item,0,0,0);}
  491. /* 打印cJSON到缓存中 调用. print_value*/
  492. /*item为待解析打印的json数据，prebuffer为预分配到缓存的大小，fmt控制是否需要json格式*/
  493. char *cJSON_PrintBuffered(cJSON *item,int prebuffer,int fmt)
  494. {
  495. 	printbuffer p;
  496. 	p.buffer=(char*)cJSON_malloc(prebuffer);
  497. 	p.length=prebuffer;
  498. 	p.offset=0;
  499. 	return print_value(item,0,fmt,&p);
  500. 	return p.buffer;
  501. }
  505. /*解析器的核心，遇到什么格式就进行什么格式的解析，从这里进入的解析一般还会递归回来调用这里的功能。*/
  506. static const char *parse_value(cJSON *item,const char *value)
  507. {
  508. 	if (!value)						return 0;	/* Fail on null. */
  509. 	//三种特定的数据类型，直接赋值item->type，并返回之后的数据。
  510. 	if (!strncmp(value,"null",4))	{ item->type=cJSON_NULL;  return value+4; }
  511. 	if (!strncmp(value,"false",5))	{ item->type=cJSON_False; return value+5; }
  512. 	if (!strncmp(value,"true",4))	{ item->type=cJSON_True; item->valueint=1;	return value+4; }
  513. 	//如果是引号开头的值传入，那么就进行解析字符串。
  514. 	if (*value=='\"')				{ return parse_string(item,value); }
  515. 	//解析数字
  516. 	if (*value=='-' || (*value>='0' && *value<='9'))	{ return parse_number(item,value); }
  517. 	//解析数组，
  518. 	if (*value=='[')				{ return parse_array(item,value); }
  519. 	//解析一个对象，递归着
  520. 	if (*value=='{')				{ return parse_object(item,value); }
  521. 	//如果到了这里，那么就置ep指针到出错的字串位置，然后返回0；
  522. 	ep=value;return 0;	/* failure. */
  523. }
  525. /*打印一个值到文本方式中. */
  526. /*item为待打印的对象，depth 当前对象到根节点的深度  fmt 是否打印json格式， p为缓存入口*/
  527. /*返回将item中数据组织成一个串的起始地址，也会被递归的调用，一般情况下*/
  528. static char *print_value(cJSON *item,int depth,int fmt,printbuffer *p)
  529. {
  530. 	char *out=0;
  531. 	if (!item) return 0;
  532. 	if (p)
  533. 	{//使用缓存模式进行打印，验证类型进入不同的打印方式cJSON_Object，cJSON_Array会递归调用的
  534. 		switch ((item->type)&255)
  535. 		{
  536. 			case cJSON_NULL:	{out=ensure(p,5);	if (out) strcpy(out,"null");	break;}
  537. 			case cJSON_False:	{out=ensure(p,6);	if (out) strcpy(out,"false");	break;}
  538. 			case cJSON_True:	{out=ensure(p,5);	if (out) strcpy(out,"true");	break;}
  539. 			case cJSON_Number:	out=print_number(item,p);break;
  540. 			case cJSON_String:	out=print_string(item,p);break;
  541. 			case cJSON_Array:	out=print_array(item,depth,fmt,p);break;
  542. 			case cJSON_Object:	out=print_object(item,depth,fmt,p);break;
  543. 		}
  544. 	}
  545. 	else
  546. 	{
  547. 		switch ((item->type)&255)
  548. 		{//不适用缓存方式进行打印值，cJSON_Object，cJSON_Array会递归调用的
  549. 			case cJSON_NULL:	out=cJSON_strdup("null");	break;
  550. 			case cJSON_False:	out=cJSON_strdup("false");break;
  551. 			case cJSON_True:	out=cJSON_strdup("true"); break;
  552. 			case cJSON_Number:	out=print_number(item,0);break;
  553. 			case cJSON_String:	out=print_string(item,0);break;
  554. 			case cJSON_Array:	out=print_array(item,depth,fmt,0);break;
  555. 			case cJSON_Object:	out=print_object(item,depth,fmt,0);break;
  556. 		}
  557. 	}
  558. 	return out;
  559. }
  561. /* 根据输入的文本，建立一个数组 */
  562. static const char *parse_array(cJSON *item,const char *value)
  563. {
  564. 	cJSON *child;
  565. 	if (*value!='[')	{ep=value;return 0;}	/* not an array! */
  566. 	//验证为数组的value，对类型进行赋值，对value进行去除不可见字符，并判断空对象数组。
  567. 	item->type=cJSON_Array;
  568. 	value=skip(value+1);
  569. 	if (*value==']') return value+1;	/* empty array. */
  570. 	//为数组建立一个孩子节点。并检查内存分配，跳过不可见字符，并调用parse_value取得值
  571. 	item->child=child=cJSON_New_Item();
  572. 	if (!item->child) return 0;		 /* memory fail */
  573. 	value=skip(parse_value(child,skip(value)));	/* skip any spacing, get the value. */
  574. 	if (!value) return 0;
  575. 	//如果还有兄弟节点，即数组有多个元素，那么进行循环创建，链接，解析值。
  576. 	while (*value==',')
  577. 	{
  578. 		cJSON *new_item;
  579. 		if (!(new_item=cJSON_New_Item())) return 0; 	/* memory fail */
  580. 		child->next=new_item;new_item->prev=child;child=new_item;
  581. 		value=skip(parse_value(child,skip(value+1)));
  582. 		if (!value) return 0;	/* memory fail */
  583. 	}
  584. 	//检查是否存在数组结束的右括号，然后返回结束位置，或者置位错误指向出错位置，然后返回0
  585. 	if (*value==']') return value+1;	/* end of array */
  586. 	ep=value;return 0;	/* malformed. */
  587. }
  589. /* 将对象数组打印成文本 */
  590. static char *print_array(cJSON *item,int depth,int fmt,printbuffer *p)
  591. {
  592. 	char **entries;
  593. 	char *out=0,*ptr,*ret;int len=5;
  594. 	//获得数组的孩子，即第一个元素
  595. 	cJSON *child=item->child;
  596. 	int numentries=0,i=0,fail=0;
  597. 	size_t tmplen=0;
  598. 	//计算有多少个元素在这个数组里。
  599. 	/* How many entries in the array? */
  600. 	while (child) numentries++,child=child->next;
  601. 	/*如果这个数组为空，那么就打印一个[]出来就好了。*/
  602. 	if (!numentries)
  603. 	{
  604. 		if (p)	out=ensure(p,3);
  605. 		else	out=(char*)cJSON_malloc(3);
  606. 		if (out) strcpy(out,"[]");
  607. 		return out;
  608. 	}
  609. 	//如果是以缓存方式打印出来的话进这个分支
  610. 	if (p)
  611. 	{
  612. 		/* Compose the output array. */
  613. 		//先将[括号写进缓存中
  614. 		i=p->offset;
  615. 		ptr=ensure(p,1);if (!ptr) return 0;	*ptr='[';	p->offset++;
  616. 		//从第一个孩子开始进行遍历
  617. 		child=item->child;
  618. 		while (child && !fail)
  619. 		{	//打印这个孩子值到缓存中，并更新缓存中offset值。
  620. 			print_value(child,depth+1,fmt,p);
  621. 			p->offset=update(p);
  622. 			//判断是否需要格式打印，并根据此进行分配空间，格式化的会在有空格符号插入
  623. 			if (child->next) 
  624. 			{
  625. 				len=fmt?2:1;ptr=ensure(p,len+1);
  626. 				if (!ptr) 
  627. 					return 0;
  628. 				*ptr++=',';
  629. 				if(fmt)
  630. 					*ptr++=' ';
  631. 				*ptr=0;
  632. 				p->offset+=len;
  634. 			}
  635. 			//遍历传递
  636. 			child=child->next;
  637. 		}
  638. 		//输出右括号，并将out指向这次填充的最开始处
  639. 		ptr=ensure(p,2);if (!ptr) return 0;	*ptr++=']';*ptr=0;
  640. 		out=(p->buffer)+i;
  641. 	}
  642. 	else
  643. 	{//不使用缓存，那么就根据元素个数申请二维字符指针，并检查内存申请，初始化指针为NULL。
  644. 		/* Allocate an array to hold the values for each */
  645. 		entries=(char**)cJSON_malloc(numentries*sizeof(char*));
  646. 		if (!entries) return 0;
  647. 		memset(entries,0,numentries*sizeof(char*));
  648. 		/* 遍历所有的元素 */
  649. 		child=item->child;
  650. 		while (child && !fail)
  651. 		{
  652. 			//使用中间变量进行遍历并将结果全都放入二维指针中。
  653. 			ret=print_value(child,depth+1,fmt,0);
  654. 			entries[i++]=ret;
  655. 			//判断是否解析值出错。并计算长度
  656. 			if (ret) 
  657. 				len+=strlen(ret)+2+(fmt?1:0); 
  658. 			else 
  659. 				fail=1;
  660. 			child=child->next;
  661. 		}
  662. 		//如果没有解析错误，那么尝试分配一个输出的数组。
  663. 		/* If we didn't fail, try to malloc the output string */
  664. 		if (!fail)	out=(char*)cJSON_malloc(len);
  665. 		/* If that fails, we fail. */
  666. 		//如果分配失败，那么这次打印就失败了。
  667. 		if (!out) fail=1;
  669. 		/* 处理错误情况，将之前申请的所有内存进行释放*/
  670. 		if (fail)
  671. 		{
  672. 			for (i=0;i<numentries;i++) 
  673. 				if (entries[i]) 
  674. 					cJSON_free(entries[i]);
  675. 			cJSON_free(entries);
  676. 			return 0;
  677. 		}
  678. 		//没有错误情况，那么就将所有的字符串全都复制到新开辟的大的串中，准备输出。
  679. 		/* Compose the output array. */
  680. 		*out='[';
  681. 		ptr=out+1;*ptr=0;
  682. 		for (i=0;i<numentries;i++)
  683. 		{
  684. 			tmplen=strlen(entries[i]);memcpy(ptr,entries[i],tmplen);ptr+=tmplen;
  685. 			if (i!=numentries-1) {*ptr++=',';if(fmt)*ptr++=' ';*ptr=0;}
  686. 			cJSON_free(entries[i]);
  687. 		}
  688. 		cJSON_free(entries);
  689. 		*ptr++=']';*ptr++=0;
  690. 	}
  691. 	return out;	
  692. }
  694. /* 根据文本输入，创建一个json对象. */
  695. static const char *parse_object(cJSON *item,const char *value)
  696. {
  697. 	cJSON *child;
  698. 	if (*value!='{')	{ep=value;return 0;}	/* 文本不是对象格式 */
  699. 	//设置类型，跳过不可见字符，并检查是否为空的数组
  700. 	item->type=cJSON_Object;
  701. 	value=skip(value+1);
  702. 	if (*value=='}') return value+1;	/* empty array. */
  703. 	//创建一个孩子对象，检查内存，
  704. 	item->child=child=cJSON_New_Item();
  705. 	if (!item->child) return 0;
  706. 	//使用child->valuestring获得待解析的字符串，然后将child->valuestring的值给child->string
  707. 	value=skip(parse_string(child,skip(value)));
  708. 	if (!value) return 0;
  709. 	child->string=child->valuestring;child->valuestring=0;
  710. 	//检查时候对应有值，成对，不然就错误
  711. 	if (*value!=':') {ep=value;return 0;}	/* fail! */
  712. 	//将:后的值获取出来赋值给child，并且指针移到获取该值后字串的第一个可见字符处
  713. 	value=skip(parse_value(child,skip(value+1)));	/* skip any spacing, get the value. */
  714. 	if (!value) return 0;
  715. 	//如果存在,号 那么说明后续还要继续进行解析。并进行循环。
  716. 	while (*value==',')
  717. 	{//创建对象，并链接到链表中，然后进行解析值。如果出现了object，那么还是要递归调用。
  718. 		cJSON *new_item;
  719. 		if (!(new_item=cJSON_New_Item()))	return 0; /* memory fail */
  720. 		child->next=new_item;new_item->prev=child;child=new_item;
  721. 		value=skip(parse_string(child,skip(value+1)));
  722. 		if (!value) return 0;
  723. 		child->string=child->valuestring;child->valuestring=0;
  724. 		if (*value!=':') {ep=value;return 0;}	/* fail! */
  725. 		value=skip(parse_value(child,skip(value+1)));	/* skip any spacing, get the value. */
  726. 		if (!value) return 0;
  727. 	}
  728. 	//检查是否出现结束的右大括号。返回最后一个值结束的位置，或者返回0并置位ep
  729. 	if (*value=='}') return value+1;	/* end of array */
  730. 	ep=value;return 0;	/* malformed. */
  731. }
  733. /* 将一个对象，打印到文本中 */
  734. static char *print_object(cJSON *item,int depth,int fmt,printbuffer *p)
  735. {
  736. 	char **entries=0,**names=0;
  737. 	char *out=0,*ptr,*ret,*str;
  738. 	int len=7,i=0,j;
  739. 	//获取根节点的孩子节点
  740. 	cJSON *child=item->child;
  741. 	int numentries=0,fail=0;
  742. 	size_t tmplen=0;
  743. 	/* Count the number of entries. */
  744. 	//计算其内包含的节点个数
  745. 	while (child) numentries++,child=child->next;
  746. 	/* Explicitly handle empty object case */
  747. 	//如果是个空的json对象，那么就打印一个空的花括号对。根据是否有格式选择转义字符
  748. 	//根据p决定将这个字符串输出的位置。
  749. 	//这里depth可以计算应该缩进的字符数
  750. 	if (!numentries)
  751. 	{
  752. 		if (p) out=ensure(p,fmt?depth+4:3);
  753. 		else	out=(char*)cJSON_malloc(fmt?depth+4:3);
  754. 		if (!out)	return 0;
  755. 		ptr=out;*ptr++='{';
  756. 		if (fmt) {*ptr++='\n';for (i=0;i<depth-1;i++) *ptr++='\t';}
  757. 		*ptr++='}';*ptr++=0;
  758. 		return out;
  759. 	}
  760. 	//如果是要求打印到缓存中去，那么进入这个处理逻辑
  761. 	if (p)
  762. 	{
  763. 		/* Compose the output: */
  765. 		//计算内训需求，将左括号和换行符输出到缓存中
  766. 		i=p->offset;
  767. 		len=fmt?2:1;	ptr=ensure(p,len+1);	if (!ptr) return 0;
  768. 		*ptr++='{';	if (fmt) *ptr++='\n';	*ptr=0;	p->offset+=len;
  769. 		//遍历孩子节点的子节点
  770. 		child=item->child;depth++;
  771. 		while (child)
  772. 		{//fmt格式输出，那么先打印应该输入的缩进再说。
  773. 			if (fmt)
  774. 			{
  775. 				ptr=ensure(p,depth);	if (!ptr) return 0;
  776. 				for (j=0;j<depth;j++) *ptr++='\t';
  777. 				p->offset+=depth;
  778. 			}
  779. 			//打印字符串到缓存中，并更新offset值
  780. 			print_string_ptr(child->string,p);
  781. 			p->offset=update(p);
  782. 			//处理冒号和格式
  783. 			len=fmt?2:1;
  784. 			ptr=ensure(p,len);	if (!ptr) return 0;
  785. 			*ptr++=':';if (fmt) *ptr++='\t';
  786. 			p->offset+=len;
  787. 			//将值解析出来放到p指向的缓存中，然后更新offset
  788. 			print_value(child,depth,fmt,p);
  789. 			p->offset=update(p);
  790. 			//计算长度，确保内存容量，检查是否还有后续节点，然后换行后进行下一个节点的遍历
  791. 			len=(fmt?1:0)+(child->next?1:0);
  792. 			ptr=ensure(p,len+1); if (!ptr) return 0;
  793. 			if (child->next) *ptr++=',';
  794. 			if (fmt) *ptr++='\n';*ptr=0;
  795. 			p->offset+=len;
  796. 			child=child->next;
  797. 		}
  798. 		//将右括号合上
  799. 		ptr=ensure(p,fmt?(depth+1):2);	 if (!ptr) return 0;
  800. 		if (fmt)	for (i=0;i<depth-1;i++) *ptr++='\t';
  801. 		*ptr++='}';*ptr=0;
  802. 		out=(p->buffer)+i;
  803. 	}
  804. 	else
  805. 	{//不使用缓存的情况下，先分配二维字符指针出来，并检查内存。初始化为0
  806. 		/* Allocate space for the names and the objects */
  807. 		entries=(char**)cJSON_malloc(numentries*sizeof(char*));
  808. 		if (!entries) return 0;
  809. 		names=(char**)cJSON_malloc(numentries*sizeof(char*));
  810. 		if (!names) {cJSON_free(entries);return 0;}
  811. 		memset(entries,0,sizeof(char*)*numentries);
  812. 		memset(names,0,sizeof(char*)*numentries);
  814. 		/* Collect all the results into our arrays: */
  815. 		//循环递归将所有的值都挂载在二维数组上
  816. 		child=item->child;depth++;if (fmt) len+=depth;
  817. 		while (child)
  818. 		{
  819. 			names[i]=str=print_string_ptr(child->string,0);
  820. 			entries[i++]=ret=print_value(child,depth,fmt,0);
  821. 			if (str && ret) len+=strlen(ret)+strlen(str)+2+(fmt?2+depth:0); else fail=1;
  822. 			child=child->next;
  823. 		}
  824. 		
  825. 		/* Try to allocate the output string */
  826. 		//申请一个总的输出字串数组，检查内存
  827. 		if (!fail)	out=(char*)cJSON_malloc(len);
  828. 		if (!out) fail=1;
  830. 		/* Handle failure */
  831. 		//分配失败，那么将所有的已分配的内存均进行释放
  832. 		if (fail)
  833. 		{
  834. 			for (i=0;i<numentries;i++) {if (names[i]) cJSON_free(names[i]);if (entries[i]) cJSON_free(entries[i]);}
  835. 			cJSON_free(names);cJSON_free(entries);
  836. 			return 0;
  837. 		}
  838. 		//将打印到各个子内存中的数据都拷贝一份到要返回的大内存中。并将原有的子内存进行释放
  839. 		/* Compose the output: */
  840. 		*out='{';ptr=out+1;if (fmt)*ptr++='\n';*ptr=0;
  841. 		for (i=0;i<numentries;i++)
  842. 		{
  843. 			if (fmt) for (j=0;j<depth;j++) *ptr++='\t';
  844. 			tmplen=strlen(names[i]);memcpy(ptr,names[i],tmplen);ptr+=tmplen;
  845. 			*ptr++=':';if (fmt) *ptr++='\t';
  846. 			strcpy(ptr,entries[i]);ptr+=strlen(entries[i]);
  847. 			if (i!=numentries-1) *ptr++=',';
  848. 			if (fmt) *ptr++='\n';*ptr=0;
  849. 			cJSON_free(names[i]);cJSON_free(entries[i]);
  850. 		}
  851. 		//补齐右括号
  852. 		cJSON_free(names);cJSON_free(entries);
  853. 		if (fmt) for (i=0;i<depth-1;i++) *ptr++='\t';
  854. 		*ptr++='}';*ptr++=0;
  855. 	}
  856. 	return out;	
  857. }
  859. /* Get Array size/item / object item. */
  860. //获取数组的元素个数
  861. int    cJSON_GetArraySize(cJSON *array)
  862. {
  863. 	cJSON *c=array->child;
  864. 	int i=0;
  865. 	while(c)
  866. 		i++,c=c->next;
  867. 	return i;
  869. }
  870. //获取array中第item个元素的入口
  871. cJSON *cJSON_GetArrayItem(cJSON *array,int item)
  872. {
  873. 	cJSON *c=array->child; 
  874. 	while (c && item>0) 
  875. 		item--,c=c->next; 
  876. 	return c;
  878. }
  879. //获取对象object中名字为string的item。
  880. cJSON *cJSON_GetObjectItem(cJSON *object,const char *string)	
  881. {
  882. 	cJSON *c=object->child;
  883. 	while (c && cJSON_strcasecmp(c->string,string))
  884. 		c=c->next;
  885. 	return c;
  887. }
  889. /* Utility for array list handling. */
  890. //将item链接到prev之后
  891. static void suffix_object(cJSON *prev,cJSON *item) {prev->next=item;item->prev=prev;}
  892. /* Utility for handling references. */
  893. //创建一个参照对象，复制一个item，新item的type为cJSON_IsReference
  894. static cJSON *create_reference(cJSON *item)
  895. {
  896. 	cJSON *ref=cJSON_New_Item();
  897. 	if (!ref)
  898. 		return 0;
  899. 	memcpy(ref,item,sizeof(cJSON));
  900. 	ref->string=0;
  901. 	ref->type|=cJSON_IsReference;
  902. 	ref->next=ref->prev=0;
  903. 	return ref;
  905. }
  907. /* Add item to array/object. */
  908. /*添加项目到数组或者对象之中*/
  909. //将item添加到array中
  910. void   cJSON_AddItemToArray(cJSON *array, cJSON *item)		
  911. {//获得array的第一个节点
  912. 	cJSON *c=array->child;
  913. 	if (!item)
  914. 		return; 
  915. 	if (!c)//如果原本就是空的数组
  916. 		{array->child=item;} 
  917. 	else
  918. 	{//找到最后一个节点，然后将item挂上
  919. 		while (c && c->next) 
  920. 			c=c->next; 
  921. 		suffix_object(c,item);
  923. 	}
  925. }
  926. /*将一个项目item，名字为string，添加到object中*/
  927. void   cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item)	
  928. {
  929. 	if (!item) return; 
  930. 	if (item->string) //清理原有的名字
  931. 		cJSON_free(item->string);
  932. 	item->string=cJSON_strdup(string);
  933. 	cJSON_AddItemToArray(object,item);//将object当成一个array来看待
  934. }
  935. //将一个名字为字符串常量的item，添加到object中，设置type为cJSON_StringIsConst
  936. void   cJSON_AddItemToObjectCS(cJSON *object,const char *string,cJSON *item)
  937. {
  938. 	if (!item) return; 
  939. 	if (!(item->type&cJSON_StringIsConst) && item->string) 
  940. 		cJSON_free(item->string);
  941. 	item->string=(char*)string;
  942. 	item->type|=cJSON_StringIsConst;
  943. 	cJSON_AddItemToArray(object,item);
  944. }
  945. //将item复制一份出来，添加到array中
  946. void	cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)	{cJSON_AddItemToArray(array,create_reference(item));}
  947. //将名字为string的item复制一份出来，添加到object中
  948. void	cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item)	{cJSON_AddItemToObject(object,string,create_reference(item));}
  949. //将array中的第which个item从array中摘取下来，作为返回值。
  950. cJSON *cJSON_DetachItemFromArray(cJSON *array,int which)		
  951. {
  952. 	cJSON *c=array->child;
  953. 	while (c && which>0)
  954. 		c=c->next,which--;
  955. 	if (!c) return 0;
  956. 	if (c->prev)//找到第which个item，从链中摘下来
  957. 		c->prev->next=c->next;
  958. 	if (c->next) 
  959. 		c->next->prev=c->prev;
  960. 	if (c==array->child) //如果是第一个孩子节点
  961. 		array->child=c->next;
  962. 	c->prev=c->next=0;
  963. 	return c;
  965. }
  966. //从array中删除第which个元素
  967. void   cJSON_DeleteItemFromArray(cJSON *array,int which)	{cJSON_Delete(cJSON_DetachItemFromArray(array,which));}
  968. //从object中摘除名字为string的item，返回这个item
  969. cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string) 
  970. {
  971. 	int i=0;
  972. 	cJSON *c=object->child;
  973. 	while (c && cJSON_strcasecmp(c->string,string)) 
  974. 		i++,c=c->next;//遍历找到这个string名字的item
  975. 	if (c)//找到了就从object中把它移除。
  976. 		return cJSON_DetachItemFromArray(object,i);
  977. 	return 0;
  979. }
  980. //将指定名字string的item从object中删除
  981. void cJSON_DeleteItemFromObject(cJSON *object,const char *string) {cJSON_Delete(cJSON_DetachItemFromObject(object,string));}
  983. /* 插入一个newitem到第which个位置，如果不存在这个位置，那么就随意加到一个位置*/
  984. void   cJSON_InsertItemInArray(cJSON *array,int which,cJSON *newitem)
  985. {
  986. 	cJSON *c=array->child;
  987. 	while (c && which>0)
  988. 		c=c->next,which--;
  989. 	if (!c)
  990. 	{//如果遍历完或者which个，没有找到有效的item，那么就将newitem插入到array中
  991. 		cJSON_AddItemToArray(array,newitem);
  992. 		return;
  993. 	}
  994. 	//将newitem挂载节点c的前面
  995. 	newitem->next=c;
  996. 	newitem->prev=c->prev;
  997. 	c->prev=newitem;
  998. 	if (c==array->child) //为第一个节点
  999. 		array->child=newitem;
  1000. 	else
  1001. 		newitem->prev->next=newitem;
  1003. }
  1004. void   cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem)	
  1005. {
  1006. 	cJSON *c=array->child;
  1007. 	while (c && which>0)
  1008. 		c=c->next,which--;
  1009. 	if (!c)//找不到第which个item
  1010. 		return;
  1011. 	//将newitem插入到第which个item个位置，将原有的item摘下来(c)。
  1012. 	newitem->next=c->next;
  1013. 	newitem->prev=c->prev;
  1014. 	if (newitem->next)
  1015. 		newitem->next->prev=newitem;
  1016. 	if (c==array->child)
  1017. 		array->child=newitem; 
  1018. 	else 
  1019. 		newitem->prev->next=newitem;
  1020. 	c->next=c->prev=0;
  1021. 	cJSON_Delete(c);//将摘下来的c节点清除掉
  1023. }
  1024. //将object中名字为string的item替换为newitem
  1025. void   cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem)
  1026. {
  1027. 	int i=0;
  1028. 	cJSON *c=object->child;
  1029. 	while(c && cJSON_strcasecmp(c->string,string))
  1030. 		i++,c=c->next;//找到名字为string的这个item
  1031. 	if(c)
  1032. 	{
  1033. 		newitem->string=cJSON_strdup(string);//需要重新分配一个内存作为名字string的值
  1034. 		cJSON_ReplaceItemInArray(object,i,newitem);//插入到前文找到的第i个位置
  1035. 	}
  1037. }
  1039. /* Create basic types: */
  1040. //创建一个NULL类型的cjson对象object
  1041. cJSON *cJSON_CreateNull(void)					    {cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_NULL;return item;}
  1042. //创建一个True类型的cjson对象object
  1043. cJSON *cJSON_CreateTrue(void)					{cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_True;return item;}
  1044. //创建一个False类型的cjson对象object
  1045. cJSON *cJSON_CreateFalse(void)					{cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_False;return item;}
  1046. //创建一个Bool类型的cjson对象object,然后根据b的值决定item->type是等于cJSON_True还是cJSON_False
  1047. cJSON *cJSON_CreateBool(int b)					{cJSON *item=cJSON_New_Item();if(item)item->type=b?cJSON_True:cJSON_False;return item;}
  1048. //创建一个cJSON_Number类型的cjson对象object,其值为num
  1049. cJSON *cJSON_CreateNumber(double num)			{cJSON *item=cJSON_New_Item();if(item){item->type=cJSON_Number;item->valuedouble=num;item->valueint=(int)num;}return item;}
  1050. //创建一个cJSON_String类型的cjson对象object,其值为string
  1051. cJSON *cJSON_CreateString(const char *string)	{cJSON *item=cJSON_New_Item();if(item){item->type=cJSON_String;item->valuestring=cJSON_strdup(string);}return item;}
  1052. //创建一个cJSON_Array类型的cjson对象object
  1053. cJSON *cJSON_CreateArray(void)					{cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_Array;return item;}
  1054. //创建一个cJSON_Object类型的cjson对象object
  1055. cJSON *cJSON_CreateObject(void)					{cJSON *item=cJSON_New_Item();if(item)item->type=cJSON_Object;return item;}
  1057. /* Create Arrays: */
  1058. /*创建数组*/
  1059. //创建一个int类型的array，array中有count个元素，值分别为number
  1060. cJSON *cJSON_CreateIntArray(const int *numbers,int count)		
  1061. {
  1062. 	int i;
  1063. 	cJSON *n=0,*p=0,*a=cJSON_CreateArray();//创建一个array
  1064. 	for(i=0;a && i<count;i++)
  1065. 	{//创建number类型的对象，并赋值
  1066. 		n=cJSON_CreateNumber(numbers[i]);
  1067. 		if(!i)//第一个元素为孩子节点
  1068. 			a->child=n;
  1069. 		else //其他为兄弟节点挂接方式
  1070. 			suffix_object(p,n);
  1071. 		p=n;
  1072. 	}
  1073. 	return a;
  1074. }
  1075. //创建一个float类型的array，array中有count个元素，值分别为number
  1076. cJSON *cJSON_CreateFloatArray(const float *numbers,int count)	{int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
  1077. //创建一个double类型的array，array中有count个元素，值分别为number
  1078. cJSON *cJSON_CreateDoubleArray(const double *numbers,int count)	{int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
  1079. //创建一个string类型的array，array中有count个元素，值分别为number
  1080. cJSON *cJSON_CreateStringArray(const char **strings,int count)	{int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;a && i<count;i++){n=cJSON_CreateString(strings[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}
  1082. /* 复制item并返回，recurse决定是否递归的将item的子节点也都复制一份 */
  1083. cJSON *cJSON_Duplicate(cJSON *item,int recurse)
  1084. {
  1085. 	cJSON *newitem,*cptr,*nptr=0,*newchild;
  1086. 	/* Bail on bad ptr */
  1087. 	//item值非法
  1088. 	if (!item) return 0;
  1089. 	/* Create new item */
  1090. 	//创建一个新的item，并检查内存
  1091. 	newitem=cJSON_New_Item();
  1092. 	if (!newitem) return 0;
  1093. 	/* Copy over all vars */
  1094. 	//拷贝所有的值到newitem中
  1095. 	newitem->type=item->type&(~cJSON_IsReference),newitem->valueint=item->valueint,newitem->valuedouble=item->valuedouble;
  1096. 	if (item->valuestring)	
  1097. 	{
  1098. 		newitem->valuestring=cJSON_strdup(item->valuestring);	
  1099. 		if (!newitem->valuestring)
  1100. 		{
  1101. 			cJSON_Delete(newitem);
  1102. 			return 0;
  1104. 		}
  1105. 	}//如果是valuestring的值
  1106. 	if (item->string)		
  1107. 	{
  1108. 		newitem->string=cJSON_strdup(item->string);	
  1109. 		if (!newitem->string)		
  1110. 		{cJSON_Delete(newitem);return 0;}
  1112. 	}//名字name的值
  1113. 	/* If non-recursive, then we're done! */
  1114. 	//判断是否需要递归的进行复制子节点
  1115. 	if (!recurse) return newitem;
  1116. 	/* Walk the ->next chain for the child. */
  1117. 	//走到子节点上，然后遍历整个链表进行递归的复制。
  1118. 	cptr=item->child;
  1119. 	while (cptr)
  1120. 	{//是个递归的过程，可以尝试gdb单步跟踪理解。
  1121. 		newchild=cJSON_Duplicate(cptr,1);		/* Duplicate (with recurse) each item in the ->next chain */
  1122. 		if (!newchild) {cJSON_Delete(newitem);return 0;}//如果没有成功申请子节点内存，那么就报错返回
  1123. 		if (nptr)	
  1124. 		{nptr->next=newchild,newchild->prev=nptr;nptr=newchild;}	/* 是兄弟节点则挂链*/
  1125. 		else		
  1126. 		{newitem->child=newchild;nptr=newchild;}					/* 是孩子节点则设置指针 */
  1127. 		cptr=cptr->next;
  1128. 	}
  1129. 	return newitem;
  1130. }
  1131. //一个mini版本的json数据遍历功能
  1132. void cJSON_Minify(char *json)
  1133. {
  1134. 	char *into=json;
  1135. 	while (*json)
  1136. 	{
  1137. 		if (*json==' ') json++;
  1138. 		else if (*json=='\t') json++;	/* Whitespace characters. */
  1139. 		else if (*json=='\r') json++;
  1140. 		else if (*json=='\n') json++;
  1141. 		else if (*json=='/' && json[1]=='/')  while (*json && *json!='\n') json++;	/* double-slash comments, to end of line. */
  1142. 		else if (*json=='/' && json[1]=='*') {while (*json && !(*json=='*' && json[1]=='/')) json++;json+=2;}	/* multiline comments. */
  1143. 		else if (*json=='\"'){*into++=*json++;while (*json && *json!='\"'){if (*json=='\\') *into++=*json++;*into++=*json++;}*into++=*json++;} /* string literals, which are \" sensitive. */
  1144. 		else *into++=*json++;			/* All other characters. */
  1145. 	}
  1146. 	*into=0;	/* and null-terminate. */
  1147. }









    

附件列表

     

    posted on 2017-08-28 11:32  cfzhang  阅读(2781)  评论(0)  编辑  收藏  举报

    导航