cJONS序列化工具解读二(数据解析)

cJSON数据解析

关于数据解析部分，其实这个解析就是个自动机，通过递归或者解析栈进行实现数据的解析

/* Utility to jump whitespace and cr/lf */
//用于跳过ascii小于32的空白字符
static const char *skip(const char *in)
{
    while (in && *in && (unsigned char)*in <= )
        in++;
    return in;
}

/* Parse an object - create a new root, and populate. */
cJSON *cJSON_ParseWithOpts(const char *value, const char **return_parse_end, int require_null_terminated)
{
    const char *end = ;
    cJSON *c = cJSON_New_Item();
    ep = ;
    if (!c)
        return ;       /* memory fail */

    //根据前几个字符设置c类型并更新读取位置为end
    end = parse_value(c, skip(value));
    if (!end)
    {
        cJSON_Delete(c);    //解析失败，数据不完整
        return ;
    }    /* parse failure. ep is set. */

        /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
    if (require_null_terminated)///??
    {
        end = skip(end);
        if (*end)
        {
            cJSON_Delete(c);
            ep = end;
            return ;
        }
    }
    if (return_parse_end)
        *return_parse_end = end;
    return c;
}
/* Default options for cJSON_Parse */
cJSON *cJSON_Parse(const char *value) { return cJSON_ParseWithOpts(value, , ); }

①关于重点部分parse_value 对类型解读函数

/* Parser core - when encountering text, process appropriately. */
//将输入字符串解析为具体类型cJSON结构
static const char *parse_value(cJSON *item, const char *value)
{
    if (!value)
        return ;    /* Fail on null. */

　　//设置结构的具体类型并且返回下一个将要解读数据的位置
    if (!strncmp(value, "null", )) { item->type = cJSON_NULL;  return value + ; }
    if (!strncmp(value, "false", )) { item->type = cJSON_False; return value + ; }
    if (!strncmp(value, "true", )) { item->type = cJSON_True; item->valueint = ;    return value + ; }
    if (*value == '\"') { return parse_string(item, value); }
    if (*value == '-' || (*value >= '' && *value <= '')) { return parse_number(item, value); }
    if (*value == '[') { return parse_array(item, value); }
    if (*value == '{') { return parse_object(item, value); }

    ep = value; return ;    /* failure. */
}

②解析字符串部分
解析字符串时， 对于特殊字符也应该转义，比如 "n" 字符应该转换为 'n' 这个换行符。
当然，如果只有特殊字符转换的话，代码不会又这么长， 对于字符串， 还要支持非 ascii 码的字符， 即 utf8字符。
这些字符在字符串中会编码为 uXXXX 的字符串， 我们现在需要还原为 0 - 255 的一个字符。

static unsigned parse_hex4(const char *str)
{
    unsigned h = ;
    if (*str >= '' && *str <= '')
        h += (*str) - '';
    else if (*str >= 'A' && *str <= 'F')
        h +=  + (*str) - 'A';
    else if (*str >= 'a' && *str <= 'f')
        h +=  + (*str) - 'a';
    else
        return ;

    h = h << ; //*F
    str++;
    if (*str >= '' && *str <= '')
        h += (*str) - '';
    else if (*str >= 'A' && *str <= 'F')
        h +=  + (*str) - 'A';
    else if (*str >= 'a' && *str <= 'f')
        h +=  + (*str) - 'a';
    else
        return ;

    h = h << ;
    str++;
    if (*str >= '' && *str <= '')
        h += (*str) - '';
    else if (*str >= 'A' && *str <= 'F')
        h +=  + (*str) - 'A';
    else if (*str >= 'a' && *str <= 'f')
        h +=  + (*str) - 'a';
    else return ;

    h = h << ;
    str++;
    if (*str >= '' && *str <= '')
        h += (*str) - '';
    else if (*str >= 'A' && *str <= 'F')
        h +=  + (*str) - 'A';
    else if (*str >= 'a' && *str <= 'f')
        h +=  + (*str) - 'a';
    else
        return ;
    return h;
}

/* Parse the input text into an unescaped cstring, and populate item. */
static const unsigned char firstByteMark[] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
static const char *parse_string(cJSON *item, const char *str)
{
    const char *ptr = str + ;
    char *ptr2;
    char *out;
    int len = ;
    unsigned uc, uc2;
    if (*str != '\"')
    {
        ep = str;
        return ;
    }    /* not a string! */

    while(*ptr != '\"' && *ptr && ++len)
        if (*ptr++ == '\\') //跳过\续行符
            ptr++;    /* Skip escaped quotes. */

    //空间申请
    out = (char*)cJSON_malloc(len + );    /* This is how long we need for the string, roughly. */
    if (!out)
        return ;

    ptr = str + ;//跳过“开始
    ptr2 = out;
    while (*ptr != '\"' && *ptr)
    {
        if (*ptr != '\\')
            *ptr2++ = *ptr++;
        else    //转义字符处理
        {
            ptr++;
            switch (*ptr)
            {
            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;
            case 'u':     /* transcode utf16 to utf8. */
                uc = parse_hex4(ptr + );
                ptr += ;    /* get the unicode char. */

                if ((uc >= 0xDC00 && uc <= 0xDFFF) || uc == )
                    break;    /* check for invalid.    */

                if (uc >= 0xD800 && uc <= 0xDBFF)    /* UTF16 surrogate pairs.    */
                {
                    if (ptr[] != '\\' || ptr[] != 'u')
                        break;    /* missing second-half of surrogate.    */
                    uc2 = parse_hex4(ptr + );
                    ptr += ;
                    if (uc2<0xDC00 || uc2>0xDFFF)
                        break;    /* invalid second-half of surrogate.    */
                    uc = 0x10000 + (((uc & 0x3FF) << ) | (uc2 & 0x3FF));
                }

                len = ;
                if (uc<0x80)
                    len = ;
                else if (uc<0x800)
                    len = ;
                else if (uc<0x10000)
                    len = ;
                ptr2 += len;

                switch (len)
                {
                case :
                    *--ptr2 = ((uc | 0x80) & 0xBF); uc >>= ;
                case :
                    *--ptr2 = ((uc | 0x80) & 0xBF); uc >>= ;
                case :
                    *--ptr2 = ((uc | 0x80) & 0xBF); uc >>= ;
                case :
                    *--ptr2 = (uc | firstByteMark[len]);
                }
                ptr2 += len;
                break;
            default:
                *ptr2++ = *ptr; break;
            }
            ptr++;
        }
    }
    *ptr2 = ;
    if (*ptr == '\"') ptr++;
    item->valuestring = out;
    item->type = cJSON_String;
    return ptr;
}

关于具体的字符解析中的编码相关问题，请自行阅读编码相关知识

③数字解析

/* Parse the input text to generate a number, and populate the result into item. */
static const char *parse_number(cJSON *item, const char *num)
{
    double n = , sign = , scale = ;
    int subscale = ,
        signsubscale = ;

    if (*num == '-')
        sign = -, num++;    /* Has sign? */
    if (*num == '')
        num++;            /* is zero */
    if (*num >= '' && *num <= '')
        do
        {
            n = (n*10.0) + (*num++ - '');
        }while (*num >= '' && *num <= '');    /* Number? */
    if (*num == '.' && num[] >= '' && num[] <= '')
    {
        num++;
        do
            n = (n*10.0) + (*num++ - ''), scale--;
        while (*num >= '' && *num <= '');
    }    /* Fractional part? */
    if (*num == 'e' || *num == 'E')        /* Exponent? */
    {
        num++;
        if (*num == '+')
            num++;
        else if (*num == '-')
            signsubscale = -, num++;        /* With sign? */
        while (*num >= '' && *num <= '')
            subscale = (subscale * ) + (*num++ - '');    /* Number? */
    }

    n = sign*n*pow(10.0, (scale + subscale*signsubscale));    /* number = +/- number.fraction * 10^+/- exponent */

    item->valuedouble = n;
    item->valueint = (int)n;
    item->type = cJSON_Number;
    return num;
}

④解析数组
解析数组， 需要先遇到 '[' 这个符号， 然后挨个的读取节点内容， 节点使用 ',' 分隔， ',' 前后还可能有空格， 最后以 ']' 结尾。
我们要编写的也是这样。
先创建一个数组对象， 判断是否有儿子， 有的话读取第一个儿子， 然后判断是不是有 逗号， 有的话循环读取后面的儿子。
最后读取 ']' 即可。

/* Build an array from input text. */
static const char *parse_array(cJSON *item, const char *value)
{
    cJSON *child;
    if (*value != '[')
    {
        ep = value;
        return ;
    }    /* not an array! */

    item->type = cJSON_Array;
    value = skip(value + );
    if (*value == ']')
        return value + ;    /* empty array. */

    item->child = child = cJSON_New_Item();
    if (!item->child)
        return ;         /* memory fail */
    //解析数组内结构
    value = skip(parse_value(child, skip(value)));    /* skip any spacing, get the value. */
    if (!value) return ;

    while (*value == ',')
    {
        cJSON *new_item;
        if (!(new_item = cJSON_New_Item())) return ;     /* memory fail */

        child->next = new_item;
        new_item->prev = child;
        child = new_item;
        value = skip(parse_value(child, skip(value + )));
        if (!value)
            return ;    /* memory fail */
    }

    if (*value == ']')
        return value + ;    /* end of array */
    ep = value;
    return ;    /* malformed. */
}

⑤解析对象

解析对象和解析数组类似， 只不过对象的一个儿子是个 key - value, key 是字符串， value 可能是任何值， key 和 value 用 ":" 分隔。

/* Render an object to text. */
static char *print_object(cJSON *item, int depth, int fmt, printbuffer *p)
{
    char **entries = , **names = ;
    char *out = , *ptr, *ret, *str; int len = , i = , j;
    cJSON *child = item->child;
    int numentries = , fail = ;
    size_t tmplen = ;
    /* Count the number of entries. */
    while (child) numentries++, child = child->next;
    /* Explicitly handle empty object case */
    if (!numentries)
    {
        if (p) out = ensure(p, fmt ? depth +  : );
        else    out = (char*)cJSON_malloc(fmt ? depth +  : );
        if (!out)    return ;
        ptr = out; *ptr++ = '{';
        if (fmt) { *ptr++ = '\n'; for (i = ; i<depth - ; i++) *ptr++ = '\t'; }
        *ptr++ = '}'; *ptr++ = ;
        return out;
    }
    if (p)
    {
        /* Compose the output: */
        i = p->offset;
        len = fmt ?  : ;    ptr = ensure(p, len + );    if (!ptr) return ;
        *ptr++ = '{';    if (fmt) *ptr++ = '\n';    *ptr = ;    p->offset += len;
        child = item->child; depth++;
        while (child)
        {
            if (fmt)
            {
                ptr = ensure(p, depth);    if (!ptr) return ;
                for (j = ; j<depth; j++) *ptr++ = '\t';
                p->offset += depth;
            }
            print_string_ptr(child->string, p);
            p->offset = update(p);

            len = fmt ?  : ;
            ptr = ensure(p, len);    if (!ptr) return ;
            *ptr++ = ':'; if (fmt) *ptr++ = '\t';
            p->offset += len;

            print_value(child, depth, fmt, p);
            p->offset = update(p);

            len = (fmt ?  : ) + (child->next ?  : );
            ptr = ensure(p, len + ); if (!ptr) return ;
            if (child->next) *ptr++ = ',';
            if (fmt) *ptr++ = '\n'; *ptr = ;
            p->offset += len;
            child = child->next;
        }
        ptr = ensure(p, fmt ? (depth + ) : );     if (!ptr) return ;
        if (fmt)    for (i = ; i<depth - ; i++) *ptr++ = '\t';
        *ptr++ = '}'; *ptr = ;
        out = (p->buffer) + i;
    }
    else
    {
        /* Allocate space for the names and the objects */
        entries = (char**)cJSON_malloc(numentries * sizeof(char*));
        if (!entries) return ;
        names = (char**)cJSON_malloc(numentries * sizeof(char*));
        if (!names) { cJSON_free(entries); return ; }
        memset(entries, , sizeof(char*)*numentries);
        memset(names, , sizeof(char*)*numentries);

        /* Collect all the results into our arrays: */
        child = item->child; depth++; if (fmt) len += depth;
        while (child)
        {
            names[i] = str = print_string_ptr(child->string, );
            entries[i++] = ret = print_value(child, depth, fmt, );
            if (str && ret) len += strlen(ret) + strlen(str) +  + (fmt ?  + depth : ); else fail = ;
            child = child->next;
        }

        /* Try to allocate the output string */
        if (!fail)    out = (char*)cJSON_malloc(len);
        if (!out) fail = ;

        /* Handle failure */
        if (fail)
        {
            for (i = ; i<numentries; i++) { if (names[i]) cJSON_free(names[i]); if (entries[i]) cJSON_free(entries[i]); }
            cJSON_free(names); cJSON_free(entries);
            return ;
        }

        /* Compose the output: */
        *out = '{'; ptr = out + ; if (fmt)*ptr++ = '\n'; *ptr = ;
        for (i = ; i<numentries; i++)
        {
            if (fmt) for (j = ; 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 - ) *ptr++ = ',';
            if (fmt) *ptr++ = '\n'; *ptr = ;
            cJSON_free(names[i]); cJSON_free(entries[i]);
        }

        cJSON_free(names); cJSON_free(entries);
        if (fmt) for (i = ; i<depth - ; i++) *ptr++ = '\t';
        *ptr++ = '}'; *ptr++ = ;
    }
    return out;
}

这样都实现后， 字符串解析为 json 对象就实现了。

⑥序列化

序列化也就是格式化输出了。

序列化又分为格式化输出，压缩输出

/* Render a cJSON item/entity/structure to text. */
char *cJSON_Print(cJSON *item)
{
    return print_value(item, , , );
}
char *cJSON_PrintUnformatted(cJSON *item)
{
    return print_value(item, , , );
}

char *cJSON_PrintBuffered(cJSON *item, int prebuffer, int fmt)
{
    printbuffer p;
    p.buffer = (char*)cJSON_malloc(prebuffer);
    p.length = prebuffer;
    p.offset = ;
    return print_value(item, , fmt, &p);
    return p.buffer;
}

/* Render a value to text. */
static char *print_value(cJSON *item, int depth, int fmt, printbuffer *p)
{
    char *out = ;
    if (!item) return ;
    if (p)
    {
        switch ((item->type) & )
        {
        case cJSON_NULL: {out = ensure(p, );    if (out) strcpy(out, "null");    break; }
        case cJSON_False: {out = ensure(p, );    if (out) strcpy(out, "false");    break; }
        case cJSON_True: {out = ensure(p, );    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); break;
        }
    }
    else
    {
        switch ((item->type) & )
        {
        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, ); break;
        case cJSON_String:    out = print_string(item, ); break;
        case cJSON_Array:    out = print_array(item, depth, fmt, ); break;
        case cJSON_Object:    out = print_object(item, depth, fmt, ); break;
        }
    }
    return out;
}

假设我们要使用格式化输出， 也就是美化输出。

cjson 的做法不是边分析 json 边输出， 而是预先将要输的内容全部按字符串存在内存中， 最后输出整个字符串。

这对于比较大的 json 来说， 内存就是个问题了。

另外，格式化输出依靠的是节点的深度， 这个也可以优化， 一般宽度超过80 时， 就需要从新的一行算起的。

/* Render an object to text. */
static char *print_object(cJSON *item, int depth, int fmt, printbuffer *p)
{
    char **entries = , **names = ;
    char *out = , *ptr, *ret, *str; int len = , i = , j;
    cJSON *child = item->child;
    int numentries = , fail = ;
    size_t tmplen = ;
    /* Count the number of entries. */
    while (child) numentries++, child = child->next;
    /* Explicitly handle empty object case */
    if (!numentries)
    {
        if (p) out = ensure(p, fmt ? depth +  : );
        else    out = (char*)cJSON_malloc(fmt ? depth +  : );
        if (!out)    return ;
        ptr = out; *ptr++ = '{';
        if (fmt) { *ptr++ = '\n'; for (i = ; i<depth - ; i++) *ptr++ = '\t'; }
        *ptr++ = '}'; *ptr++ = ;
        return out;
    }
    if (p)
    {
        /* Compose the output: */
        i = p->offset;
        len = fmt ?  : ;    ptr = ensure(p, len + );    if (!ptr) return ;
        *ptr++ = '{';    if (fmt) *ptr++ = '\n';    *ptr = ;    p->offset += len;
        child = item->child; depth++;
        while (child)
        {
            if (fmt)
            {
                ptr = ensure(p, depth);    if (!ptr) return ;
                for (j = ; j<depth; j++) *ptr++ = '\t';
                p->offset += depth;
            }
            print_string_ptr(child->string, p);
            p->offset = update(p);

            len = fmt ?  : ;
            ptr = ensure(p, len);    if (!ptr) return ;
            *ptr++ = ':'; if (fmt) *ptr++ = '\t';
            p->offset += len;

            print_value(child, depth, fmt, p);
            p->offset = update(p);

            len = (fmt ?  : ) + (child->next ?  : );
            ptr = ensure(p, len + ); if (!ptr) return ;
            if (child->next) *ptr++ = ',';
            if (fmt) *ptr++ = '\n'; *ptr = ;
            p->offset += len;
            child = child->next;
        }
        ptr = ensure(p, fmt ? (depth + ) : );     if (!ptr) return ;
        if (fmt)    for (i = ; i<depth - ; i++) *ptr++ = '\t';
        *ptr++ = '}'; *ptr = ;
        out = (p->buffer) + i;
    }
    else
    {
        /* Allocate space for the names and the objects */
        entries = (char**)cJSON_malloc(numentries * sizeof(char*));
        if (!entries) return ;
        names = (char**)cJSON_malloc(numentries * sizeof(char*));
        if (!names) { cJSON_free(entries); return ; }
        memset(entries, , sizeof(char*)*numentries);
        memset(names, , sizeof(char*)*numentries);

        /* Collect all the results into our arrays: */
        child = item->child; depth++; if (fmt) len += depth;
        while (child)
        {
            names[i] = str = print_string_ptr(child->string, );
            entries[i++] = ret = print_value(child, depth, fmt, );
            if (str && ret) len += strlen(ret) + strlen(str) +  + (fmt ?  + depth : ); else fail = ;
            child = child->next;
        }

        /* Try to allocate the output string */
        if (!fail)    out = (char*)cJSON_malloc(len);
        if (!out) fail = ;

        /* Handle failure */
        if (fail)
        {
            for (i = ; i<numentries; i++) { if (names[i]) cJSON_free(names[i]); if (entries[i]) cJSON_free(entries[i]); }
            cJSON_free(names); cJSON_free(entries);
            return ;
        }

        /* Compose the output: */
        *out = '{'; ptr = out + ; if (fmt)*ptr++ = '\n'; *ptr = ;
        for (i = ; i<numentries; i++)
        {
            if (fmt) for (j = ; 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 - ) *ptr++ = ',';
            if (fmt) *ptr++ = '\n'; *ptr = ;
            cJSON_free(names[i]); cJSON_free(entries[i]);
        }

        cJSON_free(names); cJSON_free(entries);
        if (fmt) for (i = ; i<depth - ; i++) *ptr++ = '\t';
        *ptr++ = '}'; *ptr++ = ;
    }
    return out;
}

static char *print_array(cJSON *item, int depth, int fmt, printbuffer *p)
{
    char **entries;
    char *out = , *ptr, *ret; int len = ;
    cJSON *child = item->child;
    int numentries = , i = , fail = ;
    size_t tmplen = ;

    /* How many entries in the array? */
    while (child) numentries++, child = child->next;
    /* Explicitly handle numentries==0 */
    if (!numentries)
    {
        if (p)    out = ensure(p, );
        else    out = (char*)cJSON_malloc();
        if (out) strcpy(out, "[]");
        return out;
    }

    if (p)
    {
        /* Compose the output array. */
        i = p->offset;
        ptr = ensure(p, ); if (!ptr) return ;    *ptr = '[';    p->offset++;
        child = item->child;
        while (child && !fail)
        {
            print_value(child, depth + , fmt, p);
            p->offset = update(p);
            if (child->next) { len = fmt ?  : ; ptr = ensure(p, len + ); if (!ptr) return ; *ptr++ = ','; if (fmt)*ptr++ = ' '; *ptr = ; p->offset += len; }
            child = child->next;
        }
        ptr = ensure(p, ); if (!ptr) return ;    *ptr++ = ']'; *ptr = ;
        out = (p->buffer) + i;
    }
    else
    {
        /* Allocate an array to hold the values for each */
        entries = (char**)cJSON_malloc(numentries * sizeof(char*));
        if (!entries) return ;
        memset(entries, , numentries * sizeof(char*));
        /* Retrieve all the results: */
        child = item->child;
        while (child && !fail)
        {
            ret = print_value(child, depth + , fmt, );
            entries[i++] = ret;
            if (ret) len += strlen(ret) +  + (fmt ?  : ); else fail = ;
            child = child->next;
        }

        /* If we didn't fail, try to malloc the output string */
        if (!fail)    out = (char*)cJSON_malloc(len);
        /* If that fails, we fail. */
        if (!out) fail = ;

        /* Handle failure. */
        if (fail)
        {
            for (i = ; i<numentries; i++) if (entries[i]) cJSON_free(entries[i]);
            cJSON_free(entries);
            return ;
        }

        /* Compose the output array. */
        *out = '[';
        ptr = out + ; *ptr = ;
        for (i = ; i<numentries; i++)
        {
            tmplen = strlen(entries[i]); memcpy(ptr, entries[i], tmplen); ptr += tmplen;
            if (i != numentries - ) { *ptr++ = ','; if (fmt)*ptr++ = ' '; *ptr = ; }
            cJSON_free(entries[i]);
        }
        cJSON_free(entries);
        *ptr++ = ']'; *ptr++ = ;
    }
    return out;
}