cJSON源码分析3-核心解析算法

最新推荐文章于 2024-08-13 19:27:57 发布
最新推荐文章于 2024-08-13 19:27:57 发布
阅读量820 收藏 10
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/charles1e/article/details/100053847
版权

解析函数

对于字符串，调用cJSON_Parse解析为一个cJSON对象

CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);

parser_buffer

为存解析的字符串，使用parse_buffer.

//解析的缓存
typedef struct
{
    const unsigned char *content; //字符串内容
    size_t length; //长度
    size_t offset; //当前位置
    size_t depth; //当前位置对象或数组的深度
    internal_hooks hooks; //使用的hook
} parse_buffer;

parse_buffer常用函数的宏定义：

//判断buffer能否读取到第size个字节。条件：buffer不为空，且buffer当前的位置+size不大于buffer的总长度
#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))
//是否能方位index位置
#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
//在offset位置的字符串指针
#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)

具体解析过程

//调用cJSON_ParseWithOpts
CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value)
{
    return cJSON_ParseWithOpts(value, 0, 0);
}

CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated)
{
    //1.1 初始化解析的buffer
    parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } };
    //item是返回的cJSON对象
    cJSON *item = NULL;

    /* reset error position */
    //1.2 初始化全局错误
    global_error.json = NULL;
    global_error.position = 0;

    if (value == NULL)
    {
        goto fail;
    }
    //2. 填充buffer
    buffer.content = (const unsigned char*)value;
    buffer.length = strlen((const char*)value) + sizeof("");
    buffer.offset = 0;
    buffer.hooks = global_hooks;
    //3. 创建一个节点
    item = cJSON_New_Item(&global_hooks); 
    if (item == NULL) /* memory fail */
    {
        goto fail;
    }
    //4. 先去掉utf8的BOM，再去掉前导的空白，然后解析
    if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer))))
    {
        /* parse failure. ep is set. */
        goto fail;
    }

    /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
    //字符串已经解析完
    //5. 如果要求必须以'\0'结尾,检查最后一个字符
    if (require_null_terminated) 
    {
        buffer_skip_whitespace(&buffer);
        if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0')
        {
            goto fail;
        }
    }
    //6. 返回解析后的buffer
    if (return_parse_end) 
    {
        *return_parse_end = (const char*)buffer_at_offset(&buffer);
    }
    //7. 返回解析后的cJSON
    return item;

fail:
    //出错处理
    if (item != NULL)
    {
        cJSON_Delete(item);
    }

    if (value != NULL)
    {
        error local_error;
        local_error.json = (const unsigned char*)value;
        local_error.position = 0;

        if (buffer.offset < buffer.length)
        {
            local_error.position = buffer.offset;
        }
        else if (buffer.length > 0)
        {
            local_error.position = buffer.length - 1;
        }

        if (return_parse_end != NULL)
        {
            *return_parse_end = (const char*)local_error.json + local_error.position;
        }

        global_error = local_error;
    }

    return NULL;
}


//解析时跳过前导的空格
static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
{
    if ((buffer == NULL) || (buffer->content == NULL))
    {
        return NULL;
    }
    //这里ascii码<=32都认为是空格
    while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
    {
       buffer->offset++;
    }

    if (buffer->offset == buffer->length)
    {
        buffer->offset--;
    }

    return buffer;
}

//去掉UTF-8 BOM "\xEF\xBB\xBF"
static parse_buffer *skip_utf8_bom(parse_buffer * const buffer)
{
    if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0))
    {
        return NULL;
    }
    //去掉前导的BOM
    if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0))
    {
        buffer->offset += 3;
    }

    return buffer;
}

parse

在parse_buffer中做了一些逻辑处理后，主要的解析在parse函数中.

/*
解析核心算法：从buffer中解析出一个节点
item:解析后的item
input_buffer:输入的字符串
*/
static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer)
{
    if ((input_buffer == NULL) || (input_buffer->content == NULL))
    {
        return false; /* no input */
    }
    //1.1 解析null:前面4个字符为null
    if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0))
    {
        item->type = cJSON_NULL;
        input_buffer->offset += 4;
        return true;
    }
    //1.2 解析false: 前面5个字符为false
    if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0))
    {
        item->type = cJSON_False;
        input_buffer->offset += 5;
        return true;
    }
    //1.3 解析true: 前面4个字符为true
    if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0))
    {
        item->type = cJSON_True;
        item->valueint = 1;
        input_buffer->offset += 4;
        return true;
    }
    //1.4 解析string, 以"开头。调用parse_string
    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"'))
    {
        return parse_string(item, input_buffer);
    }
    //1.5 解析数字：以-开头或者0-9开头。调用parse_number
    if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9'))))
    {
        return parse_number(item, input_buffer);
    }
    //1.6 解析数组：以[开头。调用parse_array
    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '['))
    {
        return parse_array(item, input_buffer);
    }
    //1.7 解析对象，以{开头。调用parse_object
    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{'))
    {
        return parse_object(item, input_buffer);
    }

    return false;
}

字符串解析

调用parse_string解析字符串。

//解析字符串
static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer)
{
    const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; //跳过第一个"
    const unsigned char *input_end = buffer_at_offset(input_buffer) + 1;//跳过第一个"
    unsigned char *output_pointer = NULL;
    unsigned char *output = NULL;

    /* not a string */ 
    //1. 不是以"开头，不是字符串，直接返回
    if (buffer_at_offset(input_buffer)[0] != '\"')
    {
        goto fail;
    }

    {
        /* calculate approximate size of the output (overestimate) */
        //2. 计算存放这些字符串需要的空间
        size_t allocation_length = 0;
        size_t skipped_bytes = 0;
        //2.1 一直到字符串结尾"，此后input_end指向最后一个字符
        while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"'))
        {
            /* is escape sequence */
            if (input_end[0] == '\\') //为反斜杠，说明遇到了转义字符
            { //出错：以\\结尾
                if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length)
                {
                    /* prevent buffer overflow when last input character is a backslash */
                    goto fail;
                }
                skipped_bytes++; //跳过字符+1
                input_end++; //字符串指针向前+1
            }
            input_end++; //继续判断下一个字符
        }
        //2.2 再次判断字符串是不是正确以"结尾
        if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"'))
        {
            goto fail; /* string ended unexpectedly */
        }

        /* This is at most how much we need for the output */
        //2.3 需要的最大的存储字符串长度
        allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes;
        //2.4 output存放解析后的字符串
        output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof(""));
        if (output == NULL)
        {
            goto fail; /* allocation failure */
        }
    }
    //3. 输出的字符串指针指向解析字符串存放的位置
    output_pointer = output;
    /* loop through the string literal */
    //4. 解析字符串
    while (input_pointer < input_end)
    {
        //4.1 不是转义字符，直接判断下一个
        if (*input_pointer != '\\') 
        {
            *output_pointer++ = *input_pointer++;
        }
        /* escape sequence */
        else //4.2 处理转义字符
        {
            unsigned char sequence_length = 2; //4.2.1 当前处理的序列长度
            // "/t", input_end指向最后的",input_pointer指向/
            if ((input_end - input_pointer) < 1) 
            {
                goto fail;
            }
            //4.2.2 根据下一个字符判断
            switch (input_pointer[1])
            {
                //转义字符
                case 'b':
                    *output_pointer++ = '\b';
                    break;
                case 'f':
                    *output_pointer++ = '\f';
                    break;
                case 'n':
                    *output_pointer++ = '\n';
                    break;
                case 'r':
                    *output_pointer++ = '\r';
                    break;
                case 't':
                    *output_pointer++ = '\t';
                    break;
                case '\"':
                case '\\':
                case '/':
                    *output_pointer++ = input_pointer[1];
                    break;

                /* UTF-16 literal */
                //UTF-16的处理
                case 'u':
                    sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer);
                    if (sequence_length == 0)
                    {
                        /* failed to convert UTF16-literal to UTF-8 */
                        goto fail;
                    }
                    break;
  
                default:
                    goto fail;
            }
            //input跳过的字节数
            input_pointer += sequence_length;
        }
    }

    /* zero terminate the output */
    //5. 分析完所有的字符串，天界结束符
    *output_pointer = '\0';
    //6. 填充item结构体
    item->type = cJSON_String;
    item->valuestring = (char*)output;

    input_buffer->offset = (size_t) (input_end - input_buffer->content);
    input_buffer->offset++;

    return true;

fail:
    //失败的处理
    if (output != NULL)
    {
        input_buffer->hooks.deallocate(output);
    }

    if (input_pointer != NULL)
    {
        input_buffer->offset = (size_t)(input_pointer - input_buffer->content);
    }

    return false;
}

UTF-16转UTF-8

UTF-8 的编码单元是 8 位的字节、UTF-16 为 16 位。JSON字符串中的 \uXXXX 是以 16 进制表示码点 U+0000 至 U+FFFF。如果第一个码点是 U+D800 至 U+DBFF，我们便知道它的代码对的高代理项（high surrogate），之后应该伴随一个 U+DC00 至 U+DFFF 的低代理项（low surrogate）。然后，我们用下列公式把代理对 (H, L) 变换成真实的码点：
codepoint = 0x10000 + (H − 0xD800) × 0x400 + (L − 0xDC00)

码点范围码点位数字节1字节2字节3字节4
U+0000~U+007F70xxxxxxx
U+0080~U+07FF11110xxxxx10xxxxxx
U+0800~U+FFFF161110xxxx10xxxxxx10xxxxxx
U+10000~U+10FFFF2111110xxx10xxxxxx10xxxxxx10xxxxxx
/* parse 4 digit hexadecimal number */
//把四位16进制的数转为十进制的数
static unsigned parse_hex4(const unsigned char * const input)
{
    unsigned int h = 0;
    size_t i = 0;

    for (i = 0; i < 4; i++)
    {
        /* parse digit */
        if ((input[i] >= '0') && (input[i] <= '9'))
        {
            h += (unsigned int) input[i] - '0';
        }
        else if ((input[i] >= 'A') && (input[i] <= 'F'))
        {
            h += (unsigned int) 10 + input[i] - 'A';
        }
        else if ((input[i] >= 'a') && (input[i] <= 'f'))
        {
            h += (unsigned int) 10 + input[i] - 'a';
        }
        else /* invalid */
        {
            return 0;
        }

        if (i < 3)
        {
            /* shift left to make place for the next nibble */
            h = h << 4;
        }
    }

    return h;
}

/* converts a UTF-16 literal to UTF-8
 * A literal can be one or two sequences of the form \uXXXX */
//utf-16转为utf-8
static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer)
{
    long unsigned int codepoint = 0;
    unsigned int first_code = 0;
    const unsigned char *first_sequence = input_pointer;
    unsigned char utf8_length = 0;
    unsigned char utf8_position = 0;
    unsigned char sequence_length = 0;
    unsigned char first_byte_mark = 0;
    //至少有6个字符
    if ((input_end - first_sequence) < 6)
    {
        /* input ends unexpectedly */
        goto fail;
    }

    /* get the first utf16 sequence */
    first_code = parse_hex4(first_sequence + 2);

    /* check that the code is valid */
    //检查第一个码点，有效范围为0xDC00~0xDFFF
    if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) //无效字符
    {
        goto fail;
    }

    /* UTF16 surrogate pair */
    //如果在U+D800 至 U+DBFF，还有低代理项
    if ((first_code >= 0xD800) && (first_code <= 0xDBFF)) 
    {
        const unsigned char *second_sequence = first_sequence + 6;
        unsigned int second_code = 0;
        sequence_length = 12; /* \uXXXX\uXXXX */

        if ((input_end - second_sequence) < 6)
        {
            /* input ends unexpectedly */
            goto fail;
        }

        if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u'))
        {
            /* missing second half of the surrogate pair */
            goto fail;
        }

        /* get the second utf16 sequence */
        second_code = parse_hex4(second_sequence + 2);
        /* check that the code is valid */
        if ((second_code < 0xDC00) || (second_code > 0xDFFF))
        {
            /* invalid second half of the surrogate pair */
            goto fail;
        }


        /* calculate the unicode codepoint from the surrogate pair */
        //对于有高代理项，码点计算方法codepoint = 0x10000 + (H − 0xD800) × 0x400 + (L − 0xDC00)
        codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF));
    }
    else
    {
        //对于\uxxxx格式的
        sequence_length = 6; /* \uXXXX */
        codepoint = first_code;
    }

    /* encode as UTF-8
     * takes at maximum 4 bytes to encode:
     * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
    if (codepoint < 0x80) //U+0000~U+007F
    {
        /* normal ascii, encoding 0xxxxxxx */
        utf8_length = 1;
    }
    else if (codepoint < 0x800) //U+0080~U+07FF
    {
        /* two bytes, encoding 110xxxxx 10xxxxxx */
        utf8_length = 2;
        first_byte_mark = 0xC0; /* 11000000 */
    }
    else if (codepoint < 0x10000) //U+0800~U+FFFF
    {
        /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */
        utf8_length = 3;
        first_byte_mark = 0xE0; /* 11100000 */
    }
    else if (codepoint <= 0x10FFFF)//U+10000~U+10FFFF
    {
        /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */
        utf8_length = 4;
        first_byte_mark = 0xF0; /* 11110000 */
    }
    else
    {
        /* invalid unicode codepoint */
        goto fail;
    }

    /* encode as utf8 */ 
    //1000 0000 10111111
    for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--)
    {
        /* 10xxxxxx */
        (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF);
        codepoint >>= 6;
    }
    /* encode first byte */
    if (utf8_length > 1)
    {
        (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF);
    }
    else
    {
        (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F);
    }

    *output_pointer += utf8_length;

    return sequence_length;

fail:
    return 0;
}

解析数字

解析数字时，把数字的字符串复制出来，调用strtod函数

//解析数字
static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer)
{
    double number = 0;
    unsigned char *after_end = NULL;
    unsigned char number_c_string[64]; //存放数字的字符串
    unsigned char decimal_point = get_decimal_point();
    size_t i = 0;

    if ((input_buffer == NULL) || (input_buffer->content == NULL))
    {
        return false;
    }
    for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++)
    {
        switch (buffer_at_offset(input_buffer)[i])
        {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            case '+':
            case '-':
            case 'e':
            case 'E':
                number_c_string[i] = buffer_at_offset(input_buffer)[i];
                break;

            case '.':
                number_c_string[i] = decimal_point;
                break;

            default:
                goto loop_end;
        }
    }
loop_end:
    number_c_string[i] = '\0';
    //使用strtod解析数字，after_end返回解析完成后的下一个的字符的位置 11.22abc 解析后after_end指向a
    number = strtod((const char*)number_c_string, (char**)&after_end);
    if (number_c_string == after_end) //解析出错
    {
        return false; /* parse_error */
    }

    item->valuedouble = number;

    /* use saturation in case of overflow */
    if (number >= INT_MAX)
    {
        item->valueint = INT_MAX;
    }
    else if (number <= (double)INT_MIN)
    {
        item->valueint = INT_MIN;
    }
    else
    {
        item->valueint = (int)number; //转为整数
    }

    item->type = cJSON_Number;

    input_buffer->offset += (size_t)(after_end - number_c_string);
    return true;
}

解析数组

解析数组比较简单，遇到[，后面直到遇到,就是一个item, 遇到]解析完毕。

static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer)
{
    cJSON *head = NULL; /* head of the linked list */
    cJSON *current_item = NULL;

    if (input_buffer->depth >= CJSON_NESTING_LIMIT)
    {
        return false; /* to deeply nested */
    }
    input_buffer->depth++; //1. 深度+1

    if (buffer_at_offset(input_buffer)[0] != '[') 
    {
        /* not an array */
        goto fail;
    }

    input_buffer->offset++;
    buffer_skip_whitespace(input_buffer); //2. 移除空格
    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']'))
    {
        //3.1 空的数组
        goto success;
    }

    /* check if we skipped to the end of the buffer */
    if (cannot_access_at_index(input_buffer, 0))
    {
        input_buffer->offset--;
        goto fail;
    }

    /* step back to character in front of the first element */
    input_buffer->offset--;
    /* loop through the comma separated array elements */
    //3.2 开始解析每一个以逗号分隔的item
    do
    {
        /* allocate next item */
        //3.2.1 创建item
        cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
        if (new_item == NULL)
        {
            goto fail; /* allocation failure */
        }

        /* attach next item to list */
        //3.2.2 插入item
        if (head == NULL)
        {
            /* start the linked list */
            current_item = head = new_item;
        }
        else
        {
            /* add to the end and advance */
            current_item->next = new_item;
            new_item->prev = current_item;
            current_item = new_item;
        }

        /* parse next value */
        //3.2.3 解析下一个值
        input_buffer->offset++;
        buffer_skip_whitespace(input_buffer);
        if (!parse_value(current_item, input_buffer)) //解析数组中的元素
        {
            goto fail; /* failed to parse value */
        }
        buffer_skip_whitespace(input_buffer); //3.2.4 移除空格
    }
    while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
    //4. 解析完了字符，判断是否以]结尾
    if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']')
    {
        goto fail; /* expected end of array */
    }

success:
    //5.1 解析成功，设置item
    input_buffer->depth--;

    item->type = cJSON_Array;
    item->child = head;

    input_buffer->offset++;

    return true;

fail:
    //5.2 解析失败，释放item
    if (head != NULL)
    {
        cJSON_Delete(head);
    }

    return false;
}

解析对象

解析对象和解析数组类似。

/*解析object*/
static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer)
{
    cJSON *head = NULL; /* linked list head */
    cJSON *current_item = NULL;

    if (input_buffer->depth >= CJSON_NESTING_LIMIT)
    {
        return false; /* to deeply nested */
    }
    input_buffer->depth++;

    if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{'))
    {
        goto fail; /* not an object */
    }

    input_buffer->offset++;
    buffer_skip_whitespace(input_buffer);
    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}'))
    {
        goto success; /* empty object */
    }

    /* check if we skipped to the end of the buffer */
    if (cannot_access_at_index(input_buffer, 0))
    {
        input_buffer->offset--;
        goto fail;
    }

    /* step back to character in front of the first element */
    input_buffer->offset--;
    /* loop through the comma separated array elements */
    do
    {
        /* allocate next item */
        cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
        if (new_item == NULL)
        {
            goto fail; /* allocation failure */
        }

        /* attach next item to list */
        if (head == NULL)
        {
            /* start the linked list */
            current_item = head = new_item;
        }
        else
        {
            /* add to the end and advance */
            current_item->next = new_item;
            new_item->prev = current_item;
            current_item = new_item;
        }

        /* parse the name of the child */
        input_buffer->offset++;
        buffer_skip_whitespace(input_buffer);
        if (!parse_string(current_item, input_buffer))
        {
            goto fail; /* failed to parse name */
        }
        buffer_skip_whitespace(input_buffer);

        /* swap valuestring and string, because we parsed the name */
        current_item->string = current_item->valuestring;
        current_item->valuestring = NULL;

        if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':'))
        {
            goto fail; /* invalid object */
        }

        /* parse the value */
        input_buffer->offset++;
        buffer_skip_whitespace(input_buffer);
        if (!parse_value(current_item, input_buffer))
        {
            goto fail; /* failed to parse value */
        }
        buffer_skip_whitespace(input_buffer);
    }
    while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));

    if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}'))
    {
        goto fail; /* expected end of object */
    }

success:
    input_buffer->depth--;

    item->type = cJSON_Object;
    item->child = head;

    input_buffer->offset++;
    return true;

fail:
    if (head != NULL)
    {
        cJSON_Delete(head);
    }

    return false;
}
延禾xy
关注
专栏目录
cJSON源码，解析JSON数据
03-13
C语言解析JSON格式数据
零基础学习cJSON 源码详解与应用 （四）cJSON_Parse()；解析json字符串
热门推荐
杀手的博客
12-02 2万+
文章目录一，解析json字符串示例二，代码解析2.1 parse_buffer 结构体2.2 skip_utf8_bom();2.3 buffer_skip_whitespace();2.4 parse_value(); 上一章介绍了从cjson结构体到json字符串的过程，这一章是逆过程，就是将json字符串转换成cjson结构体。逆过程与上一章思路上是一脉相承的。紧紧围绕着cjson结构体与json的格式。 一，解析json字符串示例 还记得在第一章第二节的应用场景示例吗，通过http接口获取到天气
使用cJSON库解析JSON字符串
最新发布
qqwangfan的专栏
08-13 249
（1） 首先调用cJSON_Parse()函数，解析JSON数据包，并按照cJSON结构体的结构序列化整个数据包。（2）调用cJSON_GetObjectItem()函数，可从cJSON结构体中查找某个子节点名称（键名称），如果查找成功可把该子节点序列化到cJSON结构体中。（3） 如果需要使用cJSON结构体中的内容，可通过cJSON结构体中的valueint和valuestring取出有价值的内容（即键的值）//通过cJSON_Delete()，释放cJSON_Parse()分配出来的内存空间。
cJSON使用解析
zyf方的博客
12-29 4161
cJSON_Parse(pdata); //传递数据接口 提供一个JSON块，这将返回一个可以查询的CJSON对象。完成后调用return cJSON_ParseWithOpts(value,0,0) 1.1cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated...
全面详解C语言使用cJSON解析JSON字符
void*_的博客
06-04 1万+
cJSON对象的实现采用了树形结构，每个对象是树的一个节点，每个节点由cJSON这个结构体组成，对象中的元素也由cJSON这个结构体组成。同一层的对象和元素是双向链表结构，由next和prev指针链接。不同层的对象或元素由child指针链接起来。type表示对象或元素类型，string表示对象或节点的名称。元素的值存储在valuestring, valueint和valuedouble中。cJS...
利用cJSON解析JSON格式
pjwshuai的博客
05-31 9791
利用cJSON解析JSON格式，附案例
数据交互协议——JSON
numyan的博客
07-31 1649
作者：konishi5202 链接：https://www.jianshu.com/p/4fcb49b55ff6 来源：简书 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 JSON概述 1.1 JSON介绍 JSON：JavaScript对象表示法（JavaScript Object Notation）。是一种轻量级的数据交换格式。它基于ECMAScript的一个子集。JSON采用完全独立于语言的文本格式，但是也使用了类似C语音家族的习惯（包括C、C++、C#、Java、JavaSc
cJSON源码分析
brook666
11-17 4322
因为最近在和ONENET云平台数据通信相关的项目中遇到对JSON数据的处理，于是对cJSON进行了深入研究，感觉收益匪浅，如沐春风，当然个人觉得代码格式阅读起来不是特别方便。前人种树，后人乘凉，希望整理的内容可以给道友门学习cJSON的时候提供绵薄之力，当然不足之处请各位道友批评指正，下面是我在学习过程中的相关资料。 JSON入门教程 JSON官方介绍 cJSON源码下载 一、JSON 先...
CJSON的源码，C语言学习库
08-11
CJSON库的实现是基于递归下降解析器，这是一种常见的解析算法，它直接处理输入的字符序列，逐个分析形成JSON结构。此外，`cJSON.c`还包含了一些辅助函数，用于内存管理和错误处理。 学习CJSON源码对于理解JSON解析...
cJSON_Delete源码剖析
专注【PostgreSQL源码学习&研究】
07-17 2698
文章目录1. 释放cJSON结构体变量2.3. 1. 释放cJSON结构体变量      见名知意, cJSON_Delete 函数用于释放一个cJSON结构体变量所申请的内存空间. 在阅读本章节内容之前, 我强烈推荐你先阅读 cJSON数据组装框架 章节, 这对你理解本节内容有很重要的帮助.      先附上cJSON_Delele函数的内部代码实现: void cJSON_Delete(cJSON *c) { cJSON *next; while (c) { next=c->ne
【cJSON】JSON数据解析
08-18
【cJSON】JSON数据解析 pdf文档 学习c/c++编程的资料
【0000】PostgreSQL V13.2内核源码剖析专栏（2018 ~ 2024.10.24 更新）
专注【PostgreSQL源码学习&研究】
12-13 3981
本专栏将会持续更新，直到将PostgreSQL V13.2源码涉及的所有原理、技术剖析完成为止。每一篇文章都是经过多次的源码阅读 + 调试，得以验证之后才梳理成文章形式。最终该专栏的文章数量应该在一万篇或以下，这也是文章序号从【0000】开始的缘故。通过本专栏的学习，能够让你掌握PostgreSQL数据库中的每个技术背后，底层的实现原理。
OpenHarmony源码分析之分布式软总线：trans_service模块(5)/TCP会话管理
weixin_46669761的博客
05-28 844
一、概述 trans_service模块基于系统内核提供的socket通信，向authmanager模块提供设备认证通道管理和设备认证数据的传输；向业务模块提供session管理和基于session的数据收发功能，并且通过GCM模块的加密功能提供收发报文的加解密保护。 本文将继续介绍鸿蒙系统的会话机制的管理，承接上文OpenHarmony源码分析之分布式软总线：trans_service模块(4)/TCP会话管理的内容，本文将介绍鸿蒙系统如何处理客户端发起的请求消息。 二、源码分析 在上文提到的OnPro
JSON篇：解析json报文
但行前路 无问西东
10-24 6435
JSON 通常用于与服务端交换数据。在接收服务器数据时一般是字符串。 解析JSON字符串 首先，调用cJSON_Parse()函数， recvJSON = cJSON_Parse(szBuffer); //parse str to json 其次调用cJSON_GetArraySize()函数 size = cJSON_GetArraySize(recvJSON);//get json siz...
cJSON C语言库解析和生成JSON数据
shufawangzhang的博客
03-11 1462
cJSON是一个轻量级的C语言库，用于解析和生成JSON数据。它提供了简洁而高效的API，使得在C语言中处理JSON数据变得简单和方便。以下是一些cJSON库的主要特点和用法：解析JSON数据：使用cJSON_Parse函数可以将JSON字符串解析为cJSON对象。该函数会返回一个指向根节点的指针。如果解析失败，返回NULL。生成JSON数据：使用cJSON_CreateObject和cJSON_CreateArray等函数可以创建cJSON对象。
linux下c/c++实例 cJSON库解析json字符串
u010871058的专栏
03-15 3365
一、简介      cJOSN库，仅有两个文件cJSON.c和cJSON.h。下载地址：http://sourceforge.net/projects/cjson/files/?source=navbar。二、详解1、cJOSN结构体（1）json的数据结构：[html] view plain copytypedef struct cJSON {       struct cJSON *next,...
cJSON函数用法
BYTEDANCE的博客
12-02 1551
cJson函数用法
配置文件之json——Json格式与cJson库解析
YoYo的桃子树
08-24 2316
1. 引言 这段时间做个项目，要加一个配置文件。配置文件之前有用过ini、yaml、lua，这次正好碰巧项目里还要加MQTT，要用到json，就直接拿json来做配置文件了。 其实json很多人是不建议做配置文件的，毕竟没有注释，格式对于手写也不是很友善，但是就当尝试一下新事物嘛，感受一下总是好的。 OK，开始。 2. Json格式 Json相比与ini文件来说，格式要复杂一些。虽然基本单元也是键值对。 从参考链接1里摘了一段，基本上记住这些就够了： JSON对象是一个无序的"名称/值"键值对的集合：
"深入解析Linux中cJSON源码及实例调用
在本文中，我们将对Linux中CJSON部分源码进行分析，并通过简单的实例调用来加深对其原理和用法的理解。 CJSON源码中包含了一些关键的数据结构和函数，我们首先来看一下其中的一些重要部分。在CJSON中，最核心的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值