1 /******************************************************************************
2 * cJSON_hacking
3 *
4 * 1.这是cJSON中cJSON.c(主程序)的源码,源码不到1000行(除注释).
5 * 2.本文仅仅注释了源码中JSON解析部分,对链表的操作没有进行任何注释,通过
6 * 分析阅读该源码,可以一窥双向链表,字符串处理,里面几个地方使用到了递归,
7 * 而且用得很精妙,但在理解上可能会有点困难.
8 * 3.源码作者在解析JSON时参考了: http://www.json.org/fatfree.html
9 * 如果您要阅读本程序,请先阅读该网页内容,因为源码中几个重要的函数的处理
10 * 都参照了该网页上的处理算法.
11 * 4.知识量:
12 * 1.C语言;
13 * 2.2.Unix或类Unix系统编程;
14 * 3.对双向链表的数据结构清晰;
15 * 5.如何阅读该源码:
16 * 1.linux下使用vi/vim配和ctags，windows下使用Source Insight，当然你也
17 * 可以用其他文本编辑器看.
18 * 2.该源码无主函数,本人自己是从第一个函数开始阅读,然后慢慢的看懂,
19 * 并了解了整个源码的大局,但本人强烈建议您从该函数开始阅读:
20 * cJSON *cJSON_Parse( const char *value ).
21 * 主要是因为这是默认的解析函数.
22 * 3.对于有些函数，本人没有添加注释，或者说本人觉得没必要.
23 * 4.祝您好运. :)
24 *
25 *
26 * 6.cJSON下载url: http://sourceforge.net/projects/cjson/
27 *
28 * 如果您对本文有任何意见、提议，可以发邮件至zengjf42＠163.com，会尽快回复.
29 * 本文的最终解释权归本人(曾剑锋)所有，仅供学习、讨论.
30 *
31 * 2015-3-3 阴 深圳 尚观 Var
32 *
33 ******************************************************************************/
34
35
36 /*
37 * Copyright (c) 2009 Dave Gamble
38 *
39 * Permission is hereby granted, free of charge, to any person obtaining a copy
40 * of this software and associated documentation files (the "Software"), to deal
41 * in the Software without restriction, including without limitation the rights
42 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
43 * copies of the Software, and to permit persons to whom the Software is
44 * furnished to do so, subject to the following conditions:
45 *
46 * The above copyright notice and this permission notice shall be included in
47 * all copies or substantial portions of the Software.
48 *
49 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
50 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
51 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
52 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
53 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
54 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
55 * THE SOFTWARE.
56 */
57
58 /* cJSON */
59 /* JSON parser in C. */
60
61 #include <string.h>
62 #include <stdio.h>
63 #include <math.h>
64 #include <stdlib.h>
65 #include <float.h>
66 #include <limits.h>
67 #include <ctype.h>
68 #include "cJSON.h"
69
70 /**
71 * 返回解析出错时对应的字符地址.
72 */
73 static const char *ep; /* error pointer */
74 const char *cJSON_GetErrorPtr( void )
75 {
76 return(ep);
77 }
78
79
80 /**
81 * 不分大小写字符串比较,感觉和原生的strcasecmp没什么区别.
82 */
83 static int cJSON_strcasecmp( const char *s1, const char *s2 )
84 {
85 if ( !s1 )
86 return( (s1 == s2) ? 0 : 1);
87 if ( !s2 )
88 return(1);
89 for (; tolower( *s1 ) == tolower( *s2 ); ++s1, ++s2 )
90 if ( *s1 == 0 )
91 return(0);
92 return(tolower( *(const unsigned char *) s1 ) - tolower( *(const unsigned char *) s2 ));
93 }
94
95
96 /**
97 * 定义cJSON中内存分配采用的方式,这里直接使用原生的malloc,free函数.
98 */
99 static void *(*cJSON_malloc)(size_t sz) = malloc;
100 static void (*cJSON_free)( void *ptr ) = free;
101
102
103 /**
104 * 定义cJSON中的字符串拷贝函数.
105 */
106 static char* cJSON_strdup( const char* str )
107 {
108 size_t len;
109 char * copy;
110
111 len = strlen( str ) + 1;
112 if ( !(copy = (char *) cJSON_malloc( len )))
113 return(0);
114 memcpy( copy, str, len );
115 return(copy);
116 }
117
118
119 /**
120 * 选择系统使用那种内存分配方式,这里使用原生的malloc、free函数.
121 */
122 void cJSON_InitHooks( cJSON_Hooks* hooks )
123 {
124 if ( !hooks ) /* Reset hooks */
125 {
126 cJSON_malloc = malloc;
127 cJSON_free = free;
128 return;
129 }
130
131 cJSON_malloc = (hooks->malloc_fn) ? hooks->malloc_fn : malloc;
132 cJSON_free = (hooks->free_fn) ? hooks->free_fn : free;
133 }
134
135
136 /**
137 * 构造一个item，同时给item赋初始值为全0,item可以理解为一个节点.
138 */
139 static cJSON *cJSON_New_Item( void )
140 {
141 cJSON* node = (cJSON *) cJSON_malloc( sizeof(cJSON));
142 if ( node )
143 memset( node, 0, sizeof(cJSON));
144 return(node);
145 }
146
147
148 /**
149 * 释放链表,对于有子链表的链表,采用递归的方式进行内存释放.
150 * 目前还没找到为什么需要 c->type & cJSON_IsReference 判断.
151 */
152 void cJSON_Delete( cJSON *c )
153 {
154 cJSON *next;
155 while ( c )
156 {
157 next = c->next;
158 if ( !(c->type & cJSON_IsReference) && c->child )
159 cJSON_Delete( c->child ); /* 递归释放内存 */
160 if ( !(c->type & cJSON_IsReference) && c->valuestring )
161 cJSON_free( c->valuestring );
162 if ( c->string )
163 cJSON_free( c->string );
164 cJSON_free( c );
165 c = next;
166 }
167 }
168
169
170 /* Parse the input text to generate a number, and populate the result into item. */
171 /**
172 * 解析数字,并把数据保存在item中对应的的地方.
173 */
174 static const char *parse_number( cJSON *item, const char *num )
175 {
176 /**
177 * 局部变量说明:
178 * 1.n : 用于保存数字;
179 * 2.sign : 数字部分的符号标志,如果是负数,就等于-1,如果是正数,就是1;
180 * 3.scale : 保存小数点后面有多少个数字的相反数;
181 * 4.subscale : 保存指数后面的数字;
182 * 5.signsubscale : 指数部分的符号标志,如果是负数,就等于-1,如果是正数,就是1.
183 *
184 * 如:
185 * num字符串: -1234.1234e4
186 * 1.n = 12341234;
187 * 2.sign = -1;
188 * 3.scale = -4;
189 * 4.subscale = 4;
190 * 5.signsubscale = 1;
191 *
192 * 结果公式 = sign * n * pow( 10.0, (scale + subscale * signsubscale))
193 * n = -1 * 12341234 * pow( 10.0, (-4 + 4 * 1))
194 * n = -12341234 * pow( 10.0, 0 )
195 * n = -12341234
196 */
197 double n = 0, sign = 1, scale = 0; int subscale = 0, signsubscale = 1;
198
199 if ( *num == '-' )
200 sign = -1, num++; /* Has sign? */
201 if ( *num == '0' )
202 num++; /* is zero */
203 if ( *num >= '1' && *num <= '9' )
204 do
205 n = (n * 10.0) + (*num++ - '0');
206 while ( *num >= '0' && *num <= '9' ); /* Number? */
207 if ( *num == '.' && num[1] >= '0' && num[1] <= '9' )
208 {
209 num++;
210 do
211 n = (n * 10.0) + (*num++ - '0'), scale--;
212 while ( *num >= '0' && *num <= '9' );
213 } /* Fractional part? --> 小数部分 */
214 if ( *num == 'e' || *num == 'E' ) /* Exponent? --> 指数部分 */
215 {
216 num++; if ( *num == '+' )
217 num++;
218 else if ( *num == '-' )
219 signsubscale = -1, num++; /* With sign? */
220 while ( *num >= '0' && *num <= '9' )
221 subscale = (subscale * 10) + (*num++ - '0'); /* Number? */
222 }
223
224 n = sign * n * pow( 10.0, (scale + subscale * signsubscale)); /* number = +/- number.fraction * 10^+/- exponent */
225
226 /**
227 * 以两种形式来保存数据,在下面的函数print_number()中输出数字的时候要比较这两个数据.
228 */
229 item->valuedouble = n;
230 item->valueint = (int) n;
231 item->type = cJSON_Number;
232 return(num);
233 }
234
235
236 /* Render the number nicely from the given item into a string. */
237 /**
238 * 下面代码中使用到DBL_EPSILON,其意思是双精度最小误差;
239 * 请参考url: http://blog.csdn.net/x356982611/article/details/19922453
240 */
241 static char *print_number( cJSON *item )
242 {
243 /**
244 * 局部变量说明:
245 * 1.str : 用于指向输出的数字字符串;
246 * 2.d : 保存item中的double数字.
247 */
248 char *str;
249 double d = item->valuedouble;
250 if ( fabs( ( (double) item->valueint) - d ) <= DBL_EPSILON && d <= INT_MAX && d >= INT_MIN )
251 {
252 str = (char *) cJSON_malloc( 21 ); /* 2^64+1 can be represented in 21 chars. */
253 if ( str )
254 sprintf( str, "%d", item->valueint );
255 }else {
256 str = (char *) cJSON_malloc( 64 ); /* This is a nice tradeoff. */
257 if ( str )
258 {
259 if ( fabs( floor( d ) - d ) <= DBL_EPSILON && fabs( d ) < 1.0e60 )
260 sprintf( str, "%.0f", d );
261 else if ( fabs( d ) < 1.0e-6 || fabs( d ) > 1.0e9 )
262 sprintf( str, "%e", d );
263 else sprintf( str, "%f", d );
264 }
265 }
266 return(str);
267 }
268
269
270 static unsigned parse_hex4( const char *str )
271 {
272 /**
273 * 局部变量说明:
274 * 1.h : 保存最终返回的数据
275 */
276 unsigned h = 0;
277
278 if ( *str >= '0' && *str <= '9' )
279 h += (*str) - '0';
280 else if ( *str >= 'A' && *str <= 'F' )
281 h += 10 + (*str) - 'A';
282 else if ( *str >= 'a' && *str <= 'f' )
283 h += 10 + (*str) - 'a';
284 else return(0);
285
286 h = h << 4; str++; /* h = h << 4 <===> h = h * 16 */
287 if ( *str >= '0' && *str <= '9' )
288 h += (*str) - '0';
289 else if ( *str >= 'A' && *str <= 'F' )
290 h += 10 + (*str) - 'A';
291 else if ( *str >= 'a' && *str <= 'f' )
292 h += 10 + (*str) - 'a';
293 else return(0);
294
295 h = h << 4; str++;
296 if ( *str >= '0' && *str <= '9' )
297 h += (*str) - '0';
298 else if ( *str >= 'A' && *str <= 'F' )
299 h += 10 + (*str) - 'A';
300 else if ( *str >= 'a' && *str <= 'f' )
301 h += 10 + (*str) - 'a';
302 else return(0);
303
304 h = h << 4; str++;
305 if ( *str >= '0' && *str <= '9' )
306 h += (*str) - '0';
307 else if ( *str >= 'A' && *str <= 'F' )
308 h += 10 + (*str) - 'A';
309 else if ( *str >= 'a' && *str <= 'f' )
310 h += 10 + (*str) - 'a';
311 else return(0);
312 return(h);
313 }
314
315
316 /* Parse the input text into an unescaped cstring, and populate item. */
317 /* 将输入的文本分析到非转义cstring并填充item,目前不了解这里是什么情况 */
318 /* 不清楚这里的unicode编码格式字符的处理方式 */
319 static const unsigned char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
320 static const char *parse_string( cJSON *item, const char *str )
321 {
322 /**
323 * 局部变量说明:
324 * 1.ptr : 传入参数string的指针;
325 * 2.ptr2 : 指向输出字符串里的地址,主要用于从ptr字符串中拷贝字符到out中;
326 * 3.out : 指向动态分配的输出字符串的首地址;
327 * 4.len : 动态分配时需要的字符串的长度,分配时要在基础上+1;
328 * 5.uc : unicode编码格式字符;
329 * 6.uc2 : unicode编码格式字符.
330 */
331 const char *ptr = str + 1;
332 char *ptr2;
333 char *out;
334 int len = 0;
335 unsigned uc, uc2;
336
337 /* 判断第一个字符是否是"\"",如果不是,那么就不是字符串 */
338 if ( *str != '\"' ){ ep = str; return(0); } /* not a string! */
339
340 /* 计算字符串的长度,为后面的的内存分配提供数据长度信息 */
341 while ( *ptr != '\"' && *ptr && ++len ) if ( *ptr++ == '\\' )
342 ptr++; /* Skip escaped quotes. */
343
344 out = (char *) cJSON_malloc( len + 1 ); /* This is how long we need for the string, roughly. */
345 if ( !out )
346 return(0);
347
348 /* ptr指向'\"'后面那个字符,ptr2指向out的首地址,有利于数据拷贝 */
349 ptr = str + 1; ptr2 = out;
350 while ( *ptr != '\"' && *ptr )
351 {
352 if ( *ptr != '\\' )
353 *ptr2++ = *ptr++;
354 else{
355 ptr++;
356 switch ( *ptr )
357 {
358 case 'b': *ptr2++ = '\b'; break;
359 case 'f': *ptr2++ = '\f'; break;
360 case 'n': *ptr2++ = '\n'; break;
361 case 'r': *ptr2++ = '\r'; break;
362 case 't': *ptr2++ = '\t'; break;
363 case 'u': /* transcode utf16 to utf8. */
364 uc = parse_hex4( ptr + 1 ); ptr += 4; /* get the unicode char. */
365
366 if ( (uc >= 0xDC00 && uc <= 0xDFFF) || uc == 0 )
367 break; /* check for invalid. */
368
369 if ( uc >= 0xD800 && uc <= 0xDBFF ) /* UTF16 surrogate pairs. */
370 {
371 if ( ptr[1] != '\\' || ptr[2] != 'u' )
372 break; /* missing second-half of surrogate. */
373 uc2 = parse_hex4( ptr + 3 ); ptr += 6;
374 if ( uc2 < 0xDC00 || uc2 > 0xDFFF )
375 break; /* invalid second-half of surrogate. */
376 uc = 0x10000 + ( ( (uc & 0x3FF) << 10) | (uc2 & 0x3FF));
377 }
378
379 len = 4; if ( uc < 0x80 )
380 len = 1;
381 else if ( uc < 0x800 )
382 len = 2;
383 else if ( uc < 0x10000 )
384 len = 3;
385 ptr2 += len;
386
387 switch ( len )
388 {
389 case 4: *--ptr2 = ( (uc | 0x80) & 0xBF); uc >>= 6;
390 case 3: *--ptr2 = ( (uc | 0x80) & 0xBF); uc >>= 6;
391 case 2: *--ptr2 = ( (uc | 0x80) & 0xBF); uc >>= 6;
392 case 1: *--ptr2 = (uc | firstByteMark[len]);
393 }
394 ptr2 += len;
395 break;
396 default: *ptr2++ = *ptr; break;
397 }
398 ptr++;
399 }
400 }
401 *ptr2 = 0;
402 if ( *ptr == '\"' )
403 ptr++;
404 item->valuestring = out;
405 item->type = cJSON_String;
406 return(ptr);
407 }
408
409
410 /* Render the cstring provided to an escaped version that can be printed. */
411 static char *print_string_ptr( const char *str )
412 {
413 /**
414 * 局部变量说明:
415 * 1.ptr : 指向参数传入的str字符串;
416 * 2.ptr2 : 指向要输出的out字符串;
417 * 3.out : 输出字符串;
418 * 4.len : 输出字符串的长度,用于内存分配出输出字符串的空间大小;
419 * 5.token : 字符保存中间变量.
420 */
421 const char *ptr;
422 char *ptr2, *out;
423 int len = 0;
424 unsigned char token;
425
426 if ( !str )
427 return(cJSON_strdup( "" ));
428 /* 计算字符串需要的长度 */
429 ptr = str;
430 while ( (token = *ptr) && ++len )
431 {
432 if ( strchr( "\"\\\b\f\n\r\t", token ))
433 len++;
434 else if ( token < 32 )
435 /**
436 * 除了前面列出的空白字符,其他的空白都+5的长度,
437 * 不知道为什么,应该与unicode编码有关.
438 * 如:
439 * "\uxxxx",u再加4个字符就是5个字符,前面解析字符的时候是这么解析的.
440 */
441 len += 5;
442 ptr++;
443 }
444
445 out = (char *) cJSON_malloc( len + 3 );
446 if ( !out )
447 return(0);
448
449 ptr2 = out; ptr = str;
450 *ptr2++ = '\"';
451 while ( *ptr )
452 {
453 if ( (unsigned char) *ptr > 31 && *ptr != '\"' && *ptr != '\\' )
454 *ptr2++ = *ptr++;
455 else{
456 *ptr2++ = '\\';
457 switch ( token = *ptr++ )
458 {
459 case '\\': *ptr2++ = '\\'; break;
460 case '\"': *ptr2++ = '\"'; break;
461 case '\b': *ptr2++ = 'b'; break;
462 case '\f': *ptr2++ = 'f'; break;
463 case '\n': *ptr2++ = 'n'; break;
464 case '\r': *ptr2++ = 'r'; break;
465 case '\t': *ptr2++ = 't'; break;
466 default: sprintf( ptr2, "u%04x", token ); ptr2 += 5; break; /* escape and print */
467 }
468 }
469 }
470 *ptr2++ = '\"'; *ptr2++ = 0;
471 return(out);
472 }
473
474
475 /* Invote print_string_ptr (which is useful) on an item. */
476 static char *print_string( cJSON *item )
477 {
478 return(print_string_ptr( item->valuestring ));
479 }
480
481
482 /* Predeclare these prototypes. --> 提前声明这些原型 */
483 static const char *parse_value( cJSON *item, const char *value );
484 static char *print_value( cJSON *item, int depth, int fmt );
485 static const char *parse_array( cJSON *item, const char *value );
486 static char *print_array( cJSON *item, int depth, int fmt );
487 static const char *parse_object( cJSON *item, const char *value );
488 static char *print_object( cJSON *item, int depth, int fmt );
489
490 /* Utility to jump whitespace and cr/lf --> 跳过不可见字符,这些字符都集中在ascii的前32个字符 */
491 static const char *skip( const char *in )
492 {
493 while ( in && *in && (unsigned char) *in <= 32 )
494 in++;
495 return(in);
496 }
497
498
499 /* Parse an object - create a new root, and populate. --> 创建一个根,并填充 */
500 cJSON *cJSON_ParseWithOpts( const char *value, const char **return_parse_end, int require_null_terminated )
501 {
502 /**
503 * 局部变量说明:
504 * 1.end : 当解析完整个字符串的时候,最后一个字符如果不是NULL,则代表这个输入的value字串
505 * 可能有问题;
506 * 2.c : cJSON节点,也是所谓的根节点.
507 */
508 const char *end = 0;
509 cJSON *c = cJSON_New_Item();
510 ep = 0;
511 if ( !c )
512 return(0); /* memory fail */
513
514 end = parse_value( c, skip( value ));
515 if ( !end )
516 {
517 cJSON_Delete( c ); return(0);
518 } /* parse failure. ep is set. */
519
520 /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
521 /* 检查是否是正常的JSON结束字符串 */
522 if ( require_null_terminated )
523 {
524 end = skip( end );
525 if ( *end )
526 {
527 cJSON_Delete( c ); ep = end; return(0);
528 }
529 }
530 if ( return_parse_end )
531 *return_parse_end = end;
532 return(c);
533 }
534
535
536 /* Default options for cJSON_Parse, 默认不检查NULL终止符 */
537 cJSON *cJSON_Parse( const char *value )
538 {
539 return(cJSON_ParseWithOpts( value, 0, 0 ));
540 }
541
542
543 /* Render a cJSON item/entity/structure to text. */
544 /**
545 * print_value中的
546 * 第二个参数是代表JSON对象的深度;
547 * 地三个代码中的意思是逗号分割键值对后面是否要加空格,
548 *
549 * 如下是第三个参数事例:
550 * fmt = 0 : {"zjf":1,"jfz":2,"fjz":3}或[1,2,3,4]
551 * fmt = 1 : {"zjf":1, "jfz":2, "fjz":3}或[1, 2, 3, 4]
552 *
553 * 如上,这里提供了2中选择供我们选择使用.
554 */
555 char *cJSON_Print( cJSON *item )
556 {
557 return(print_value( item, 0, 1 ));
558 }
559
560
561 char *cJSON_PrintUnformatted( cJSON *item )
562 {
563 return(print_value( item, 0, 0 ));
564 }
565
566
567 /* Parser core - when encountering text, process appropriately. */
568 /**
569 * 根据首字符的不同来决定采用哪种方式进行解析字符串
570 */
571 static const char *parse_value( cJSON *item, const char *value )
572 {
573 if ( !value )
574 return(0); /* Fail on null. */
575 if ( !strncmp( value, "null", 4 )) { item->type = cJSON_NULL; return(value + 4); }
576 if ( !strncmp( value, "false", 5 )) { item->type = cJSON_False; return(value + 5); }
577 if ( !strncmp( value, "true", 4 )) {
578 item->type = cJSON_True; item->valueint = 1; return(value + 4);
579 }
580 if ( *value == '\"' ) { return(parse_string( item, value )); }
581 if ( *value == '-' || (*value >= '0' && *value <= '9')) {
582 return(parse_number( item, value ));
583 }
584 if ( *value == '[' ) { return(parse_array( item, value )); }
585 if ( *value == '{' ) { return(parse_object( item, value )); }
586
587 ep = value; return(0); /* failure. */
588 }
589
590
591 /* Render a value to text. */
592 /**
593 * 根据item的类型来选这使用哪种方式进行数据的输出格式
594 */
595 static char *print_value( cJSON *item, int depth, int fmt )
596 {
597 char *out = 0;
598 if ( !item )
599 return(0);
600 switch ( (item->type) & 255 )
601 {
602 case cJSON_NULL: out = cJSON_strdup( "null" ); break;
603 case cJSON_False: out = cJSON_strdup( "false" ); break;
604 case cJSON_True: out = cJSON_strdup( "true" ); break;
605 case cJSON_Number: out = print_number( item ); break;
606 case cJSON_String: out = print_string( item ); break;
607 case cJSON_Array: out = print_array( item, depth, fmt ); break;
608 case cJSON_Object: out = print_object( item, depth, fmt ); break;
609 }
610 return(out);
611 }
612
613
614 /* Build an array from input text. */
615 /**
616 * 以以下数据为格式分析:
617 * [
618 * [0, -1, 0],
619 * [1, 0, 0],
620 * [0, 0, 1]
621 * ]
622 *
623 * 1.先检测到[;
624 * 2.然后skip掉换行符,空白字符;
625 * 3.parse_value重新检测字符串,也就能再次检测又是一个数组了[0, -1, 0],
626 * 递归进入解析[0, -1, 0],并解析出0,-1,0,保存在节点中.
627 * 4.检测是否遇到','字符,如果遇到说明后面还有内容需要解析;
628 * 5.循环解析接下来的内容.
629 */
630 static const char *parse_array( cJSON *item, const char *value )
631 {
632 cJSON *child;
633 if ( *value != '[' )
634 {
635 ep = value; return(0);
636 } /* not an array! */
637
638 item->type = cJSON_Array;
639 value = skip( value + 1 );
640 if ( *value == ']' )
641 return(value + 1); /* empty array. */
642
643 item->child = child = cJSON_New_Item();
644 if ( !item->child )
645 return(0); /* memory fail */
646 value = skip( parse_value( child, skip( value ))); /* skip any spacing, get the value. */
647 if ( !value )
648 return(0);
649
650 while ( *value == ',' )
651 {
652 cJSON *new_item;
653 if ( !(new_item = cJSON_New_Item()))
654 return(0); /* memory fail */
655 child->next = new_item; new_item->prev = child; child = new_item;
656 value = skip( parse_value( child, skip( value + 1 )));
657 if ( !value )
658 return(0); /* memory fail */
659 }
660
661 if ( *value == ']' )
662 return(value + 1); /* end of array */
663 ep = value; return(0); /* malformed. --> 格式不正确 */
664 }
665
666
667 /* Render an array to text */
668 static char *print_array( cJSON *item, int depth, int fmt )
669 {
670 /**
671 * 局部变量说明:
672 * 1.entries : 输出字符串数组,本来是保存在节点中的,被提取取来报存在字符串数组中;
673 * 2.out : 合并entries字符数组中的字符串,得到out;
674 * 3.ptr : 指向out的指针;
675 * 4.ret : 函数执行结果的返回值;
676 * 5.len : 用于统计总的字符长度;
677 * 6.child : 用于指向当前正要处理的节点;
678 * 7.numentries : 用于统计总共有多少个entries;
679 * 8.i : for循环计数;
680 * 9.fail : 处理出错标志.
681 */
682 char **entries;
683 char *out = 0, *ptr, *ret;
684 int len = 5;
685 cJSON *child = item->child;
686 int numentries = 0 /*number entries*/, i = 0, fail = 0;
687
688 /* How many entries in the array? */
689 while ( child )
690 numentries++, child = child->next;
691 /* Explicitly handle numentries==0 --> 显示处理条目为0的情况 */
692 if ( !numentries )
693 {
694 out = (char *) cJSON_malloc( 3 );
695 if ( out )
696 strcpy( out, "[]" );
697 return(out);
698 }
699 /* Allocate an array to hold the values for each */
700 entries = (char * *) cJSON_malloc( numentries * sizeof(char*));
701 if ( !entries )
702 return(0);
703 memset( entries, 0, numentries * sizeof(char*));
704 /* Retrieve all the results: --> 恢复结果 */
705 child = item->child;
706 while ( child && !fail )
707 {
708 ret = print_value( child, depth + 1, fmt );
709 entries[i++] = ret;
710 if ( ret )
711 /**
712 * 为什么要加2,目前只发现需要加1就够了,因为就加了一个逗号.
713 * 不知何故........
714 * 难道是为了给那对[]留下空间?
715 */
716 len += strlen( ret ) + 2 + (fmt ? 1 : 0);
717 else fail = 1;
718 child = child->next;
719 }
720
721 /* If we didn't fail, try to malloc the output string */
722 if ( !fail )
723 out = (char *) cJSON_malloc( len );
724 /* If that fails, we fail. */
725 if ( !out )
726 fail = 1;
727
728 /* Handle failure. */
729 if ( fail )
730 {
731 for ( i = 0; i < numentries; i++ )
732 if ( entries[i] )
733 cJSON_free( entries[i] );
734 cJSON_free( entries );
735 return(0);
736 }
737
738 /* Compose the output array. --> 合成输出数组 */
739 *out = '[';
740 ptr = out + 1; *ptr = 0;
741 for ( i = 0; i < numentries; i++ )
742 {
743 strcpy( ptr, entries[i] ); ptr += strlen( entries[i] );
744 if ( i != numentries - 1 )
745 {
746 *ptr++ = ','; /* 字符和分割符 */
747 if ( fmt ) *ptr++ = ' '; /* 一个格式字符 */
748 *ptr = 0; /* 每次都结束当前字符串,但是运行后续代码,又会被取代 */
749 }
750 cJSON_free( entries[i] );
751 }
752 cJSON_free( entries );
753 *ptr++ = ']'; *ptr++ = 0;
754 return(out);
755 }
756
757
758 /* Build an object from the text. */
759 /**
760 * 以下数据为格式分析:
761 * {
762 * "name": "Jack (\"Bee\") Nimble",
763 * "format": {
764 * "type": "rect",
765 * "width": 1920,
766 * "height": 1080,
767 * "interlace": false,
768 * "frame rate": 24
769 * }
770 * }
771 *
772 * 1.检测到'{';
773 * 2.跳过空白字符,换行符;
774 * 3.通过parse_string获取name;
775 * 4.判断键值对标识符':';
776 * 5.通过parse_value获取对应的value;
777 * 6.parse_value和前面的几个函数一样,是递归函数;
778 * 7.通过while循环解析剩下的键值对.
779 */
780 static const char *parse_object( cJSON *item, const char *value )
781 {
782 cJSON *child;
783 if ( *value != '{' )
784 {
785 ep = value; return(0);
786 } /* not an object! */
787
788 item->type = cJSON_Object;
789 value = skip( value + 1 );
790 if ( *value == '}' )
791 return(value + 1); /* empty array. */
792
793 item->child = child = cJSON_New_Item();
794 if ( !item->child )
795 return(0);
796 value = skip( parse_string( child, skip( value )));
797 if ( !value )
798 return(0);
799 child->string = child->valuestring; child->valuestring = 0;
800 if ( *value != ':' )
801 {
802 ep = value; return(0);
803 } /* fail! */
804 value = skip( parse_value( child, skip( value + 1 ))); /* skip any spacing, get the value. */
805 if ( !value )
806 return(0);
807
808 while ( *value == ',' )
809 {
810 cJSON *new_item;
811 if ( !(new_item = cJSON_New_Item()))
812 return(0); /* memory fail */
813 child->next = new_item; new_item->prev = child; child = new_item;
814 value = skip( parse_string( child, skip( value + 1 )));
815 if ( !value )
816 return(0);
817 child->string = child->valuestring; child->valuestring = 0;
818 if ( *value != ':' )
819 {
820 ep = value; return(0);
821 } /* fail! */
822 value = skip( parse_value( child, skip( value + 1 ))); /* skip any spacing, get the value. */
823 if ( !value )
824 return(0);
825 }
826
827 if ( *value == '}' )
828 return(value + 1); /* end of array */
829 ep = value; return(0); /* malformed. */
830 }
831
832
833 /* Render an object to text. */
834 /* 该函数和前面的print_array()相似 */
835 static char *print_object( cJSON *item, int depth, int fmt )
836 {
837 /**
838 * 局部变量说明:
839 * 1.entries : 键值对的value;
840 * 2.names : 键值对的key;
841 * 3.out : 指向输出的字符串;
842 * 4.ptr : 指向out输出的字符串;
843 * 5.ret : 执行函数时返回的字符串地址;
844 * 6.str : 执行函数返回的字符串的地址;
845 * 7.len : 字符串的长度;
846 * 8.i : for循环用于计数的变量;
847 * 9.j : for循环用于计数的变量;
848 * 10.child : 指向节点的指针;
849 * 11.fail : 输出出错时的标志;
850 * 12.numentries : 用于统计当前结构深度层次上的节点个数
851 */
852 char **entries = 0, **names = 0;
853 char *out = 0, *ptr, *ret, *str;
854 int len = 7, i = 0, j;
855 cJSON *child = item->child;
856 int numentries = 0, fail = 0;
857 /* Count the number of entries. */
858 while ( child )
859 numentries++, child = child->next;
860 /* Explicitly handle empty object case */
861 if ( !numentries )
862 {
863 out = (char *) cJSON_malloc( fmt ? depth + 4 : 3 );
864 if ( !out )
865 return(0);
866 ptr = out; *ptr++ = '{';
867 if ( fmt )
868 {
869 *ptr++ = '\n';
870 for ( i = 0; i < depth - 1; i++ )
871 *ptr++ = '\t';
872 }
873 *ptr++ = '}'; *ptr++ = 0;
874 return(out);
875 }
876 /* Allocate space for the names and the objects */
877 entries = (char **) cJSON_malloc( numentries * sizeof(char*));
878 if ( !entries )
879 return(0);
880 names = (char **) cJSON_malloc( numentries * sizeof(char*));
881 if ( !names )
882 {
883 cJSON_free( entries ); return(0);
884 }
885 memset( entries, 0, sizeof(char*) * numentries );
886 memset( names, 0, sizeof(char*) * numentries );
887
888 /* Collect all the results into our arrays: */
889 child = item->child; depth++; if ( fmt )
890 len += depth;
891 while ( child )
892 {
893 names[i] = str = print_string_ptr( child->string );
894 entries[i++] = ret = print_value( child, depth, fmt );
895 if ( str && ret )
896 len += strlen( ret ) + strlen( str ) + 2 + (fmt ? 2 + depth : 0);
897 else fail = 1;
898 child = child->next;
899 }
900
901 /* Try to allocate the output string */
902 if ( !fail )
903 out = (char *) cJSON_malloc( len );
904 if ( !out )
905 fail = 1;
906
907 /* Handle failure */
908 if ( fail )
909 {
910 for ( i = 0; i < numentries; i++ )
911 {
912 if ( names[i] )
913 cJSON_free( names[i] );
914 if ( entries[i] )
915 cJSON_free( entries[i] );
916 }
917 cJSON_free( names ); cJSON_free( entries );
918 return(0);
919 }
920
921 /* Compose the output: */
922 *out = '{';
923 ptr = out + 1;
924 if ( fmt )
925 *ptr++ = '\n';
926 *ptr = 0;
927 for ( i = 0; i < numentries; i++ )
928 {
929 if ( fmt )
930 for ( j = 0; j < depth; j++ )
931 *ptr++ = '\t';
932 strcpy( ptr, names[i] );
933 ptr += strlen( names[i] );
934 *ptr++ = ':';
935 if ( fmt )
936 *ptr++ = '\t';
937 strcpy( ptr, entries[i] );
938 ptr += strlen( entries[i] );
939 if ( i != numentries - 1 )
940 *ptr++ = ',';
941 if ( fmt )
942 *ptr++ = '\n';
943 *ptr = 0;
944 cJSON_free( names[i] );
945 cJSON_free( entries[i] );
946 }
947
948 cJSON_free( names );
949 cJSON_free( entries );
950 if ( fmt )
951 for ( i = 0; i < depth - 1; i++ )
952 *ptr++ = '\t';
953 *ptr++ = '}';
954 *ptr++ = 0;
955 return(out);
956 }
957
958
959 /* Get Array size/item / object item. */
960 int cJSON_GetArraySize( cJSON *array )
961 {
962 cJSON *c = array->child; int i = 0; while ( c )
963 i++, c = c->next;
964 return(i);
965 }
966
967
968 cJSON *cJSON_GetArrayItem( cJSON *array, int item )
969 {
970 cJSON *c = array->child; while ( c && item > 0 )
971 item--, c = c->next;
972 return(c);
973 }
974
975
976 cJSON *cJSON_GetObjectItem( cJSON *object, const char *string )
977 {
978 cJSON *c = object->child; while ( c && cJSON_strcasecmp( c->string, string ))
979 c = c->next;
980 return(c);
981 }
982
983
984 /* Utility for array list handling. --> 在当前节点的后面添加一个节点 */
985 static void suffix_object( cJSON *prev, cJSON *item )
986 {
987 prev->next = item; item->prev = prev;
988 }
989
990
991 /* Utility for handling references. */
992 static cJSON *create_reference( cJSON *item )
993 {
994 cJSON *ref = cJSON_New_Item();
995 if ( !ref )
996 return(0);
997 memcpy( ref, item, sizeof(cJSON));
998 ref->string = 0;
999 ref->type |= cJSON_IsReference;
1000 ref->next = ref->prev = 0;
1001 return(ref);
1002 }
1003
1004
1005 /* Add item to array/object. */
1006 void cJSON_AddItemToArray( cJSON *array, cJSON *item )
1007 {
1008 cJSON *c = array->child;
1009 if ( !item )
1010 return;
1011 if ( !c )
1012 {
1013 array->child = item;
1014 }
1015 else
1016 {
1017 while ( c && c->next )
1018 c = c->next;
1019 suffix_object( c, item );
1020 }
1021 }
1022
1023
1024 void cJSON_AddItemToObject( cJSON *object, const char *string, cJSON *item )
1025 {
1026 if ( !item )
1027 return;
1028 if ( item->string )
1029 cJSON_free( item->string );
1030 item->string = cJSON_strdup( string );
1031 cJSON_AddItemToArray( object, item );
1032 }
1033
1034
1035 void cJSON_AddItemReferenceToArray( cJSON *array, cJSON *item )
1036 {
1037 cJSON_AddItemToArray( array, create_reference( item ));
1038 }
1039
1040
1041 void cJSON_AddItemReferenceToObject( cJSON *object, const char *string, cJSON *item )
1042 {
1043 cJSON_AddItemToObject( object, string, create_reference( item ));
1044 }
1045
1046
1047 cJSON *cJSON_DetachItemFromArray( cJSON *array, int which )
1048 {
1049 cJSON *c = array->child;
1050 while ( c && which > 0 )
1051 c = c->next, which--;
1052
1053 if ( !c )
1054 return(0);
1055 if ( c->prev )
1056 c->prev->next = c->next;
1057 if ( c->next )
1058 c->next->prev = c->prev;
1059 if ( c == array->child )
1060 array->child = c->next;
1061 c->prev = c->next = 0;
1062 return(c);
1063 }
1064
1065
1066 void cJSON_DeleteItemFromArray( cJSON *array, int which )
1067 {
1068 cJSON_Delete( cJSON_DetachItemFromArray( array, which ));
1069 }
1070
1071
1072 cJSON *cJSON_DetachItemFromObject( cJSON *object, const char *string )
1073 {
1074 int i = 0; cJSON *c = object->child;
1075 while ( c && cJSON_strcasecmp( c->string, string ))
1076 i++, c = c->next;
1077 if ( c )
1078 return(cJSON_DetachItemFromArray( object, i ));
1079 return(0);
1080 }
1081
1082
1083 void cJSON_DeleteItemFromObject( cJSON *object, const char *string )
1084 {
1085 cJSON_Delete( cJSON_DetachItemFromObject( object, string ));
1086 }
1087
1088
1089 /* Replace array/object items with new ones. */
1090 void cJSON_ReplaceItemInArray( cJSON *array, int which, cJSON *newitem )
1091 {
1092 cJSON *c = array->child;
1093 while ( c && which > 0 )
1094 c = c->next, which--;
1095 if ( !c )
1096 return;
1097 newitem->next = c->next;
1098 newitem->prev = c->prev;
1099 if ( newitem->next )
1100 newitem->next->prev = newitem;
1101 if ( c == array->child )
1102 array->child = newitem;
1103 else
1104 newitem->prev->next = newitem;
1105 c->next = c->prev = 0;
1106 cJSON_Delete( c );
1107 }
1108
1109
1110 void cJSON_ReplaceItemInObject( cJSON *object, const char *string, cJSON *newitem )
1111 {
1112 int i = 0;
1113 cJSON *c = object->child;
1114 while ( c && cJSON_strcasecmp( c->string, string ))
1115 i++, c = c->next;
1116 if ( c )
1117 {
1118 newitem->string = cJSON_strdup( string );
1119 cJSON_ReplaceItemInArray( object, i, newitem );
1120 }
1121 }
1122
1123
1124 /* Create basic types: */
1125 cJSON *cJSON_CreateNull( void )
1126 {
1127 cJSON *item = cJSON_New_Item();
1128 if ( item )
1129 item->type = cJSON_NULL;
1130 return(item);
1131 }
1132
1133
1134 cJSON *cJSON_CreateTrue( void )
1135 {
1136 cJSON *item = cJSON_New_Item();
1137 if ( item )
1138 item->type = cJSON_True;
1139 return(item);
1140 }
1141
1142
1143 cJSON *cJSON_CreateFalse( void )
1144 {
1145 cJSON *item = cJSON_New_Item();
1146 if ( item )
1147 item->type = cJSON_False;
1148 return(item);
1149 }
1150
1151
1152 cJSON *cJSON_CreateBool( int b )
1153 {
1154 cJSON *item = cJSON_New_Item();
1155 if ( item )
1156 item->type = b ? cJSON_True : cJSON_False;
1157 return(item);
1158 }
1159
1160
1161 cJSON *cJSON_CreateNumber( double num )
1162 {
1163 cJSON *item = cJSON_New_Item();
1164 if ( item )
1165 {
1166 item->type = cJSON_Number;
1167 item->valuedouble = num;
1168 item->valueint = (int) num;
1169 }
1170 return(item);
1171 }
1172
1173
1174 cJSON *cJSON_CreateString( const char *string )
1175 {
1176 cJSON *item = cJSON_New_Item();
1177 if ( item )
1178 {
1179 item->type = cJSON_String;
1180 item->valuestring = cJSON_strdup( string );
1181 }
1182 return(item);
1183 }
1184
1185
1186 cJSON *cJSON_CreateArray( void )
1187 {
1188 cJSON *item = cJSON_New_Item();
1189 if ( item )
1190 item->type = cJSON_Array;
1191 return(item);
1192 }
1193
1194
1195 cJSON *cJSON_CreateObject( void )
1196 {
1197 cJSON *item = cJSON_New_Item();
1198 if ( item )
1199 item->type = cJSON_Object;
1200 return(item);
1201 }
1202
1203
1204 /* Create Arrays: */
1205 cJSON *cJSON_CreateIntArray( const int *numbers, int count )
1206 {
1207 int i;
1208 cJSON *n = 0, *p = 0, *a = cJSON_CreateArray();
1209 for ( i = 0; a && i < count; i++ )
1210 {
1211 n = cJSON_CreateNumber( numbers[i] );
1212 if ( !i )
1213 a->child = n;
1214 else
1215 suffix_object( p, n );
1216 p = n;
1217 }
1218 return(a);
1219 }
1220
1221
1222 cJSON *cJSON_CreateFloatArray( const float *numbers, int count )
1223 {
1224 int i;
1225 cJSON *n = 0, *p = 0, *a = cJSON_CreateArray();
1226 for ( i = 0; a && i < count; i++ )
1227 {
1228 n = cJSON_CreateNumber( numbers[i] );
1229 if ( !i )
1230 a->child = n;
1231 else
1232 suffix_object( p, n );
1233 p = n;
1234 }
1235 return(a);
1236 }
1237
1238
1239 cJSON *cJSON_CreateDoubleArray( const double *numbers, int count )
1240 {
1241 int i;
1242 cJSON *n = 0, *p = 0, *a = cJSON_CreateArray();
1243 for ( i = 0; a && i < count; i++ )
1244 {
1245 n = cJSON_CreateNumber( numbers[i] );
1246 if ( !i )
1247 a->child = n;
1248 else
1249 suffix_object( p, n );
1250 p = n;
1251 }
1252 return(a);
1253 }
1254
1255
1256 cJSON *cJSON_CreateStringArray( const char **strings, int count )
1257 {
1258 int i; cJSON *n = 0, *p = 0, *a = cJSON_CreateArray();
1259 for ( i = 0; a && i < count; i++ )
1260 {
1261 n = cJSON_CreateString( strings[i] );
1262 if ( !i )
1263 a->child = n;
1264 else
1265 suffix_object( p, n );
1266 p = n;
1267 }
1268 return(a);
1269 }
1270
1271
1272 /* Duplication */
1273 cJSON *cJSON_Duplicate( cJSON *item, int recurse )
1274 {
1275 cJSON *newitem, *cptr, *nptr = 0, *newchild;
1276 /* Bail on bad ptr */
1277 if ( !item )
1278 return(0);
1279 /* Create new item */
1280 newitem = cJSON_New_Item();
1281 if ( !newitem )
1282 return(0);
1283 /* Copy over all vars */
1284 newitem->type = item->type & (~cJSON_IsReference), newitem->valueint = item->valueint, newitem->valuedouble = item->valuedouble;
1285 if ( item->valuestring )
1286 {
1287 newitem->valuestring = cJSON_strdup( item->valuestring ); if ( !newitem->valuestring )
1288 {
1289 cJSON_Delete( newitem ); return(0);
1290 }
1291 }
1292 if ( item->string )
1293 {
1294 newitem->string = cJSON_strdup( item->string ); if ( !newitem->string )
1295 {
1296 cJSON_Delete( newitem ); return(0);
1297 }
1298 }
1299 /* If non-recursive, then we're done! */
1300 if ( !recurse )
1301 return(newitem);
1302 /* Walk the ->next chain for the child. */
1303 cptr = item->child;
1304 while ( cptr )
1305 {
1306 newchild = cJSON_Duplicate( cptr, 1 ); /* Duplicate (with recurse) each item in the ->next chain */
1307 if ( !newchild )
1308 {
1309 cJSON_Delete( newitem ); return(0);
1310 }
1311 if ( nptr )
1312 {
1313 nptr->next = newchild, newchild->prev = nptr; nptr = newchild;
1314 } /* If newitem->child already set, then crosswire ->prev and ->next and move on */
1315 else { newitem->child = newchild; nptr = newchild; } /* Set newitem->child and move to it */
1316 cptr = cptr->next;
1317 }
1318 return(newitem);
1319 }
1320
1321
1322 void cJSON_Minify( char *json )
1323 {
1324 char *into = json;
1325 while ( *json )
1326 {
1327 if ( *json == ' ' )
1328 json++;
1329 else if ( *json == '\t' )
1330 json++; /* Whitespace characters. */
1331 else if ( *json == '\r' )
1332 json++;
1333 else if ( *json == '\n' )
1334 json++;
1335 else if ( *json == '/' && json[1] == '/' )
1336 while ( *json && *json != '\n' )
1337 json++;
1338 /* double-slash comments, to end of line. */
1339 else if ( *json == '/' && json[1] == '*' )
1340 {
1341 while ( *json && !(*json == '*' && json[1] == '/'))
1342 json++;
1343 json += 2;
1344 } /* multiline comments. */
1345 else if ( *json == '\"' )
1346 {
1347 *into++ = *json++; while ( *json && *json != '\"' )
1348 {
1349 if ( *json == '\\' )
1350 *into++ = *json++;
1351 *into++ = *json++;
1352 }
1353 *into++ = *json++;
1354 } /* string literals, which are \" sensitive. */
1355 else *into++ = *json++; /* All other characters. */
1356 }
1357 *into = 0; /* and null-terminate. */
1358 }
