cJSON 源码解析

Posted 2020-10-19 壹点灵异

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了 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。我们先从头文件开始分析。

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

#ifndef cJSON__h
#define cJSON__h
#ifdef __cplusplus
extern "C"
{
#endif

...

#ifdef __cplusplus
}
#endif
#endif

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

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

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

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

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

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

示例图如下：

技术分享图片

cjson的类型宏定义：

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

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

cjson的创建：

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

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

相关代码如下:

// 将字符串添加进对象
void cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item)
{
if (!item)
return;
if (item->string)
cJSON_free(item->string); // 这个儿子之前有key，先清理
item->string=cJSON_strdup(string); // 设置key值
cJSON_AddItemToArray(object,item); // 添加儿子
}
// 将传入的字符串复制一副本并返回新的字符串指针
static char* cJSON_strdup(const char* str)
{
size_t len;
char* copy;
len = strlen(str) + 1;
// 分配空间
if (!(copy = (char*)cJSON_malloc(len)))
return 0;
// 执行复制操作
memcpy(copy,str,len);
// 返回复制的副本
return copy;
}
// 添加节点到object或array中
void cJSON_AddItemToArray(cJSON *array, cJSON *item)
{
cJSON *c=array->child;
if (!item)
return;
if (!c)
{
array->child=item; // 之前不存在儿子节点，直接添加
}
else
{
while (c && c->next) // 先找到最后一个儿子
c=c->next;
suffix_object(c,item); // 添加儿子，c是item的兄弟节点
}
}
// array的处理
static void suffix_object(cJSON *prev,cJSON *item)
{
// 两个兄弟的指针互相指向对方
prev->next=item;
item->prev=prev;
}

cjson打印：

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

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

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

为例，进行分析。

相关函数结构图如下：

相关函数如下：

typedef struct {
char *buffer;
int length;
int offset;
} printbuffer;
static int pow2gt(int x) /*返回一个比x的n(其中n是2的幂),并且是最小的幂，说白了就是将一个数后边所有的位都置1然后再+1*/
{
--x;
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x + 1;
}
/* ensure 函数是一个协助 printbuffer 分配内存的一个函数
* len 表示当前字符串的字符串起始偏移量即 newbuffer+p->offset 起始的
*/
static char* ensure(printbuffer *p,int needed)
{
char *newbuffer;int newsize;
if (!p || !p->buffer) return 0;//传入参数合法性检测
needed+=p->offset;//需要额外分配的内存也就是偏移量
if (needed<=p->length) return p->buffer+p->offset;//内存够用直接返回
newsize=pow2gt(needed);
newbuffer=(char*)cJSON_malloc(newsize);//malloc出新内存放buffer里面的内容
if (!newbuffer) {cJSON_free(p->buffer);p->length=0,p->buffer=0;return 0;}
if (newbuffer) memcpy(newbuffer,p->buffer,p->length);//
cJSON_free(p->buffer);//
p->length=newsize;
p->buffer=newbuffer;
return newbuffer+p->offset;//
}
char *cJSON_Print(cJSON * item)
{
return print_value(item, 0, 1, 0);
}
static char *print_value(cJSON * item, int depth, int fmt, printbuffer * p)
{
char *out = 0;
if (!item)
return 0;
if (p) {
switch ((item->type) & 255) {
case cJSON_NULL:{
out = ensure(p, 5);
if (out)
strcpy(out, "null");
break;
}
case cJSON_False:{
out = ensure(p, 6);
if (out)
strcpy(out, "false");
break;
}
case cJSON_True:{
out = ensure(p, 5);
if (out)
strcpy(out, "true");
break;
}
case cJSON_Number:
out = print_number(item, p); //打印数字函数
break;
case cJSON_String:
out = print_string(item, p); //打印字符串函数
break;
case cJSON_Array:
out = print_array(item, depth, fmt, p); //打印数组函数
break;
case cJSON_Object:
out = print_object(item, depth, fmt, p); //打印object对象类型的函数
break;
}
} else {
switch ((item->type) & 255) {
case cJSON_NULL:
out = cJSON_strdup("null");
break;
case cJSON_False:
out = cJSON_strdup("false");
break;
case cJSON_True:
out = cJSON_strdup("true");
break;
case cJSON_Number:
out = print_number(item, 0);
break;
case cJSON_String:
out = print_string(item, 0);
break;
case cJSON_Array:
out = print_array(item, depth, fmt, 0);
break;
case cJSON_Object:
out = print_object(item, depth, fmt, 0);
break;
}
}
return out;
}
static char *print_number(cJSON * item, printbuffer * p) //打印数字函数
{
char *str = 0;
double d = item->valuedouble;
if (d == 0) {
if (p)
str = ensure(p, 2);
else
str = (char *) cJSON_malloc(2); /* special case for 0. */
if (str)
strcpy(str, "0");
} else if (fabs(((double) item->valueint) - d) <= DBL_EPSILON
&& d <= INT_MAX && d >= INT_MIN) {
if (p)
str = ensure(p, 21);
else
str = (char *) cJSON_malloc(21); /* 2 ^ 64 + 1可以用21个字符表示 */
if (str)
sprintf(str, "%d", item->valueint);
} else {
if (p)
str = ensure(p, 64);
else
str = (char *) cJSON_malloc(64); /* This is a nice tradeoff. */
if (str) {
if (fpclassify(d) != FP_ZERO && !isnormal(d)) //非正常浮点数
sprintf(str, "null");
else if (fabs(floor(d) - d) <= DBL_EPSILON
&& fabs(d) < 1.0e60)
sprintf(str, "%.0f", d);
else if (fabs(d) < 1.0e-6 || fabs(d) > 1.0e9)
sprintf(str, "%e", d);
else
sprintf(str, "%f", d);
}
}
return str;
}
static char *print_string(cJSON * item, printbuffer * p) //打印字符串类型的结点
{
return print_string_ptr(item->valuestring, p);
}
static char *print_string_ptr(const char *str, printbuffer * p) //打印字符串类型的结点
{
const char *ptr;
char *ptr2, *out;
int len = 0, flag = 0;
unsigned char token;
if (!str) {
if (p)
out = ensure(p, 3);
else
out = (char *) cJSON_malloc(3);
if (!out)
return 0;
strcpy(out, "\"\""); //字符串为空
return out;
}
for (ptr = str; *ptr; ptr++)
flag |= ((*ptr > 0 && *ptr < 32) || (*ptr == ‘\"‘)
|| (*ptr == ‘\\‘)) ? 1 : 0;
if (!flag) { //对字符串中不含‘\‘,‘/‘，空格等字符的字符处理
len = ptr - str;
if (p)
out = ensure(p, len + 3);
else
out = (char *) cJSON_malloc(len + 3);
if (!out)
return 0;
ptr2 = out;
*ptr2++ = ‘\"‘;
strcpy(ptr2, str);
ptr2[len] = ‘\"‘;
ptr2[len + 1] = 0;
return out;
}
ptr = str;
while ((token = *ptr) && ++len) {
if (strchr("\"\\\b\f\n\r\t", token))
len++;
else if (token < 32)
len += 5;
ptr++;
}
if (p)
out = ensure(p, len + 3);
else
out = (char *) cJSON_malloc(len + 3);
if (!out)
return 0;
ptr2 = out;
ptr = str;
*ptr2++ = ‘\"‘;
while (*ptr) {
if ((unsigned char) *ptr > 31 && *ptr != ‘\"‘
&& *ptr != ‘\\‘)
*ptr2++ = *ptr++;
else {
*ptr2++ = ‘\\‘;
switch (token = *ptr++) {
case ‘\\‘:
*ptr2++ = ‘\\‘;
break;
case ‘\"‘:
*ptr2++ = ‘\"‘;
break;
case ‘\b‘:
*ptr2++ = ‘b‘;
break;
case ‘\f‘:
*ptr2++ = ‘f‘;
break;
case ‘\n‘:
*ptr2++ = ‘n‘;
break;
case ‘\r‘:
*ptr2++ = ‘r‘;
break;
case ‘\t‘:
*ptr2++ = ‘t‘;
break;
default:
sprintf(ptr2, "u%04x", token);
ptr2 += 5;
break; /* escape and print */
}
}
}
*ptr2++ = ‘\"‘;
*ptr2++ = 0;
return out;
}
static char *print_array(cJSON * item, int depth, int fmt, printbuffer * p) //打印数组类型结点函数
{
char **entries;
char *out = 0, *ptr, *ret;
int len = 5;
cJSON *child = item->child;
int numentries = 0, i = 0, fail = 0;
size_t tmplen = 0;
/* 数组里有多少个元素 */
while (child)
numentries++, child = child->next;
/* 明确处理numentries = = 0 */ //处理空数组
if (!numentries) {
if (p)
out = ensure(p, 3);
else
out = (char *) cJSON_malloc(3);
if (out)
strcpy(out, "[]");
return out;
}
if (p) {
/* 组成数组的输出形式 */
i = p->offset;
ptr = ensure(p, 1);
if (!ptr)
return 0;
*ptr = ‘[‘;
p->offset++;
child = item->child;
while (child && !fail) {
print_value(child, depth + 1, fmt, p);
p->offset = update(p);
if (child->next) {
len = fmt ? 2 : 1;
ptr = ensure(p, len + 1);
if (!ptr)
return 0;
*ptr++ = ‘,‘;
if (fmt)
*ptr++ = ‘ ‘;
*ptr = 0;
p->offset += len;
}
child = child->next;
}
ptr = ensure(p, 2);
if (!ptr)
return 0;
*ptr++ = ‘]‘;
*ptr = 0;
out = (p->buffer) + i;
} else {
/* 分配一个指针数组存储数组里的每一个元素的打印结果 */
entries =
(char **) cJSON_malloc(numentries * sizeof(char *));
if (!entries)
return 0;
memset(entries, 0, numentries * sizeof(char *));
/* 检索所有结果: */
child = item->child;
while (child && !fail) {
ret = print_value(child, depth + 1, fmt, 0);
entries[i++] = ret;
if (ret)
len += strlen(ret) + 2 + (fmt ? 1 : 0);
else
fail = 1;
child = child->next;
}
if (!fail)
out = (char *) cJSON_malloc(len);
if (!out)
fail = 1;
if (fail) {
for (i = 0; i < numentries; i++)
if (entries[i])
cJSON_free(entries[i]);
cJSON_free(entries);
return 0;
}
/* 组成数组的输出形式. */
*out = ‘[‘;
ptr = out + 1;
*ptr = 0;
for (i = 0; i < numentries; i++) {
tmplen = strlen(entries[i]);
memcpy(ptr, entries[i], tmplen);
ptr += tmplen;
if (i != numentries - 1) {
*ptr++ = ‘,‘;
if (fmt)
*ptr++ = ‘ ‘;
*ptr = 0;
}
cJSON_free(entries[i]);
}
cJSON_free(entries);
*ptr++ = ‘]‘;
*ptr++ = 0;
}
return out;
}
/* 打印object类型结点. */
static char *print_object(cJSON * item, int depth, int fmt, printbuffer * p)
{
char **entries = 0, **names = 0;
char *out = 0, *ptr, *ret, *str;
int len = 7, i = 0, j;
cJSON *child = item->child;
int numentries = 0, fail = 0;
size_t tmplen = 0;
/* 统计有多少个子结点. */
while (child)
numentries++, child = child->next;
/* 明确处理空对象的情况*/
if (!numentries) {
if (p)
out = ensure(p, fmt ? depth + 4 : 3);
else
out = (char *) cJSON_malloc(fmt ? depth + 4 : 3);
if (!out)
return 0;
ptr = out;
*ptr++ = ‘{‘;
if (fmt) {
*ptr++ = ‘\n‘;
for (i = 0; i < depth; i++)
*ptr++ = ‘\t‘;
}
*ptr++ = ‘}‘;
*ptr++ = 0;
return out;
}
if (p) {
/* 组成输出形式: */
i = p->offset;
len = fmt ? 2 : 1;
ptr = ensure(p, len + 1);
if (!ptr)
return 0;
*ptr++ = ‘{‘;
if (fmt)
*ptr++ = ‘\n‘;
*ptr = 0;
p->offset += len;
child = item->child;
depth++;
while (child) {
if (fmt) {
ptr = ensure(p, depth);
if (!ptr)
return 0;
for (j = 0; j < depth; j++)
*ptr++ = ‘\t‘;
p->offset += depth;
}
print_string_ptr(child->string, p);
p->offset = update(p);
len = fmt ? 2 : 1;
ptr = ensure(p, len);
if (!ptr)
return 0;
*ptr++ = ‘:‘;
if (fmt)
*ptr++ = ‘\t‘;
p->offset += len;
print_value(child, depth, fmt, p);
p->offset = update(p);
len = (fmt ? 1 : 0) + (child->next ? 1 : 0);
ptr = ensure(p, len + 1);
if (!ptr)
return 0;
if (child->next)
*ptr++ = ‘,‘;
if (fmt)
*ptr++ = ‘\n‘;
*ptr = 0;
p->offset += len;
child = child->next;
}
ptr = ensure(p, fmt ? (depth + 1) : 2);
if (!ptr)
return 0;
if (fmt)
for (i = 0; i < depth - 1; i++)
*ptr++ = ‘\t‘;
*ptr++ = ‘}‘;
*ptr = 0;
out = (p->buffer) + i;
} else {
/*为对象和名称分配空间 */
entries =
(char **) cJSON_malloc(numentries * sizeof(char *));
if (!entries)
return 0;
names =
(char **) cJSON_malloc(numentries * sizeof(char *));
if (!names) {
cJSON_free(entries);
return 0;
}
memset(entries, 0, sizeof(char *) * numentries);
memset(names, 0, sizeof(char *) * numentries);
/* 将所有结果收集到数组: */
child = item->child;
depth++;
if (fmt)
len += depth;
while (child && !fail) {
names[i] = str =
print_string_ptr(child->string, 0);
entries[i++] = ret =
print_value(child, depth, fmt, 0);
if (str && ret)
len +=
strlen(ret) + strlen(str) + 2 +
(fmt ? 2 + depth : 0);
else
fail = 1;
child = child->next;
}
if (!fail)
out = (char *) cJSON_malloc(len);
if (!out)
fail = 1;
if (fail) {
for (i = 0; i < numentries; i++) {
if (names[i])
cJSON_free(names[i]);
if (entries[i])
cJSON_free(entries[i]);
}
cJSON_free(names);
cJSON_free(entries);
return 0;
}
/* 组成输出形式: */
*out = ‘{‘;
ptr = out + 1;
if (fmt)
*ptr++ = ‘\n‘;
*ptr = 0;
for (i = 0; i < numentries; i++) {
if (fmt)
for (j = 0; j < depth; j++)
*ptr++ = ‘\t‘;
tmplen = strlen(names[i]);
memcpy(ptr, names[i], tmplen);
ptr += tmplen;
*ptr++ = ‘:‘;
if (fmt)
*ptr++ = ‘\t‘;
strcpy(ptr, entries[i]);
ptr += strlen(entries[i]);
if (i != numentries - 1)
*ptr++ = ‘,‘;
if (fmt)
*ptr++ = ‘\n‘;
*ptr = 0;
cJSON_free(names[i]);
cJSON_free(entries[i]);
}
cJSON_free(names);
cJSON_free(entries);
if (fmt)
for (i = 0; i < depth - 1; i++)
*ptr++ = ‘\t‘;
*ptr++ = ‘}‘;
*ptr++ = 0;
}
return out;
}

cJSON解析：

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

结构图如下：

技术分享图片