ANSI C中的超轻量级JSON解析器
JSON（JavaScript对象表示法）是一种轻量级的数据交换格式。人类易于阅读和书写。机器很容易解析和生成。它基于JavaScript编程语言标准ECMA-262第三版（1999年12月）的子集 。JSON是一种完全独立于语言的文本格式，但是使用C语言家族（包括C，C ++，C＃，Java，JavaScript，Perl，Python等）的程序员熟悉的约定。这些属性使JSON成为理想的数据交换语言。
cJSON旨在成为您可以完成工作的最简单的解析器。它是资源只有一个C的头文件和C文件，所以方便移植。它可以为你各种需要的json字符串处理，包括打包、解析、修改、删除、添加等。在这里将一探究竟。
在这里将着重叙述json的打包和解析，更多处理玩法，见文章末尾链接。
开始cJSON
cJSON合并到您的项目
因为整个库只有一个C文件和一个头文件，所以您只需复制cJSON.h并复制cJSON.c到项目源并开始使用它。
cJSON用ANSI C（C89）编写，以便支持尽可能多的平台和编译器。
下载：
https://github.com/DaveGamble/cJSON/releases
Cjson结构体
/* The cJSON structure: */ typedef struct cJSON { struct cJSON *next; struct cJSON *prev; struct cJSON *child; int type; char *valuestring; int valueint; double valuedouble; char *string; } cJSON;
结构体项解析：
next 和prev ：Cjson结构体作为一个双向连表的环，可以通过 next 和prev 指针进行连表遍历
child：可以是cJSON_Array、cJSON_Object类型数据
type：当前项的类型
valuestring：内容存储，当类型是cJSON_String和cJSON_Raw
valueint：内容存储，整型，可以是cJSON_False、cJSON_True数据
valuedouble：内容存储，浮点型，当类型是cJSON_Number
string：键名
数据类型
l cJSON_Invalid表示一个不包含任何值的无效项目。如果将项目设置为全零字节，则将自动具有此类型。
l cJSON_False表示一个false布尔值。您也可以使用来检查布尔值cJSON_IsBool
l cJSON_True表示一个true布尔值。您也可以使用来检查布尔值cJSON_IsBool
l cJSON_NULL表示一个null值
l cJSON_Number 表示一个数字值。该值存储为double in valuedouble和in valueint。如果数字超出整数范围，INT_MAX或INT_MIN用于valueint
l cJSON_String表示一个字符串值。它以零终止字符串的形式存储在中valuestring
l cJSON_Array表示一个数组值。这是通过指向表示数组中值child的cJSON项目的链接列表来实现的。使用next和将元素链接在一起prev，其中第一个元素具有prev.next == NULL和最后一个元素next == NULL
l cJSON_Object 表示一个对象值。对象的存储方式与数组相同，唯一的区别是对象中的项将其键存储在中string
l cJSON_Raw表示以JSON字符存储的零终止形式的任何JSON valuestring。例如，可以使用它来避免一遍又一遍地打印相同的静态JSON以节省性能。解析时，cJSON永远不会创建此类型。另请注意，cJSON不会检查其是否为有效JSON。
类型
#define cJSON_Invalid (0) #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_Raw (1 << 7) /* raw json */
类型判断
cJSON_IsInvalid(const cJSON * const item); cJSON_IsFalse(const cJSON * const item); cJSON_IsTrue(const cJSON * const item); cJSON_IsBool(const cJSON * const item); cJSON_IsNull(const cJSON * const item); cJSON_IsNumber(const cJSON * const item); cJSON_IsString(const cJSON * const item); cJSON_IsArray(const cJSON * const item); cJSON_IsObject(const cJSON * const item); cJSON_IsRaw(const cJSON * const item);
注意
创建cjson对象后，处理完需要进行内存释放：
如果是cjson里的对象，请使用cJSON_Delete()
如果不是对象：cJSON_free()或free()
零字符
cJSON不支持包含零字符‘\0‘或的字符串\u0000。对于当前的API，这是不可能的，因为字符串以零结尾。
字符编码
cJSON仅支持UTF-8编码的输入。但是在大多数情况下，它不会拒绝无效的UTF-8作为输入，而只是将其原样传播。只要输入不包含无效的UTF-8，输出将始终是有效的UTF-8。
C标准
cJSON用ANSI C（或C89，C90）编写。如果您的编译器或C库未遵循此标准，则不能保证正确的行为。
注意：ANSI C不是C ++，因此不应使用C ++编译器进行编译。您可以使用C编译器对其进行编译，然后将其与C ++代码链接。尽管可以使用C ++编译器进行编译，但是不能保证正确的行为。
浮点数字
double除IEEE754双精度浮点数外，cJSON不正式支持任何实现。它可能仍然可以与其他实现一起使用，但是这些实现的错误将被视为无效。
目前，cJSON支持的浮点文字的最大长度为63个字符。
数组和对象的深层嵌套
cJSON不支持嵌套太深的数组和对象，因为这会导致堆栈溢出。为了防止这种CJSON_NESTING_LIMIT情况，默认情况下，cJSON将深度限制为1000，但是可以在编译时进行更改。
格式化输出
按标准的格式输出json字符串，输出完后一定要记得释放内存
代码
1 #include <stdio.h> 2 #include "cJSON.h" 3 #include "cJSON.c" 4 void main(){ 5 //待解析字符串 6 char *json_str="{\"key1\":\"dongxiaodong\",\"key2\":1998,\"key3\":55778}"; 7 8 //输出原字符串 9 printf("原字符串：%s\r\n",json_str); 10 11 //解析成json对象 12 cJSON * json_obj = cJSON_Parse(json_str); 13 14 //格式输出 15 char *json_print_str=NULL; 16 json_print_str=cJSON_Print(json_obj); 17 printf("\r\n输出内容：\r\n\r\n%s\r\n",json_print_str); 18 19 //释放资源 20 free(json_print_str); 21 22 //释放资源 23 cJSON_Delete(json_obj); 24 }
json打包
cJSON_CreateObject函数可创建一个根数据项，在此之后就可以添加各种数据类型的子节点了，使用完成后需要通过cJSON_Delete()释放内存。
创建一层级的json
代码：
1 #include <stdio.h> 2 #include "cJSON.h" 3 #include "cJSON.c" 4 void main(){ 5 cJSON *root_obj = NULL;//根，json对象 6 char *out_str = NULL; //输出结果 7 root_obj =cJSON_CreateObject();//创建 8 //添加一个字符串，参数（根对象，键，值） 9 cJSON_AddStringToObject(root_obj, "key1", "dongxiaodong"); 10 //添加一个整型，参数（根对象，键，值） 11 cJSON_AddNumberToObject(root_obj, "key2",1998); 12 //添加一个浮点型，参数（根对象，键，值） 13 cJSON_AddNumberToObject(root_obj, "key3",22.33); 14 //添加一个bool类型，参数（根对象，键，值） 15 //bool值可以是0/1或false/true 16 cJSON_AddBoolToObject(root_obj, "key4",0); 17 //将json对象打包成字符串 18 out_str = cJSON_PrintUnformatted(root_obj); 19 //销毁json对象，释放内存 20 cJSON_Delete(root_obj); 21 //输出值：{"key1":"dongxiaodong","key2":1998,"key3":22.33,"key4":false} 22 printf("%s",out_str); 23 }
类型创建函数还有：
cJSON_AddNullToObject(cJSON * const object, const char * const name);
cJSON_AddTrueToObject(cJSON * const object, const char * const name);
cJSON_AddFalseToObject(cJSON * const object, const char * const name);
cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
cJSON_AddObjectToObject(cJSON * const object, const char * const name);
cJSON_AddArrayToObject(cJSON * const object, const char * const name);
创建多层级的json
代码：
1 #include <stdio.h> 2 #include "cJSON.h" 3 #include "cJSON.c" 4 void main(){ 5 cJSON *root_obj = NULL;//根，json对象 6 cJSON *item_obj = NULL;//二级json对象 7 char *out_str = NULL; //输出结果 8 9 root_obj =cJSON_CreateObject();//创建 10 //添加一个字符串，参数（根对象，键，值） 11 cJSON_AddStringToObject(root_obj, "key1", "dongxiaodong"); 12 //添加一个整型，参数（根对象，键，值） 13 cJSON_AddNumberToObject(root_obj, "key2",1998); 14 15 //创建一个子json对象 16 item_obj= cJSON_AddObjectToObject(root_obj,"myson"); 17 //向孩子对象中添加内容 18 cJSON_AddStringToObject(item_obj, "sonkey1", "东小东"); 19 cJSON_AddNumberToObject(item_obj, "sonkey2",2020); 20 21 //将json对象打包成字符串 22 out_str = cJSON_PrintUnformatted(root_obj); 23 //销毁json对象，释放内存 24 cJSON_Delete(root_obj); 25 //输出值：{"key1":"dongxiaodong","key2":1998,"myson":{"sonkey1":"东小东","sonkey2":2020}} 26 printf("%s",out_str); 27 }
创建多层json(数组形式)
代码
1 #include <stdio.h> 2 #include "cJSON.h" 3 #include "cJSON.c" 4 void main(){ 5 cJSON *root_obj = NULL;//根，json对象 6 cJSON *item_obj = NULL;//数组对象 7 char *out_str = NULL; //输出结果 8 9 root_obj =cJSON_CreateObject();//创建 10 //添加一个字符串，参数（根对象，键，值） 11 cJSON_AddStringToObject(root_obj, "key1", "dongxiaodong"); 12 //添加一个整型，参数（根对象，键，值） 13 cJSON_AddNumberToObject(root_obj, "key2",1998); 14 15 //创建一个子数组对象 16 item_obj= cJSON_AddArrayToObject(root_obj,"myson"); 17 //向数组对象中添加内容 18 cJSON_AddItemToArray(item_obj,cJSON_CreateTrue()); 19 cJSON_AddItemToArray(item_obj,cJSON_CreateNumber(22)); 20 21 //将json对象打包成字符串 22 out_str = cJSON_PrintUnformatted(root_obj); 23 //销毁json对象，释放内存 24 cJSON_Delete(root_obj); 25 //输出值：{"key1":"dongxiaodong","key2":1998,"myson":[true,22]} 26 printf("%s",out_str); 27 }
创建的对象还可以是下面这些
cJSON_CreateNull(void);
cJSON_CreateTrue(void);
cJSON_CreateFalse(void);
cJSON_CreateBool(cJSON_bool boolean);
cJSON_CreateNumber(double num);
cJSON_CreateString(const char *string);
cJSON_CreateRaw(const char *raw);
cJSON_CreateArray(void);
cJSON_CreateObject(void);
创建混合json
代码
1 #include <stdio.h> 2 #include "cJSON.h" 3 #include "cJSON.c" 4 void main(){ 5 cJSON *root_obj = NULL;//根，json对象 6 cJSON *son_obj=NULL; 7 cJSON *item_obj = NULL;//数组对象 8 char *out_str = NULL; //输出结果 9 10 //根对象 11 root_obj =cJSON_CreateObject();//创建 12 //添加一个字符串，参数（根对象，键，值） 13 cJSON_AddStringToObject(root_obj, "key1", "dongxiaodong"); 14 //添加一个整型，参数（根对象，键，值） 15 cJSON_AddNumberToObject(root_obj, "key2",1998); 16 17 //创建一个子数组对象 18 item_obj= cJSON_AddArrayToObject(root_obj,"myson"); 19 //向数组对象中添加内容 20 cJSON_AddItemToArray(item_obj,cJSON_CreateTrue()); 21 cJSON_AddItemToArray(item_obj,cJSON_CreateNumber(22)); 22 23 //子对象 24 son_obj =cJSON_CreateObject();//创建 25 //添加一个字符串，参数（根对象，键，值） 26 cJSON_AddStringToObject(son_obj, "son1", "dongxiaodong"); 27 //添加一个整型，参数（根对象，键，值） 28 cJSON_AddNumberToObject(son_obj, "son2",1998); 29 cJSON_AddItemToArray(item_obj,son_obj); 30 31 //将json对象打包成字符串 32 out_str = cJSON_PrintUnformatted(root_obj); 33 //销毁json对象，释放内存 34 cJSON_Delete(root_obj); 35 //输出值：{"key1":"dongxiaodong","key2":1998,"myson":[true,22,{"son1":"dongxiaodong","son2":1998}]} 36 printf("%s",out_str); 37 }
json解析
解析一层级的json
代码：
1 #include <stdio.h> 2 #include "cJSON.h" 3 #include "cJSON.c" 4 void main(){ 5 //待解析字符串 6 char *json_str="{\"key1\":\"dongxiaodong\",\"key2\":1998,\"key3\":22.33,\"key4\":true}"; 7 //解析成json对象 8 cJSON * json_obj = cJSON_Parse(json_str); 9 10 //项存储 11 cJSON *item=NULL; 12 13 //输出原字符串 14 printf("原字符串：%s\r\n",json_str); 15 16 //获取string类型 17 item=cJSON_GetObjectItem(json_obj,"key1"); 18 printf("\r\nkey1：%s\r\n",item->valuestring); 19 cJSON_Delete(item);//释放资源 20 21 //获取数字 22 item=cJSON_GetObjectItem(json_obj,"key2"); 23 printf("\r\nkey2：%d\r\n",item->valueint); 24 cJSON_Delete(item);//释放资源 25 26 //获取数字 27 item=cJSON_GetObjectItem(json_obj,"key3"); 28 printf("\r\nkey3：%f\r\n",item->valuedouble); 29 cJSON_Delete(item);//释放资源 30 31 //获取bool 32 item=cJSON_GetObjectItem(json_obj,"key4"); 33 printf("\r\nkey4：%d\r\n",item->valueint); 34 cJSON_Delete(item);//释放资源 35 36 //是否资源 37 cJSON_Delete(json_obj); 38 }
解析多层级的json
代码
1 #include <stdio.h> 2 #include "cJSON.h" 3 #include "cJSON.c" 4 void main(){ 5 //待解析字符串 6 char *json_str="{\"key1\":\"dongxiaodong\",\"key2\":1998,\"myson\":{\"sonkey1\":\"东小东\",\"sonkey2\":2020}}"; 7 //解析成json对象 8 cJSON * json_obj = cJSON_Parse(json_str); 9 10 //项存储 11 cJSON *item=NULL; 12 //内部项存储 13 cJSON * item_item=NULL; 14 15 //输出原字符串 16 printf("原字符串：%s\r\n",json_str); 17 18 //获取string类型 19 item=cJSON_GetObjectItem(json_obj,"key1"); 20 printf("\r\nkey1：%s\r\n",item->valuestring); 21 cJSON_Delete(item);//释放资源 22 23 //获取数字 24 item=cJSON_GetObjectItem(json_obj,"key2"); 25 printf("\r\nkey2：%d\r\n",item->valueint); 26 cJSON_Delete(item);//释放资源 27 28 //子串 29 item=cJSON_GetObjectItem(json_obj,"myson"); 30 item_item=cJSON_GetObjectItem(item,"sonkey1"); 31 printf("\r\nmyson(sonkey1)：%s\r\n",item_item->valuestring); 32 cJSON_Delete(item_item);//释放资源 33 34 item_item=cJSON_GetObjectItem(item,"sonkey2"); 35 printf("\r\nmyson(sonkey2)：%d\r\n",item_item->valueint); 36 cJSON_Delete(item_item);//释放资源 37 38 cJSON_Delete(item);//释放资源 39 40 //释放资源 41 cJSON_Delete(json_obj); 42 }
解析多层json(数组形式)
代码
1 #include <stdio.h> 2 #include "cJSON.h" 3 #include "cJSON.c" 4 void main(){ 5 //待解析字符串 6 char *json_str="{\"key1\":\"dongxiaodong\",\"key2\":1998,\"myson\":[true,113]}"; 7 //解析成json对象 8 cJSON * json_obj = cJSON_Parse(json_str); 9 10 //项存储 11 cJSON *item=NULL; 12 //内部项存储 13 cJSON * item_item=NULL; 14 15 //输出原字符串 16 printf("原字符串：%s\r\n",json_str); 17 18 //获取string类型 19 item=cJSON_GetObjectItem(json_obj,"key1"); 20 printf("\r\nkey1：%s\r\n",item->valuestring); 21 cJSON_Delete(item);//释放资源 22 23 //获取数字 24 item=cJSON_GetObjectItem(json_obj,"key2"); 25 printf("\r\nkey2：%d\r\n",item->valueint); 26 cJSON_Delete(item);//释放资源 27 28 //获取子串 29 item=cJSON_GetObjectItem(json_obj,"myson"); 30 31 //输出数组大小 32 printf("\r\n数组大小：%d\r\n",cJSON_GetArraySize(item)); 33 34 //输出项1内容 35 item_item=cJSON_GetArrayItem(item,0); 36 printf("\r\nmyson(0)：%d\r\n",item_item->valueint); 37 //cJSON_Delete(item_item);//释放资源 38 39 //输出项2内容 40 item_item=cJSON_GetArrayItem(item,1); 41 printf("\r\nmyson(1)：%d\r\n",item_item->valueint); 42 cJSON_Delete(item_item);//释放资源 43 44 cJSON_Delete(item);//释放资源 45 46 //释放资源 47 cJSON_Delete(json_obj); 48 }
解析混合json
代码
1 #include <stdio.h> 2 #include "cJSON.h" 3 #include "cJSON.c" 4 void main(){ 5 //待解析字符串 6 char *json_str="{\"key1\":\"dongxiaodong\",\"key2\":1998,\"myson\":[true,22,{\"son1\":\"dongxiaodong\",\"son2\":1998}]}"; 7 //解析成json对象 8 cJSON * json_obj = cJSON_Parse(json_str); 9 10 //项存储 11 cJSON *item=NULL; 12 //内部项存储 13 cJSON * item_item=NULL; 14 15 //输出原字符串 16 printf("原字符串：%s\r\n",json_str); 17 18 //获取string类型 19 item=cJSON_GetObjectItem(json_obj,"key1"); 20 printf("\r\nkey1：%s\r\n",item->valuestring); 21 cJSON_Delete(item);//释放资源 22 23 //获取数字 24 item=cJSON_GetObjectItem(json_obj,"key2"); 25 printf("\r\nkey2：%d\r\n",item->valueint); 26 cJSON_Delete(item);//释放资源 27 28 //获取子串 29 item=cJSON_GetObjectItem(json_obj,"myson"); 30 31 //输出数组大小 32 printf("\r\n数组大小：%d\r\n",cJSON_GetArraySize(item)); 33 34 //输出项1内容 35 item_item=cJSON_GetArrayItem(item,0); 36 printf("\r\nmyson(0)：%d\r\n",item_item->valueint); 37 //cJSON_Delete(item_item);//释放资源 38 39 //输出项2内容 40 item_item=cJSON_GetArrayItem(item,1); 41 printf("\r\nmyson(1)：%d\r\n",item_item->valueint); 42 cJSON_Delete(item_item);//释放资源 43 44 //项3内容 45 item_item=cJSON_GetArrayItem(item,2); 46 cJSON *item_item_son=NULL; 47 48 item_item_son =cJSON_GetObjectItem(item_item,"son1"); 49 printf("\r\nmyson(2)(son1）：%s\r\n",item_item_son->valuestring); 50 cJSON_Delete(item_item_son);//释放资源 51 52 item_item_son =cJSON_GetObjectItem(item_item,"son2"); 53 printf("\r\nmyson(2)(son2）：%d\r\n",item_item_son->valueint); 54 cJSON_Delete(item_item_son);//释放资源 55 cJSON_Delete(item_item);//释放资源 56 57 cJSON_Delete(item);//释放资源 58 59 //释放资源 60 cJSON_Delete(json_obj); 61 }
附件：
cJSON.h
1 /* 2 Copyright (c) 2009-2017 Dave Gamble and cJSON contributors 3 4 Permission is hereby granted, free of charge, to any person obtaining a copy 5 of this software and associated documentation files (the "Software"), to deal 6 in the Software without restriction, including without limitation the rights 7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 8 copies of the Software, and to permit persons to whom the Software is 9 furnished to do so, subject to the following conditions: 10 11 The above copyright notice and this permission notice shall be included in 12 all copies or substantial portions of the Software. 13 14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 20 THE SOFTWARE. 21 */ 22 23 #ifndef cJSON__h 24 #define cJSON__h 25 26 #ifdef __cplusplus 27 extern "C" 28 { 29 #endif 30 31 #if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32)) 32 #define __WINDOWS__ 33 #endif 34 35 #ifdef __WINDOWS__ 36 37 /* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention. For windows you have 3 define options: 38 39 CJSON_HIDE_SYMBOLS - Define this in the case where you don‘t want to ever dllexport symbols 40 CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default) 41 CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol 42 43 For *nix builds that support visibility attribute, you can define similar behavior by 44 45 setting default visibility to hidden by adding 46 -fvisibility=hidden (for gcc) 47 or 48 -xldscope=hidden (for sun cc) 49 to CFLAGS 50 51 then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does 52 53 */ 54 55 #define CJSON_CDECL __cdecl 56 #define CJSON_STDCALL __stdcall 57 58 /* export symbols by default, this is necessary for copy pasting the C and header file */ 59 #if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS) 60 #define CJSON_EXPORT_SYMBOLS 61 #endif 62 63 #if defined(CJSON_HIDE_SYMBOLS) 64 #define CJSON_PUBLIC(type) type CJSON_STDCALL 65 #elif defined(CJSON_EXPORT_SYMBOLS) 66 #define CJSON_PUBLIC(type) __declspec(dllexport) type CJSON_STDCALL 67 #elif defined(CJSON_IMPORT_SYMBOLS) 68 #define CJSON_PUBLIC(type) __declspec(dllimport) type CJSON_STDCALL 69 #endif 70 #else /* !__WINDOWS__ */ 71 #define CJSON_CDECL 72 #define CJSON_STDCALL 73 74 #if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY) 75 #define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type 76 #else 77 #define CJSON_PUBLIC(type) type 78 #endif 79 #endif 80 81 /* project version */ 82 #define CJSON_VERSION_MAJOR 1 83 #define CJSON_VERSION_MINOR 7 84 #define CJSON_VERSION_PATCH 13 85 86 #include <stddef.h> 87 88 /* cJSON Types: */ 89 #define cJSON_Invalid (0) 90 #define cJSON_False (1 << 0) 91 #define cJSON_True (1 << 1) 92 #define cJSON_NULL (1 << 2) 93 #define cJSON_Number (1 << 3) 94 #define cJSON_String (1 << 4) 95 #define cJSON_Array (1 << 5) 96 #define cJSON_Object (1 << 6) 97 #define cJSON_Raw (1 << 7) /* raw json */ 98 99 #define cJSON_IsReference 256 100 #define cJSON_StringIsConst 512 101 102 /* The cJSON structure: */ 103 typedef struct cJSON 104 { 105 /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ 106 struct cJSON *next; 107 struct cJSON *prev; 108 /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ 109 struct cJSON *child; 110 111 /* The type of the item, as above. */ 112 int type; 113 114 /* The item‘s string, if type==cJSON_String and type == cJSON_Raw */ 115 char *valuestring; 116 /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */ 117 int valueint; 118 /* The item‘s number, if type==cJSON_Number */ 119 double valuedouble; 120 121 /* The item‘s name string, if this item is the child of, or is in the list of subitems of an object. */ 122 char *string; 123 } cJSON; 124 125 typedef struct cJSON_Hooks 126 { 127 /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */ 128 void *(CJSON_CDECL *malloc_fn)(size_t sz); 129 void (CJSON_CDECL *free_fn)(void *ptr); 130 } cJSON_Hooks; 131 132 typedef int cJSON_bool; 133 134 /* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them. 135 * This is to prevent stack overflows. */ 136 #ifndef CJSON_NESTING_LIMIT 137 #define CJSON_NESTING_LIMIT 1000 138 #endif 139 140 /* returns the version of cJSON as a string */ 141 CJSON_PUBLIC(const char*) cJSON_Version(void); 142 143 /* Supply malloc, realloc and free functions to cJSON */ 144 CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks); 145 146 /* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */ 147 /* Supply a block of JSON, and this returns a cJSON object you can interrogate. */ 148 CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value); 149 CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length); 150 /* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */ 151 /* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */ 152 CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated); 153 CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated); 154 155 /* Render a cJSON entity to text for transfer/storage. */ 156 CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item); 157 /* Render a cJSON entity to text for transfer/storage without any formatting. */ 158 CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item); 159 /* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */ 160 CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt); 161 /* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */ 162 /* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */ 163 CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format); 164 /* Delete a cJSON entity and all subentities. */ 165 CJSON_PUBLIC(void) cJSON_Delete(cJSON *item); 166 167 /* Returns the number of items in an array (or object). */ 168 CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array); 169 /* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */ 170 CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index); 171 /* Get item "string" from object. Case insensitive. */ 172 CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string); 173 CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string); 174 CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string); 175 /* For analysing failed parses. This returns a pointer to the parse error. You‘ll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */ 176 CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void); 177 178 /* Check item type and return its value */ 179 CJSON_PUBLIC(char *) cJSON_GetStringValue(cJSON *item); 180 CJSON_PUBLIC(double) cJSON_GetNumberValue(cJSON *item); 181 182 /* These functions check the type of an item */ 183 CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item); 184 CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item); 185 CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item); 186 CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item); 187 CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item); 188 CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item); 189 CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item); 190 CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item); 191 CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item); 192 CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item); 193 194 /* These calls create a cJSON item of the appropriate type. */ 195 CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void); 196 CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void); 197 CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void); 198 CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean); 199 CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num); 200 CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string); 201 /* raw json */ 202 CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw); 203 CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void); 204 CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void); 205 206 /* Create a string where valuestring references a string so 207 * it will not be freed by cJSON_Delete */ 208 CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string); 209 /* Create an object/array that only references it‘s elements so 210 * they will not be freed by cJSON_Delete */ 211 CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child); 212 CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child); 213 214 /* These utilities create an Array of count items. 215 * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/ 216 CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count); 217 CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count); 218 CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count); 219 CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count); 220 221 /* Append item to the specified array/object. */ 222 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item); 223 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item); 224 /* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object. 225 * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before 226 * writing to `item->string` */ 227 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item); 228 /* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don‘t want to corrupt your existing cJSON. */ 229 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item); 230 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item); 231 232 /* Remove/Detach items from Arrays/Objects. */ 233 CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item); 234 CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which); 235 CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which); 236 CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string); 237 CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string); 238 CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string); 239 CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string); 240 241 /* Update array items. */ 242 CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */ 243 CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement); 244 CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem); 245 CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem); 246 CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem); 247 248 /* Duplicate a cJSON item */ 249 CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse); 250 /* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will 251 * need to be released. With recurse!=0, it will duplicate any children connected to the item. 252 * The item->next and ->prev pointers are always zero on return from Duplicate. */ 253 /* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal. 254 * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */ 255 CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive); 256 257 /* Minify a strings, remove blank characters(such as ‘ ‘, ‘\t‘, ‘\r‘, ‘\n‘) from strings. 258 * The input pointer json cannot point to a read-only address area, such as a string constant, 259 * but should point to a readable and writable adress area. */ 260 CJSON_PUBLIC(void) cJSON_Minify(char *json); 261 262 /* Helper functions for creating and adding items to an object at the same time. 263 * They return the added item or NULL on failure. */ 264 CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name); 265 CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name); 266 CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name); 267 CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean); 268 CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number); 269 CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string); 270 CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw); 271 CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name); 272 CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name); 273 274 /* When assigning an integer value, it needs to be propagated to valuedouble too. */ 275 #define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number)) 276 /* helper for the cJSON_SetNumberValue macro */ 277 CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number); 278 #define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number)) 279 /* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */ 280 CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring); 281 282 /* Macro for iterating over an array or object */ 283 #define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next) 284 285 /* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */ 286 CJSON_PUBLIC(void *) cJSON_malloc(size_t size); 287 CJSON_PUBLIC(void) cJSON_free(void *object); 288 289 #ifdef __cplusplus 290 } 291 #endif 292 293 #endif
cJSON.c
1 /* 2 Copyright (c) 2009-2017 Dave Gamble and cJSON contributors 3 4 Permission is hereby granted, free of charge, to any person obtaining a copy 5 of this software and associated documentation files (the "Software"), to deal 6 in the Software without restriction, including without limitation the rights 7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 8 copies of the Software, and to permit persons to whom the Software is 9 furnished to do so, subject to the following conditions: 10 11 The above copyright notice and this permission notice shall be included in 12 all copies or substantial portions of the Software. 13 14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 20 THE SOFTWARE. 21 */ 22 23 /* cJSON */ 24 /* JSON parser in C. */ 25 26 /* disable warnings about old C89 functions in MSVC */ 27 #if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) 28 #define _CRT_SECURE_NO_DEPRECATE 29 #endif 30 31 #ifdef __GNUC__ 32 #pragma GCC visibility push(default) 33 #endif 34 #if defined(_MSC_VER) 35 #pragma warning (push) 36 /* disable warning about single line comments in system headers */ 37 #pragma warning (disable : 4001) 38 #endif 39 40 #include <string.h> 41 #include <stdio.h> 42 #include <math.h> 43 #include <stdlib.h> 44 #include <limits.h> 45 #include <ctype.h> 46 #include <float.h> 47 48 #ifdef ENABLE_LOCALES 49 #include <locale.h> 50 #endif 51 52 #if defined(_MSC_VER) 53 #pragma warning (pop) 54 #endif 55 #ifdef __GNUC__ 56 #pragma GCC visibility pop 57 #endif 58 59 #include "cJSON.h" 60 61 /* define our own boolean type */ 62 #ifdef true 63 #undef true 64 #endif 65 #define true ((cJSON_bool)1) 66 67 #ifdef false 68 #undef false 69 #endif 70 #define false ((cJSON_bool)0) 71 72 /* define isnan and isinf for ANSI C, if in C99 or above, isnan and isinf has been defined in math.h */ 73 #ifndef isinf 74 #define isinf(d) (isnan((d - d)) && !isnan(d)) 75 #endif 76 #ifndef isnan 77 #define isnan(d) (d != d) 78 #endif 79 80 #ifndef NAN 81 #define NAN 0.0/0.0 82 #endif 83 84 typedef struct { 85 const unsigned char *json; 86 size_t position; 87 } error; 88 static error global_error = { NULL, 0 }; 89 90 CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void) 91 { 92 return (const char*) (global_error.json + global_error.position); 93 } 94 95 CJSON_PUBLIC(char *) cJSON_GetStringValue(cJSON *item) 96 { 97 if (!cJSON_IsString(item)) 98 { 99 return NULL; 100 } 101 102 return item->valuestring; 103 } 104 105 CJSON_PUBLIC(double) cJSON_GetNumberValue(cJSON *item) 106 { 107 if (!cJSON_IsNumber(item)) 108 { 109 return NAN; 110 } 111 112 return item->valuedouble; 113 } 114 115 /* This is a safeguard to prevent copy-pasters from using incompatible C and header files */ 116 #if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 13) 117 #error cJSON.h and cJSON.c have different versions. Make sure that both have the same. 118 #endif 119 120 CJSON_PUBLIC(const char*) cJSON_Version(void) 121 { 122 static char version[15]; 123 sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH); 124 125 return version; 126 } 127 128 /* Case insensitive string comparison, doesn‘t consider two NULL pointers equal though */ 129 static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2) 130 { 131 if ((string1 == NULL) || (string2 == NULL)) 132 { 133 return 1; 134 } 135 136 if (string1 == string2) 137 { 138 return 0; 139 } 140 141 for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++) 142 { 143 if (*string1 == ‘\0‘) 144 { 145 return 0; 146 } 147 } 148 149 return tolower(*string1) - tolower(*string2); 150 } 151 152 typedef struct internal_hooks 153 { 154 void *(CJSON_CDECL *allocate)(size_t size); 155 void (CJSON_CDECL *deallocate)(void *pointer); 156 void *(CJSON_CDECL *reallocate)(void *pointer, size_t size); 157 } internal_hooks; 158 159 #if defined(_MSC_VER) 160 /* work around MSVC error C2322: ‘...‘ address of dllimport ‘...‘ is not static */ 161 static void * CJSON_CDECL internal_malloc(size_t size) 162 { 163 return malloc(size); 164 } 165 static void CJSON_CDECL internal_free(void *pointer) 166 { 167 free(pointer); 168 } 169 static void * CJSON_CDECL internal_realloc(void *pointer, size_t size) 170 { 171 return realloc(pointer, size); 172 } 173 #else 174 #define internal_malloc malloc 175 #define internal_free free 176 #define internal_realloc realloc 177 #endif 178 179 /* strlen of character literals resolved at compile time */ 180 #define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) 181 182 static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc }; 183 184 static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks) 185 { 186 size_t length = 0; 187 unsigned char *copy = NULL; 188 189 if (string == NULL) 190 { 191 return NULL; 192 } 193 194 length = strlen((const char*)string) + sizeof(""); 195 copy = (unsigned char*)hooks->allocate(length); 196 if (copy == NULL) 197 { 198 return NULL; 199 } 200 memcpy(copy, string, length); 201 202 return copy; 203 } 204 205 CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks) 206 { 207 if (hooks == NULL) 208 { 209 /* Reset hooks */ 210 global_hooks.allocate = malloc; 211 global_hooks.deallocate = free; 212 global_hooks.reallocate = realloc; 213 return; 214 } 215 216 global_hooks.allocate = malloc; 217 if (hooks->malloc_fn != NULL) 218 { 219 global_hooks.allocate = hooks->malloc_fn; 220 } 221 222 global_hooks.deallocate = free; 223 if (hooks->free_fn != NULL) 224 { 225 global_hooks.deallocate = hooks->free_fn; 226 } 227 228 /* use realloc only if both free and malloc are used */ 229 global_hooks.reallocate = NULL; 230 if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free)) 231 { 232 global_hooks.reallocate = realloc; 233 } 234 } 235 236 /* Internal constructor. */ 237 static cJSON *cJSON_New_Item(const internal_hooks * const hooks) 238 { 239 cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON)); 240 if (node) 241 { 242 memset(node, ‘\0‘, sizeof(cJSON)); 243 } 244 245 return node; 246 } 247 248 /* Delete a cJSON structure. */ 249 CJSON_PUBLIC(void) cJSON_Delete(cJSON *item) 250 { 251 cJSON *next = NULL; 252 while (item != NULL) 253 { 254 next = item->next; 255 if (!(item->type & cJSON_IsReference) && (item->child != NULL)) 256 { 257 cJSON_Delete(item->child); 258 } 259 if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) 260 { 261 global_hooks.deallocate(item->valuestring); 262 } 263 if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) 264 { 265 global_hooks.deallocate(item->string); 266 } 267 global_hooks.deallocate(item); 268 item = next; 269 } 270 } 271 272 /* get the decimal point character of the current locale */ 273 static unsigned char get_decimal_point(void) 274 { 275 #ifdef ENABLE_LOCALES 276 struct lconv *lconv = localeconv(); 277 return (unsigned char) lconv->decimal_point[0]; 278 #else 279 return ‘.‘; 280 #endif 281 } 282 283 typedef struct 284 { 285 const unsigned char *content; 286 size_t length; 287 size_t offset; 288 size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */ 289 internal_hooks hooks; 290 } parse_buffer; 291 292 /* check if the given size is left to read in a given parse buffer (starting with 1) */ 293 #define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) 294 /* check if the buffer can be accessed at the given index (starting with 0) */ 295 #define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) 296 #define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) 297 /* get a pointer to the buffer at the position */ 298 #define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) 299 300 /* Parse the input text to generate a number, and populate the result into item. */ 301 static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer) 302 { 303 double number = 0; 304 unsigned char *after_end = NULL; 305 unsigned char number_c_string[64]; 306 unsigned char decimal_point = get_decimal_point(); 307 size_t i = 0; 308 309 if ((input_buffer == NULL) || (input_buffer->content == NULL)) 310 { 311 return false; 312 } 313 314 /* copy the number into a temporary buffer and replace ‘.‘ with the decimal point 315 * of the current locale (for strtod) 316 * This also takes care of ‘\0‘ not necessarily being available for marking the end of the input */ 317 for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++) 318 { 319 switch (buffer_at_offset(input_buffer)[i]) 320 { 321 case ‘0‘: 322 case ‘1‘: 323 case ‘2‘: 324 case ‘3‘: 325 case ‘4‘: 326 case ‘5‘: 327 case ‘6‘: 328 case ‘7‘: 329 case ‘8‘: 330 case ‘9‘: 331 case ‘+‘: 332 case ‘-‘: 333 case ‘e‘: 334 case ‘E‘: 335 number_c_string[i] = buffer_at_offset(input_buffer)[i]; 336 break; 337 338 case ‘.‘: 339 number_c_string[i] = decimal_point; 340 break; 341 342 default: 343 goto loop_end; 344 } 345 } 346 loop_end: 347 number_c_string[i] = ‘\0‘; 348 349 number = strtod((const char*)number_c_string, (char**)&after_end); 350 if (number_c_string == after_end) 351 { 352 return false; /* parse_error */ 353 } 354 355 item->valuedouble = number; 356 357 /* use saturation in case of overflow */ 358 if (number >= INT_MAX) 359 { 360 item->valueint = INT_MAX; 361 } 362 else if (number <= (double)INT_MIN) 363 { 364 item->valueint = INT_MIN; 365 } 366 else 367 { 368 item->valueint = (int)number; 369 } 370 371 item->type = cJSON_Number; 372 373 input_buffer->offset += (size_t)(after_end - number_c_string); 374 return true; 375 } 376 377 /* don‘t ask me, but the original cJSON_SetNumberValue returns an integer or double */ 378 CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number) 379 { 380 if (number >= INT_MAX) 381 { 382 object->valueint = INT_MAX; 383 } 384 else if (number <= (double)INT_MIN) 385 { 386 object->valueint = INT_MIN; 387 } 388 else 389 { 390 object->valueint = (int)number; 391 } 392 393 return object->valuedouble = number; 394 } 395 396 CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring) 397 { 398 char *copy = NULL; 399 /* if object‘s type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */ 400 if (!(object->type & cJSON_String) || (object->type & cJSON_IsReference)) 401 { 402 return NULL; 403 } 404 if (strlen(valuestring) <= strlen(object->valuestring)) 405 { 406 strcpy(object->valuestring, valuestring); 407 return object->valuestring; 408 } 409 copy = (char*) cJSON_strdup((const unsigned char*)valuestring, &global_hooks); 410 if (copy == NULL) 411 { 412 return NULL; 413 } 414 if (object->valuestring != NULL) 415 { 416 cJSON_free(object->valuestring); 417 } 418 object->valuestring = copy; 419 420 return copy; 421 } 422 423 typedef struct 424 { 425 unsigned char *buffer; 426 size_t length; 427 size_t offset; 428 size_t depth; /* current nesting depth (for formatted printing) */ 429 cJSON_bool noalloc; 430 cJSON_bool format; /* is this print a formatted print */ 431 internal_hooks hooks; 432 } printbuffer; 433 434 /* realloc printbuffer if necessary to have at least "needed" bytes more */ 435 static unsigned char* ensure(printbuffer * const p, size_t needed) 436 { 437 unsigned char *newbuffer = NULL; 438 size_t newsize = 0; 439 440 if ((p == NULL) || (p->buffer == NULL)) 441 { 442 return NULL; 443 } 444 445 if ((p->length > 0) && (p->offset >= p->length)) 446 { 447 /* make sure that offset is valid */ 448 return NULL; 449 } 450 451 if (needed > INT_MAX) 452 { 453 /* sizes bigger than INT_MAX are currently not supported */ 454 return NULL; 455 } 456 457 needed += p->offset + 1; 458 if (needed <= p->length) 459 { 460 return p->buffer + p->offset; 461 } 462 463 if (p->noalloc) { 464 return NULL; 465 } 466 467 /* calculate new buffer size */ 468 if (needed > (INT_MAX / 2)) 469 { 470 /* overflow of int, use INT_MAX if possible */ 471 if (needed <= INT_MAX) 472 { 473 newsize = INT_MAX; 474 } 475 else 476 { 477 return NULL; 478 } 479 } 480 else 481 { 482 newsize = needed * 2; 483 } 484 485 if (p->hooks.reallocate != NULL) 486 { 487 /* reallocate with realloc if available */ 488 newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize); 489 if (newbuffer == NULL) 490 { 491 p->hooks.deallocate(p->buffer); 492 p->length = 0; 493 p->buffer = NULL; 494 495 return NULL; 496 } 497 } 498 else 499 { 500 /* otherwise reallocate manually */ 501 newbuffer = (unsigned char*)p->hooks.allocate(newsize); 502 if (!newbuffer) 503 { 504 p->hooks.deallocate(p->buffer); 505 p->length = 0; 506 p->buffer = NULL; 507 508 return NULL; 509 } 510 if (newbuffer) 511 { 512 memcpy(newbuffer, p->buffer, p->offset + 1); 513 } 514 p->hooks.deallocate(p->buffer); 515 } 516 p->length = newsize; 517 p->buffer = newbuffer; 518 519 return newbuffer + p->offset; 520 } 521 522 /* calculate the new length of the string in a printbuffer and update the offset */ 523 static void update_offset(printbuffer * const buffer) 524 { 525 const unsigned char *buffer_pointer = NULL; 526 if ((buffer == NULL) || (buffer->buffer == NULL)) 527 { 528 return; 529 } 530 buffer_pointer = buffer->buffer + buffer->offset; 531 532 buffer->offset += strlen((const char*)buffer_pointer); 533 } 534 535 /* securely comparison of floating-point variables */ 536 static cJSON_bool compare_double(double a, double b) 537 { 538 double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b); 539 return (fabs(a - b) <= maxVal * DBL_EPSILON); 540 } 541 542 /* Render the number nicely from the given item into a string. */ 543 static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer) 544 { 545 unsigned char *output_pointer = NULL; 546 double d = item->valuedouble; 547 int length = 0; 548 size_t i = 0; 549 unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */ 550 unsigned char decimal_point = get_decimal_point(); 551 double test = 0.0; 552 553 if (output_buffer == NULL) 554 { 555 return false; 556 } 557 558 /* This checks for NaN and Infinity */ 559 if (isnan(d) || isinf(d)) 560 { 561 length = sprintf((char*)number_buffer, "null"); 562 } 563 else 564 { 565 /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */ 566 length = sprintf((char*)number_buffer, "%1.15g", d); 567 568 /* Check whether the original double can be recovered */ 569 if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d)) 570 { 571 /* If not, print with 17 decimal places of precision */ 572 length = sprintf((char*)number_buffer, "%1.17g", d); 573 } 574 } 575 576 /* sprintf failed or buffer overrun occurred */ 577 if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) 578 { 579 return false; 580 } 581 582 /* reserve appropriate space in the output */ 583 output_pointer = ensure(output_buffer, (size_t)length + sizeof("")); 584 if (output_pointer == NULL) 585 { 586 return false; 587 } 588 589 /* copy the printed number to the output and replace locale 590 * dependent decimal point with ‘.‘ */ 591 for (i = 0; i < ((size_t)length); i++) 592 { 593 if (number_buffer[i] == decimal_point) 594 { 595 output_pointer[i] = ‘.‘; 596 continue; 597 } 598 599 output_pointer[i] = number_buffer[i]; 600 } 601 output_pointer[i] = ‘\0‘; 602 603 output_buffer->offset += (size_t)length; 604 605 return true; 606 } 607 608 /* parse 4 digit hexadecimal number */ 609 static unsigned parse_hex4(const unsigned char * const input) 610 { 611 unsigned int h = 0; 612 size_t i = 0; 613 614 for (i = 0; i < 4; i++) 615 { 616 /* parse digit */ 617 if ((input[i] >= ‘0‘) && (input[i] <= ‘9‘)) 618 { 619 h += (unsigned int) input[i] - ‘0‘; 620 } 621 else if ((input[i] >= ‘A‘) && (input[i] <= ‘F‘)) 622 { 623 h += (unsigned int) 10 + input[i] - ‘A‘; 624 } 625 else if ((input[i] >= ‘a‘) && (input[i] <= ‘f‘)) 626 { 627 h += (unsigned int) 10 + input[i] - ‘a‘; 628 } 629 else /* invalid */ 630 { 631 return 0; 632 } 633 634 if (i < 3) 635 { 636 /* shift left to make place for the next nibble */ 637 h = h << 4; 638 } 639 } 640 641 return h; 642 } 643 644 /* converts a UTF-16 literal to UTF-8 645 * A literal can be one or two sequences of the form \uXXXX */ 646 static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer) 647 { 648 long unsigned int codepoint = 0; 649 unsigned int first_code = 0; 650 const unsigned char *first_sequence = input_pointer; 651 unsigned char utf8_length = 0; 652 unsigned char utf8_position = 0; 653 unsigned char sequence_length = 0; 654 unsigned char first_byte_mark = 0; 655 656 if ((input_end - first_sequence) < 6) 657 { 658 /* input ends unexpectedly */ 659 goto fail; 660 } 661 662 /* get the first utf16 sequence */ 663 first_code = parse_hex4(first_sequence + 2); 664 665 /* check that the code is valid */ 666 if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) 667 { 668 goto fail; 669 } 670 671 /* UTF16 surrogate pair */ 672 if ((first_code >= 0xD800) && (first_code <= 0xDBFF)) 673 { 674 const unsigned char *second_sequence = first_sequence + 6; 675 unsigned int second_code = 0; 676 sequence_length = 12; /* \uXXXX\uXXXX */ 677 678 if ((input_end - second_sequence) < 6) 679 { 680 /* input ends unexpectedly */ 681 goto fail; 682 } 683 684 if ((second_sequence[0] != ‘\\‘) || (second_sequence[1] != ‘u‘)) 685 { 686 /* missing second half of the surrogate pair */ 687 goto fail; 688 } 689 690 /* get the second utf16 sequence */ 691 second_code = parse_hex4(second_sequence + 2); 692 /* check that the code is valid */ 693 if ((second_code < 0xDC00) || (second_code > 0xDFFF)) 694 { 695 /* invalid second half of the surrogate pair */ 696 goto fail; 697 } 698 699 700 /* calculate the unicode codepoint from the surrogate pair */ 701 codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF)); 702 } 703 else 704 { 705 sequence_length = 6; /* \uXXXX */ 706 codepoint = first_code; 707 } 708 709 /* encode as UTF-8 710 * takes at maximum 4 bytes to encode: 711 * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ 712 if (codepoint < 0x80) 713 { 714 /* normal ascii, encoding 0xxxxxxx */ 715 utf8_length = 1; 716 } 717 else if (codepoint < 0x800) 718 { 719 /* two bytes, encoding 110xxxxx 10xxxxxx */ 720 utf8_length = 2; 721 first_byte_mark = 0xC0; /* 11000000 */ 722 } 723 else if (codepoint < 0x10000) 724 { 725 /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */ 726 utf8_length = 3; 727 first_byte_mark = 0xE0; /* 11100000 */ 728 } 729 else if (codepoint <= 0x10FFFF) 730 { 731 /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */ 732 utf8_length = 4; 733 first_byte_mark = 0xF0; /* 11110000 */ 734 } 735 else 736 { 737 /* invalid unicode codepoint */ 738 goto fail; 739 } 740 741 /* encode as utf8 */ 742 for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) 743 { 744 /* 10xxxxxx */ 745 (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF); 746 codepoint >>= 6; 747 } 748 /* encode first byte */ 749 if (utf8_length > 1) 750 { 751 (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF); 752 } 753 else 754 { 755 (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F); 756 } 757 758 *output_pointer += utf8_length; 759 760 return sequence_length; 761 762 fail: 763 return 0; 764 } 765 766 /* Parse the input text into an unescaped cinput, and populate item. */ 767 static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer) 768 { 769 const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; 770 const unsigned char *input_end = buffer_at_offset(input_buffer) + 1; 771 unsigned char *output_pointer = NULL; 772 unsigned char *output = NULL; 773 774 /* not a string */ 775 if (buffer_at_offset(input_buffer)[0] != ‘\"‘) 776 { 777 goto fail; 778 } 779 780 { 781 /* calculate approximate size of the output (overestimate) */ 782 size_t allocation_length = 0; 783 size_t skipped_bytes = 0; 784 while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != ‘\"‘)) 785 { 786 /* is escape sequence */ 787 if (input_end[0] == ‘\\‘) 788 { 789 if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) 790 { 791 /* prevent buffer overflow when last input character is a backslash */ 792 goto fail; 793 } 794 skipped_bytes++; 795 input_end++; 796 } 797 input_end++; 798 } 799 if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != ‘\"‘)) 800 { 801 goto fail; /* string ended unexpectedly */ 802 } 803 804 /* This is at most how much we need for the output */ 805 allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes; 806 output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof("")); 807 if (output == NULL) 808 { 809 goto fail; /* allocation failure */ 810 } 811 } 812 813 output_pointer = output; 814 /* loop through the string literal */ 815 while (input_pointer < input_end) 816 { 817 if (*input_pointer != ‘\\‘) 818 { 819 *output_pointer++ = *input_pointer++; 820 } 821 /* escape sequence */ 822 else 823 { 824 unsigned char sequence_length = 2; 825 if ((input_end - input_pointer) < 1) 826 { 827 goto fail; 828 } 829 830 switch (input_pointer[1]) 831 { 832 case ‘b‘: 833 *output_pointer++ = ‘\b‘; 834 break; 835 case ‘f‘: 836 *output_pointer++ = ‘\f‘; 837 break; 838 case ‘n‘: 839 *output_pointer++ = ‘\n‘; 840 break; 841 case ‘r‘: 842 *output_pointer++ = ‘\r‘; 843 break; 844 case ‘t‘: 845 *output_pointer++ = ‘\t‘; 846 break; 847 case ‘\"‘: 848 case ‘\\‘: 849 case ‘/‘: 850 *output_pointer++ = input_pointer[1]; 851 break; 852 853 /* UTF-16 literal */ 854 case ‘u‘: 855 sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer); 856 if (sequence_length == 0) 857 { 858 /* failed to convert UTF16-literal to UTF-8 */ 859 goto fail; 860 } 861 break; 862 863 default: 864 goto fail; 865 } 866 input_pointer += sequence_length; 867 } 868 } 869 870 /* zero terminate the output */ 871 *output_pointer = ‘\0‘; 872 873 item->type = cJSON_String; 874 item->valuestring = (char*)output; 875 876 input_buffer->offset = (size_t) (input_end - input_buffer->content); 877 input_buffer->offset++; 878 879 return true; 880 881 fail: 882 if (output != NULL) 883 { 884 input_buffer->hooks.deallocate(output); 885 } 886 887 if (input_pointer != NULL) 888 { 889 input_buffer->offset = (size_t)(input_pointer - input_buffer->content); 890 } 891 892 return false; 893 } 894 895 /* Render the cstring provided to an escaped version that can be printed. */ 896 static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer) 897 { 898 const unsigned char *input_pointer = NULL; 899 unsigned char *output = NULL; 900 unsigned char *output_pointer = NULL; 901 size_t output_length = 0; 902 /* numbers of additional characters needed for escaping */ 903 size_t escape_characters = 0; 904 905 if (output_buffer == NULL) 906 { 907 return false; 908 } 909 910 /* empty string */ 911 if (input == NULL) 912 { 913 output = ensure(output_buffer, sizeof("\"\"")); 914 if (output == NULL) 915 { 916 return false; 917 } 918 strcpy((char*)output, "\"\""); 919 920 return true; 921 } 922 923 /* set "flag" to 1 if something needs to be escaped */ 924 for (input_pointer = input; *input_pointer; input_pointer++) 925 { 926 switch (*input_pointer) 927 { 928 case ‘\"‘: 929 case ‘\\‘: 930 case ‘\b‘: 931 case ‘\f‘: 932 case ‘\n‘: 933 case ‘\r‘: 934 case ‘\t‘: 935 /* one character escape sequence */ 936 escape_characters++; 937 break; 938 default: 939 if (*input_pointer < 32) 940 { 941 /* UTF-16 escape sequence uXXXX */ 942 escape_characters += 5; 943 } 944 break; 945 } 946 } 947 output_length = (size_t)(input_pointer - input) + escape_characters; 948 949 output = ensure(output_buffer, output_length + sizeof("\"\"")); 950 if (output == NULL) 951 { 952 return false; 953 } 954 955 /* no characters have to be escaped */ 956 if (escape_characters == 0) 957 { 958 output[0] = ‘\"‘; 959 memcpy(output + 1, input, output_length); 960 output[output_length + 1] = ‘\"‘; 961 output[output_length + 2] = ‘\0‘; 962 963 return true; 964 } 965 966 output[0] = ‘\"‘; 967 output_pointer = output + 1; 968 /* copy the string */ 969 for (input_pointer = input; *input_pointer != ‘\0‘; (void)input_pointer++, output_pointer++) 970 { 971 if ((*input_pointer > 31) && (*input_pointer != ‘\"‘) && (*input_pointer != ‘\\‘)) 972 { 973 /* normal character, copy */ 974 *output_pointer = *input_pointer; 975 } 976 else 977 { 978 /* character needs to be escaped */ 979 *output_pointer++ = ‘\\‘; 980 switch (*input_pointer) 981 { 982 case ‘\\‘: 983 *output_pointer = ‘\\‘; 984 break; 985 case ‘\"‘: 986 *output_pointer = ‘\"‘; 987 break; 988 case ‘\b‘: 989 *output_pointer = ‘b‘; 990 break; 991 case ‘\f‘: 992 *output_pointer = ‘f‘; 993 break; 994 case ‘\n‘: 995 *output_pointer = ‘n‘; 996 break; 997 case ‘\r‘: 998 *output_pointer = ‘r‘; 999 break; 1000 case ‘\t‘: 1001 *output_pointer = ‘t‘; 1002 break; 1003 default: 1004 /* escape and print as unicode codepoint */ 1005 sprintf((char*)output_pointer, "u%04x", *input_pointer); 1006 output_pointer += 4; 1007 break; 1008 } 1009 } 1010 } 1011 output[output_length + 1] = ‘\"‘; 1012 output[output_length + 2] = ‘\0‘; 1013 1014 return true; 1015 } 1016 1017 /* Invoke print_string_ptr (which is useful) on an item. */ 1018 static cJSON_bool print_string(const cJSON * const item, printbuffer * const p) 1019 { 1020 return print_string_ptr((unsigned char*)item->valuestring, p); 1021 } 1022 1023 /* Predeclare these prototypes. */ 1024 static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer); 1025 static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer); 1026 static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer); 1027 static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer); 1028 static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer); 1029 static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer); 1030 1031 /* Utility to jump whitespace and cr/lf */ 1032 static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer) 1033 { 1034 if ((buffer == NULL) || (buffer->content == NULL)) 1035 { 1036 return NULL; 1037 } 1038 1039 if (cannot_access_at_index(buffer, 0)) 1040 { 1041 return buffer; 1042 } 1043 1044 while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) 1045 { 1046 buffer->offset++; 1047 } 1048 1049 if (buffer->offset == buffer->length) 1050 { 1051 buffer->offset--; 1052 } 1053 1054 return buffer; 1055 } 1056 1057 /* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */ 1058 static parse_buffer *skip_utf8_bom(parse_buffer * const buffer) 1059 { 1060 if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) 1061 { 1062 return NULL; 1063 } 1064 1065 if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) 1066 { 1067 buffer->offset += 3; 1068 } 1069 1070 return buffer; 1071 } 1072 1073 CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated) 1074 { 1075 size_t buffer_length; 1076 1077 if (NULL == value) 1078 { 1079 return NULL; 1080 } 1081 1082 /* Adding null character size due to require_null_terminated. */ 1083 buffer_length = strlen(value) + sizeof(""); 1084 1085 return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated); 1086 } 1087 1088 /* Parse an object - create a new root, and populate. */ 1089 CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated) 1090 { 1091 parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } }; 1092 cJSON *item = NULL; 1093 1094 /* reset error position */ 1095 global_error.json = NULL; 1096 global_error.position = 0; 1097 1098 if (value == NULL || 0 == buffer_length) 1099 { 1100 goto fail; 1101 } 1102 1103 buffer.content = (const unsigned char*)value; 1104 buffer.length = buffer_length; 1105 buffer.offset = 0; 1106 buffer.hooks = global_hooks; 1107 1108 item = cJSON_New_Item(&global_hooks); 1109 if (item == NULL) /* memory fail */ 1110 { 1111 goto fail; 1112 } 1113 1114 if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) 1115 { 1116 /* parse failure. ep is set. */ 1117 goto fail; 1118 } 1119 1120 /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ 1121 if (require_null_terminated) 1122 { 1123 buffer_skip_whitespace(&buffer); 1124 if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != ‘\0‘) 1125 { 1126 goto fail; 1127 } 1128 } 1129 if (return_parse_end) 1130 { 1131 *return_parse_end = (const char*)buffer_at_offset(&buffer); 1132 } 1133 1134 return item; 1135 1136 fail: 1137 if (item != NULL) 1138 { 1139 cJSON_Delete(item); 1140 } 1141 1142 if (value != NULL) 1143 { 1144 error local_error; 1145 local_error.json = (const unsigned char*)value; 1146 local_error.position = 0; 1147 1148 if (buffer.offset < buffer.length) 1149 { 1150 local_error.position = buffer.offset; 1151 } 1152 else if (buffer.length > 0) 1153 { 1154 local_error.position = buffer.length - 1; 1155 } 1156 1157 if (return_parse_end != NULL) 1158 { 1159 *return_parse_end = (const char*)local_error.json + local_error.position; 1160 } 1161 1162 global_error = local_error; 1163 } 1164 1165 return NULL; 1166 } 1167 1168 /* Default options for cJSON_Parse */ 1169 CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value) 1170 { 1171 return cJSON_ParseWithOpts(value, 0, 0); 1172 } 1173 1174 CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length) 1175 { 1176 return cJSON_ParseWithLengthOpts(value, buffer_length, 0, 0); 1177 } 1178 1179 #define cjson_min(a, b) (((a) < (b)) ? (a) : (b)) 1180 1181 static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks) 1182 { 1183 static const size_t default_buffer_size = 256; 1184 printbuffer buffer[1]; 1185 unsigned char *printed = NULL; 1186 1187 memset(buffer, 0, sizeof(buffer)); 1188 1189 /* create buffer */ 1190 buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size); 1191 buffer->length = default_buffer_size; 1192 buffer->format = format; 1193 buffer->hooks = *hooks; 1194 if (buffer->buffer == NULL) 1195 { 1196 goto fail; 1197 } 1198 1199 /* print the value */ 1200 if (!print_value(item, buffer)) 1201 { 1202 goto fail; 1203 } 1204 update_offset(buffer); 1205 1206 /* check if reallocate is available */ 1207 if (hooks->reallocate != NULL) 1208 { 1209 printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1); 1210 if (printed == NULL) { 1211 goto fail; 1212 } 1213 buffer->buffer = NULL; 1214 } 1215 else /* otherwise copy the JSON over to a new buffer */ 1216 { 1217 printed = (unsigned char*) hooks->allocate(buffer->offset + 1); 1218 if (printed == NULL) 1219 { 1220 goto fail; 1221 } 1222 memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1)); 1223 printed[buffer->offset] = ‘\0‘; /* just to be sure */ 1224 1225 /* free the buffer */ 1226 hooks->deallocate(buffer->buffer); 1227 } 1228 1229 return printed; 1230 1231 fail: 1232 if (buffer->buffer != NULL) 1233 { 1234 hooks->deallocate(buffer->buffer); 1235 } 1236 1237 if (printed != NULL) 1238 { 1239 hooks->deallocate(printed); 1240 } 1241 1242 return NULL; 1243 } 1244 1245 /* Render a cJSON item/entity/structure to text. */ 1246 CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item) 1247 { 1248 return (char*)print(item, true, &global_hooks); 1249 } 1250 1251 CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item) 1252 { 1253 return (char*)print(item, false, &global_hooks); 1254 } 1255 1256 CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt) 1257 { 1258 printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; 1259 1260 if (prebuffer < 0) 1261 { 1262 return NULL; 1263 } 1264 1265 p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer); 1266 if (!p.buffer) 1267 { 1268 return NULL; 1269 } 1270 1271 p.length = (size_t)prebuffer; 1272 p.offset = 0; 1273 p.noalloc = false; 1274 p.format = fmt; 1275 p.hooks = global_hooks; 1276 1277 if (!print_value(item, &p)) 1278 { 1279 global_hooks.deallocate(p.buffer); 1280 return NULL; 1281 } 1282 1283 return (char*)p.buffer; 1284 } 1285 1286 CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format) 1287 { 1288 printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; 1289 1290 if ((length < 0) || (buffer == NULL)) 1291 { 1292 return false; 1293 } 1294 1295 p.buffer = (unsigned char*)buffer; 1296 p.length = (size_t)length; 1297 p.offset = 0; 1298 p.noalloc = true; 1299 p.format = format; 1300 p.hooks = global_hooks; 1301 1302 return print_value(item, &p); 1303 } 1304 1305 /* Parser core - when encountering text, process appropriately. */ 1306 static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer) 1307 { 1308 if ((input_buffer == NULL) || (input_buffer->content == NULL)) 1309 { 1310 return false; /* no input */ 1311 } 1312 1313 /* parse the different types of values */ 1314 /* null */ 1315 if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) 1316 { 1317 item->type = cJSON_NULL; 1318 input_buffer->offset += 4; 1319 return true; 1320 } 1321 /* false */ 1322 if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) 1323 { 1324 item->type = cJSON_False; 1325 input_buffer->offset += 5; 1326 return true; 1327 } 1328 /* true */ 1329 if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) 1330 { 1331 item->type = cJSON_True; 1332 item->valueint = 1; 1333 input_buffer->offset += 4; 1334 return true; 1335 } 1336 /* string */ 1337 if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ‘\"‘)) 1338 { 1339 return parse_string(item, input_buffer); 1340 } 1341 /* number */ 1342 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‘)))) 1343 { 1344 return parse_number(item, input_buffer); 1345 } 1346 /* array */ 1347 if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ‘[‘)) 1348 { 1349 return parse_array(item, input_buffer); 1350 } 1351 /* object */ 1352 if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ‘{‘)) 1353 { 1354 return parse_object(item, input_buffer); 1355 } 1356 1357 return false; 1358 } 1359 1360 /* Render a value to text. */ 1361 static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer) 1362 { 1363 unsigned char *output = NULL; 1364 1365 if ((item == NULL) || (output_buffer == NULL)) 1366 { 1367 return false; 1368 } 1369 1370 switch ((item->type) & 0xFF) 1371 { 1372 case cJSON_NULL: 1373 output = ensure(output_buffer, 5); 1374 if (output == NULL) 1375 { 1376 return false; 1377 } 1378 strcpy((char*)output, "null"); 1379 return true; 1380 1381 case cJSON_False: 1382 output = ensure(output_buffer, 6); 1383 if (output == NULL) 1384 { 1385 return false; 1386 } 1387 strcpy((char*)output, "false"); 1388 return true; 1389 1390 case cJSON_True: 1391 output = ensure(output_buffer, 5); 1392 if (output == NULL) 1393 { 1394 return false; 1395 } 1396 strcpy((char*)output, "true"); 1397 return true; 1398 1399 case cJSON_Number: 1400 return print_number(item, output_buffer); 1401 1402 case cJSON_Raw: 1403 { 1404 size_t raw_length = 0; 1405 if (item->valuestring == NULL) 1406 { 1407 return false; 1408 } 1409 1410 raw_length = strlen(item->valuestring) + sizeof(""); 1411 output = ensure(output_buffer, raw_length); 1412 if (output == NULL) 1413 { 1414 return false; 1415 } 1416 memcpy(output, item->valuestring, raw_length); 1417 return true; 1418 } 1419 1420 case cJSON_String: 1421 return print_string(item, output_buffer); 1422 1423 case cJSON_Array: 1424 return print_array(item, output_buffer); 1425 1426 case cJSON_Object: 1427 return print_object(item, output_buffer); 1428 1429 default: 1430 return false; 1431 } 1432 } 1433 1434 /* Build an array from input text. */ 1435 static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer) 1436 { 1437 cJSON *head = NULL; /* head of the linked list */ 1438 cJSON *current_item = NULL; 1439 1440 if (input_buffer->depth >= CJSON_NESTING_LIMIT) 1441 { 1442 return false; /* to deeply nested */ 1443 } 1444 input_buffer->depth++; 1445 1446 if (buffer_at_offset(input_buffer)[0] != ‘[‘) 1447 { 1448 /* not an array */ 1449 goto fail; 1450 } 1451 1452 input_buffer->offset++; 1453 buffer_skip_whitespace(input_buffer); 1454 if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ‘]‘)) 1455 { 1456 /* empty array */ 1457 goto success; 1458 } 1459 1460 /* check if we skipped to the end of the buffer */ 1461 if (cannot_access_at_index(input_buffer, 0)) 1462 { 1463 input_buffer->offset--; 1464 goto fail; 1465 } 1466 1467 /* step back to character in front of the first element */ 1468 input_buffer->offset--; 1469 /* loop through the comma separated array elements */ 1470 do 1471 { 1472 /* allocate next item */ 1473 cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); 1474 if (new_item == NULL) 1475 { 1476 goto fail; /* allocation failure */ 1477 } 1478 1479 /* attach next item to list */ 1480 if (head == NULL) 1481 { 1482 /* start the linked list */ 1483 current_item = head = new_item; 1484 } 1485 else 1486 { 1487 /* add to the end and advance */ 1488 current_item->next = new_item; 1489 new_item->prev = current_item; 1490 current_item = new_item; 1491 } 1492 1493 /* parse next value */ 1494 input_buffer->offset++; 1495 buffer_skip_whitespace(input_buffer); 1496 if (!parse_value(current_item, input_buffer)) 1497 { 1498 goto fail; /* failed to parse value */ 1499 } 1500 buffer_skip_whitespace(input_buffer); 1501 } 1502 while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ‘,‘)); 1503 1504 if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ‘]‘) 1505 { 1506 goto fail; /* expected end of array */ 1507 } 1508 1509 success: 1510 input_buffer->depth--; 1511 1512 item->type = cJSON_Array; 1513 item->child = head; 1514 1515 input_buffer->offset++; 1516 1517 return true; 1518 1519 fail: 1520 if (head != NULL) 1521 { 1522 cJSON_Delete(head); 1523 } 1524 1525 return false; 1526 } 1527 1528 /* Render an array to text */ 1529 static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer) 1530 { 1531 unsigned char *output_pointer = NULL; 1532 size_t length = 0; 1533 cJSON *current_element = item->child; 1534 1535 if (output_buffer == NULL) 1536 { 1537 return false; 1538 } 1539 1540 /* Compose the output array. */ 1541 /* opening square bracket */ 1542 output_pointer = ensure(output_buffer, 1); 1543 if (output_pointer == NULL) 1544 { 1545 return false; 1546 } 1547 1548 *output_pointer = ‘[‘; 1549 output_buffer->offset++; 1550 output_buffer->depth++; 1551 1552 while (current_element != NULL) 1553 { 1554 if (!print_value(current_element, output_buffer)) 1555 { 1556 return false; 1557 } 1558 update_offset(output_buffer); 1559 if (current_element->next) 1560 { 1561 length = (size_t) (output_buffer->format ? 2 : 1); 1562 output_pointer = ensure(output_buffer, length + 1); 1563 if (output_pointer == NULL) 1564 { 1565 return false; 1566 } 1567 *output_pointer++ = ‘,‘; 1568 if(output_buffer->format) 1569 { 1570 *output_pointer++ = ‘ ‘; 1571 } 1572 *output_pointer = ‘\0‘; 1573 output_buffer->offset += length; 1574 } 1575 current_element = current_element->next; 1576 } 1577 1578 output_pointer = ensure(output_buffer, 2); 1579 if (output_pointer == NULL) 1580 { 1581 return false; 1582 } 1583 *output_pointer++ = ‘]‘; 1584 *output_pointer = ‘\0‘; 1585 output_buffer->depth--; 1586 1587 return true; 1588 } 1589 1590 /* Build an object from the text. */ 1591 static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer) 1592 { 1593 cJSON *head = NULL; /* linked list head */ 1594 cJSON *current_item = NULL; 1595 1596 if (input_buffer->depth >= CJSON_NESTING_LIMIT) 1597 { 1598 return false; /* to deeply nested */ 1599 } 1600 input_buffer->depth++; 1601 1602 if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ‘{‘)) 1603 { 1604 goto fail; /* not an object */ 1605 } 1606 1607 input_buffer->offset++; 1608 buffer_skip_whitespace(input_buffer); 1609 if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ‘}‘)) 1610 { 1611 goto success; /* empty object */ 1612 } 1613 1614 /* check if we skipped to the end of the buffer */ 1615 if (cannot_access_at_index(input_buffer, 0)) 1616 { 1617 input_buffer->offset--; 1618 goto fail; 1619 } 1620 1621 /* step back to character in front of the first element */ 1622 input_buffer->offset--; 1623 /* loop through the comma separated array elements */ 1624 do 1625 { 1626 /* allocate next item */ 1627 cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); 1628 if (new_item == NULL) 1629 { 1630 goto fail; /* allocation failure */ 1631 } 1632 1633 /* attach next item to list */ 1634 if (head == NULL) 1635 { 1636 /* start the linked list */ 1637 current_item = head = new_item; 1638 } 1639 else 1640 { 1641 /* add to the end and advance */ 1642 current_item->next = new_item; 1643 new_item->prev = current_item; 1644 current_item = new_item; 1645 } 1646 1647 /* parse the name of the child */ 1648 input_buffer->offset++; 1649 buffer_skip_whitespace(input_buffer); 1650 if (!parse_string(current_item, input_buffer)) 1651 { 1652 goto fail; /* failed to parse name */ 1653 } 1654 buffer_skip_whitespace(input_buffer); 1655 1656 /* swap valuestring and string, because we parsed the name */ 1657 current_item->string = current_item->valuestring; 1658 current_item->valuestring = NULL; 1659 1660 if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ‘:‘)) 1661 { 1662 goto fail; /* invalid object */ 1663 } 1664 1665 /* parse the value */ 1666 input_buffer->offset++; 1667 buffer_skip_whitespace(input_buffer); 1668 if (!parse_value(current_item, input_buffer)) 1669 { 1670 goto fail; /* failed to parse value */ 1671 } 1672 buffer_skip_whitespace(input_buffer); 1673 } 1674 while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ‘,‘)); 1675 1676 if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ‘}‘)) 1677 { 1678 goto fail; /* expected end of object */ 1679 } 1680 1681 success: 1682 input_buffer->depth--; 1683 1684 item->type = cJSON_Object; 1685 item->child = head; 1686 1687 input_buffer->offset++; 1688 return true; 1689 1690 fail: 1691 if (head != NULL) 1692 { 1693 cJSON_Delete(head); 1694 } 1695 1696 return false; 1697 } 1698 1699 /* Render an object to text. */ 1700 static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer) 1701 { 1702 unsigned char *output_pointer = NULL; 1703 size_t length = 0; 1704 cJSON *current_item = item->child; 1705 1706 if (output_buffer == NULL) 1707 { 1708 return false; 1709 } 1710 1711 /* Compose the output: */ 1712 length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */ 1713 output_pointer = ensure(output_buffer, length + 1); 1714 if (output_pointer == NULL) 1715 { 1716 return false; 1717 } 1718 1719 *output_pointer++ = ‘{‘; 1720 output_buffer->depth++; 1721 if (output_buffer->format) 1722 { 1723 *output_pointer++ = ‘\n‘; 1724 } 1725 output_buffer->offset += length; 1726 1727 while (current_item) 1728 { 1729 if (output_buffer->format) 1730 { 1731 size_t i; 1732 output_pointer = ensure(output_buffer, output_buffer->depth); 1733 if (output_pointer == NULL) 1734 { 1735 return false; 1736 } 1737 for (i = 0; i < output_buffer->depth; i++) 1738 { 1739 *output_pointer++ = ‘\t‘; 1740 } 1741 output_buffer->offset += output_buffer->depth; 1742 } 1743 1744 /* print key */ 1745 if (!print_string_ptr((unsigned char*)current_item->string, output_buffer)) 1746 { 1747 return false; 1748 } 1749 update_offset(output_buffer); 1750 1751 length = (size_t) (output_buffer->format ? 2 : 1); 1752 output_pointer = ensure(output_buffer, length); 1753 if (output_pointer == NULL) 1754 { 1755 return false; 1756 } 1757 *output_pointer++ = ‘:‘; 1758 if (output_buffer->format) 1759 { 1760 *output_pointer++ = ‘\t‘; 1761 } 1762 output_buffer->offset += length; 1763 1764 /* print value */ 1765 if (!print_value(current_item, output_buffer)) 1766 { 1767 return false; 1768 } 1769 update_offset(output_buffer); 1770 1771 /* print comma if not last */ 1772 length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0)); 1773 output_pointer = ensure(output_buffer, length + 1); 1774 if (output_pointer == NULL) 1775 { 1776 return false; 1777 } 1778 if (current_item->next) 1779 { 1780 *output_pointer++ = ‘,‘; 1781 } 1782 1783 if (output_buffer->format) 1784 { 1785 *output_pointer++ = ‘\n‘; 1786 } 1787 *output_pointer = ‘\0‘; 1788 output_buffer->offset += length; 1789 1790 current_item = current_item->next; 1791 } 1792 1793 output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2); 1794 if (output_pointer == NULL) 1795 { 1796 return false; 1797 } 1798 if (output_buffer->format) 1799 { 1800 size_t i; 1801 for (i = 0; i < (output_buffer->depth - 1); i++) 1802 { 1803 *output_pointer++ = ‘\t‘; 1804 } 1805 } 1806 *output_pointer++ = ‘}‘; 1807 *output_pointer = ‘\0‘; 1808 output_buffer->depth--; 1809 1810 return true; 1811 } 1812 1813 /* Get Array size/item / object item. */ 1814 CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array) 1815 { 1816 cJSON *child = NULL; 1817 size_t size = 0; 1818 1819 if (array == NULL) 1820 { 1821 return 0; 1822 } 1823 1824 child = array->child; 1825 1826 while(child != NULL) 1827 { 1828 size++; 1829 child = child->next; 1830 } 1831 1832 /* FIXME: Can overflow here. Cannot be fixed without breaking the API */ 1833 1834 return (int)size; 1835 } 1836 1837 static cJSON* get_array_item(const cJSON *array, size_t index) 1838 { 1839 cJSON *current_child = NULL; 1840 1841 if (array == NULL) 1842 { 1843 return NULL; 1844 } 1845 1846 current_child = array->child; 1847 while ((current_child != NULL) && (index > 0)) 1848 { 1849 index--; 1850 current_child = current_child->next; 1851 } 1852 1853 return current_child; 1854 } 1855 1856 CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index) 1857 { 1858 if (index < 0) 1859 { 1860 return NULL; 1861 } 1862 1863 return get_array_item(array, (size_t)index); 1864 } 1865 1866 static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive) 1867 { 1868 cJSON *current_element = NULL; 1869 1870 if ((object == NULL) || (name == NULL)) 1871 { 1872 return NULL; 1873 } 1874 1875 current_element = object->child; 1876 if (case_sensitive) 1877 { 1878 while ((current_element != NULL) && (current_element->string != NULL) && (strcmp(name, current_element->string) != 0)) 1879 { 1880 current_element = current_element->next; 1881 } 1882 } 1883 else 1884 { 1885 while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0)) 1886 { 1887 current_element = current_element->next; 1888 } 1889 } 1890 1891 if ((current_element == NULL) || (current_element->string == NULL)) { 1892 return NULL; 1893 } 1894 1895 return current_element; 1896 } 1897 1898 CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string) 1899 { 1900 return get_object_item(object, string, false); 1901 } 1902 1903 CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string) 1904 { 1905 return get_object_item(object, string, true); 1906 } 1907 1908 CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string) 1909 { 1910 return cJSON_GetObjectItem(object, string) ? 1 : 0; 1911 } 1912 1913 /* Utility for array list handling. */ 1914 static void suffix_object(cJSON *prev, cJSON *item) 1915 { 1916 prev->next = item; 1917 item->prev = prev; 1918 } 1919 1920 /* Utility for handling references. */ 1921 static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks) 1922 { 1923 cJSON *reference = NULL; 1924 if (item == NULL) 1925 { 1926 return NULL; 1927 } 1928 1929 reference = cJSON_New_Item(hooks); 1930 if (reference == NULL) 1931 { 1932 return NULL; 1933 } 1934 1935 memcpy(reference, item, sizeof(cJSON)); 1936 reference->string = NULL; 1937 reference->type |= cJSON_IsReference; 1938 reference->next = reference->prev = NULL; 1939 return reference; 1940 } 1941 1942 static cJSON_bool add_item_to_array(cJSON *array, cJSON *item) 1943 { 1944 cJSON *child = NULL; 1945 1946 if ((item == NULL) || (array == NULL) || (array == item)) 1947 { 1948 return false; 1949 } 1950 1951 child = array->child; 1952 /* 1953 * To find the last item in array quickly, we use prev in array 1954 */ 1955 if (child == NULL) 1956 { 1957 /* list is empty, start new one */ 1958 array->child = item; 1959 item->prev = item; 1960 item->next = NULL; 1961 } 1962 else 1963 { 1964 /* append to the end */ 1965 if (child->prev) 1966 { 1967 suffix_object(child->prev, item); 1968 array->child->prev = item; 1969 } 1970 else 1971 { 1972 while (child->next) 1973 { 1974 child = child->next; 1975 } 1976 suffix_object(child, item); 1977 array->child->prev = item; 1978 } 1979 } 1980 1981 return true; 1982 } 1983 1984 /* Add item to array/object. */ 1985 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item) 1986 { 1987 return add_item_to_array(array, item); 1988 } 1989 1990 #if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) 1991 #pragma GCC diagnostic push 1992 #endif 1993 #ifdef __GNUC__ 1994 #pragma GCC diagnostic ignored "-Wcast-qual" 1995 #endif 1996 /* helper function to cast away const */ 1997 static void* cast_away_const(const void* string) 1998 { 1999 return (void*)string; 2000 } 2001 #if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) 2002 #pragma GCC diagnostic pop 2003 #endif 2004 2005 2006 static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key) 2007 { 2008 char *new_key = NULL; 2009 int new_type = cJSON_Invalid; 2010 2011 if ((object == NULL) || (string == NULL) || (item == NULL) || (object == item)) 2012 { 2013 return false; 2014 } 2015 2016 if (constant_key) 2017 { 2018 new_key = (char*)cast_away_const(string); 2019 new_type = item->type | cJSON_StringIsConst; 2020 } 2021 else 2022 { 2023 new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks); 2024 if (new_key == NULL) 2025 { 2026 return false; 2027 } 2028 2029 new_type = item->type & ~cJSON_StringIsConst; 2030 } 2031 2032 if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) 2033 { 2034 hooks->deallocate(item->string); 2035 } 2036 2037 item->string = new_key; 2038 item->type = new_type; 2039 2040 return add_item_to_array(object, item); 2041 } 2042 2043 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item) 2044 { 2045 return add_item_to_object(object, string, item, &global_hooks, false); 2046 } 2047 2048 /* Add an item to an object with constant string as key */ 2049 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item) 2050 { 2051 return add_item_to_object(object, string, item, &global_hooks, true); 2052 } 2053 2054 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) 2055 { 2056 if (array == NULL) 2057 { 2058 return false; 2059 } 2060 2061 return add_item_to_array(array, create_reference(item, &global_hooks)); 2062 } 2063 2064 CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) 2065 { 2066 if ((object == NULL) || (string == NULL)) 2067 { 2068 return false; 2069 } 2070 2071 return add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false); 2072 } 2073 2074 CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name) 2075 { 2076 cJSON *null = cJSON_CreateNull(); 2077 if (add_item_to_object(object, name, null, &global_hooks, false)) 2078 { 2079 return null; 2080 } 2081 2082 cJSON_Delete(null); 2083 return NULL; 2084 } 2085 2086 CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name) 2087 { 2088 cJSON *true_item = cJSON_CreateTrue(); 2089 if (add_item_to_object(object, name, true_item, &global_hooks, false)) 2090 { 2091 return true_item; 2092 } 2093 2094 cJSON_Delete(true_item); 2095 return NULL; 2096 } 2097 2098 CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name) 2099 { 2100 cJSON *false_item = cJSON_CreateFalse(); 2101 if (add_item_to_object(object, name, false_item, &global_hooks, false)) 2102 { 2103 return false_item; 2104 } 2105 2106 cJSON_Delete(false_item); 2107 return NULL; 2108 } 2109 2110 CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean) 2111 { 2112 cJSON *bool_item = cJSON_CreateBool(boolean); 2113 if (add_item_to_object(object, name, bool_item, &global_hooks, false)) 2114 { 2115 return bool_item; 2116 } 2117 2118 cJSON_Delete(bool_item); 2119 return NULL; 2120 } 2121 2122 CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number) 2123 { 2124 cJSON *number_item = cJSON_CreateNumber(number); 2125 if (add_item_to_object(object, name, number_item, &global_hooks, false)) 2126 { 2127 return number_item; 2128 } 2129 2130 cJSON_Delete(number_item); 2131 return NULL; 2132 } 2133 2134 CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string) 2135 { 2136 cJSON *string_item = cJSON_CreateString(string); 2137 if (add_item_to_object(object, name, string_item, &global_hooks, false)) 2138 { 2139 return string_item; 2140 } 2141 2142 cJSON_Delete(string_item); 2143 return NULL; 2144 } 2145 2146 CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw) 2147 { 2148 cJSON *raw_item = cJSON_CreateRaw(raw); 2149 if (add_item_to_object(object, name, raw_item, &global_hooks, false)) 2150 { 2151 return raw_item; 2152 } 2153 2154 cJSON_Delete(raw_item); 2155 return NULL; 2156 } 2157 2158 CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name) 2159 { 2160 cJSON *object_item = cJSON_CreateObject(); 2161 if (add_item_to_object(object, name, object_item, &global_hooks, false)) 2162 { 2163 return object_item; 2164 } 2165 2166 cJSON_Delete(object_item); 2167 return NULL; 2168 } 2169 2170 CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name) 2171 { 2172 cJSON *array = cJSON_CreateArray(); 2173 if (add_item_to_object(object, name, array, &global_hooks, false)) 2174 { 2175 return array; 2176 } 2177 2178 cJSON_Delete(array); 2179 return NULL; 2180 } 2181 2182 CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item) 2183 { 2184 if ((parent == NULL) || (item == NULL)) 2185 { 2186 return NULL; 2187 } 2188 2189 if (item != parent->child) 2190 { 2191 /* not the first element */ 2192 item->prev->next = item->next; 2193 } 2194 if (item->next != NULL) 2195 { 2196 /* not the last element */ 2197 item->next->prev = item->prev; 2198 } 2199 2200 if (item == parent->child) 2201 { 2202 /* first element */ 2203 parent->child = item->next; 2204 } 2205 /* make sure the detached item doesn‘t point anywhere anymore */ 2206 item->prev = NULL; 2207 item->next = NULL; 2208 2209 return item; 2210 } 2211 2212 CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which) 2213 { 2214 if (which < 0) 2215 { 2216 return NULL; 2217 } 2218 2219 return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which)); 2220 } 2221 2222 CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which) 2223 { 2224 cJSON_Delete(cJSON_DetachItemFromArray(array, which)); 2225 } 2226 2227 CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string) 2228 { 2229 cJSON *to_detach = cJSON_GetObjectItem(object, string); 2230 2231 return cJSON_DetachItemViaPointer(object, to_detach); 2232 } 2233 2234 CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string) 2235 { 2236 cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string); 2237 2238 return cJSON_DetachItemViaPointer(object, to_detach); 2239 } 2240 2241 CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string) 2242 { 2243 cJSON_Delete(cJSON_DetachItemFromObject(object, string)); 2244 } 2245 2246 CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string) 2247 { 2248 cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string)); 2249 } 2250 2251 /* Replace array/object items with new ones. */ 2252 CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem) 2253 { 2254 cJSON *after_inserted = NULL; 2255 2256 if (which < 0) 2257 { 2258 return false; 2259 } 2260 2261 after_inserted = get_array_item(array, (size_t)which); 2262 if (after_inserted == NULL) 2263 { 2264 return add_item_to_array(array, newitem); 2265 } 2266 2267 newitem->next = after_inserted; 2268 newitem->prev = after_inserted->prev; 2269 after_inserted->prev = newitem; 2270 if (after_inserted == array->child) 2271 { 2272 array->child = newitem; 2273 } 2274 else 2275 { 2276 newitem->prev->next = newitem; 2277 } 2278 return true; 2279 } 2280 2281 CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement) 2282 { 2283 if ((parent == NULL) || (replacement == NULL) || (item == NULL)) 2284 { 2285 return false; 2286 } 2287 2288 if (replacement == item) 2289 { 2290 return true; 2291 } 2292 2293 replacement->next = item->next; 2294 replacement->prev = item->prev; 2295 2296 if (replacement->next != NULL) 2297 { 2298 replacement->next->prev = replacement; 2299 } 2300 if (parent->child == item) 2301 { 2302 parent->child = replacement; 2303 } 2304 else 2305 { /* 2306 * To find the last item in array quickly, we use prev in array. 2307 * We can‘t modify the last item‘s next pointer where this item was the parent‘s child 2308 */ 2309 if (replacement->prev != NULL) 2310 { 2311 replacement->prev->next = replacement; 2312 } 2313 } 2314 2315 item->next = NULL; 2316 item->prev = NULL; 2317 cJSON_Delete(item); 2318 2319 return true; 2320 } 2321 2322 CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem) 2323 { 2324 if (which < 0) 2325 { 2326 return false; 2327 } 2328 2329 return cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem); 2330 } 2331 2332 static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive) 2333 { 2334 if ((replacement == NULL) || (string == NULL)) 2335 { 2336 return false; 2337 } 2338 2339 /* replace the name in the replacement */ 2340 if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL)) 2341 { 2342 cJSON_free(replacement->string); 2343 } 2344 replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); 2345 replacement->type &= ~cJSON_StringIsConst; 2346 2347 return cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement); 2348 } 2349 2350 CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem) 2351 { 2352 return replace_item_in_object(object, string, newitem, false); 2353 } 2354 2355 CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem) 2356 { 2357 return replace_item_in_object(object, string, newitem, true); 2358 } 2359 2360 /* Create basic types: */ 2361 CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void) 2362 { 2363 cJSON *item = cJSON_New_Item(&global_hooks); 2364 if(item) 2365 { 2366 item->type = cJSON_NULL; 2367 } 2368 2369 return item; 2370 } 2371 2372 CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void) 2373 { 2374 cJSON *item = cJSON_New_Item(&global_hooks); 2375 if(item) 2376 { 2377 item->type = cJSON_True; 2378 } 2379 2380 return item; 2381 } 2382 2383 CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void) 2384 { 2385 cJSON *item = cJSON_New_Item(&global_hooks); 2386 if(item) 2387 { 2388 item->type = cJSON_False; 2389 } 2390 2391 return item; 2392 } 2393 2394 CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean) 2395 { 2396 cJSON *item = cJSON_New_Item(&global_hooks); 2397 if(item) 2398 { 2399 item->type = boolean ? cJSON_True : cJSON_False; 2400 } 2401 2402 return item; 2403 } 2404 2405 CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num) 2406 { 2407 cJSON *item = cJSON_New_Item(&global_hooks); 2408 if(item) 2409 { 2410 item->type = cJSON_Number; 2411 item->valuedouble = num; 2412 2413 /* use saturation in case of overflow */ 2414 if (num >= INT_MAX) 2415 { 2416 item->valueint = INT_MAX; 2417 } 2418 else if (num <= (double)INT_MIN) 2419 { 2420 item->valueint = INT_MIN; 2421 } 2422 else 2423 { 2424 item->valueint = (int)num; 2425 } 2426 } 2427 2428 return item; 2429 } 2430 2431 CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string) 2432 { 2433 cJSON *item = cJSON_New_Item(&global_hooks); 2434 if(item) 2435 { 2436 item->type = cJSON_String; 2437 item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); 2438 if(!item->valuestring) 2439 { 2440 cJSON_Delete(item); 2441 return NULL; 2442 } 2443 } 2444 2445 return item; 2446 } 2447 2448 CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string) 2449 { 2450 cJSON *item = cJSON_New_Item(&global_hooks); 2451 if (item != NULL) 2452 { 2453 item->type = cJSON_String | cJSON_IsReference; 2454 item->valuestring = (char*)cast_away_const(string); 2455 } 2456 2457 return item; 2458 } 2459 2460 CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child) 2461 { 2462 cJSON *item = cJSON_New_Item(&global_hooks); 2463 if (item != NULL) { 2464 item->type = cJSON_Object | cJSON_IsReference; 2465 item->child = (cJSON*)cast_away_const(child); 2466 } 2467 2468 return item; 2469 } 2470 2471 CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) { 2472 cJSON *item = cJSON_New_Item(&global_hooks); 2473 if (item != NULL) { 2474 item->type = cJSON_Array | cJSON_IsReference; 2475 item->child = (cJSON*)cast_away_const(child); 2476 } 2477 2478 return item; 2479 } 2480 2481 CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw) 2482 { 2483 cJSON *item = cJSON_New_Item(&global_hooks); 2484 if(item) 2485 { 2486 item->type = cJSON_Raw; 2487 item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks); 2488 if(!item->valuestring) 2489 { 2490 cJSON_Delete(item); 2491 return NULL; 2492 } 2493 } 2494 2495 return item; 2496 } 2497 2498 CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void) 2499 { 2500 cJSON *item = cJSON_New_Item(&global_hooks); 2501 if(item) 2502 { 2503 item->type=cJSON_Array; 2504 } 2505 2506 return item; 2507 } 2508 2509 CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void) 2510 { 2511 cJSON *item = cJSON_New_Item(&global_hooks); 2512 if (item) 2513 { 2514 item->type = cJSON_Object; 2515 } 2516 2517 return item; 2518 } 2519 2520 /* Create Arrays: */ 2521 CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count) 2522 { 2523 size_t i = 0; 2524 cJSON *n = NULL; 2525 cJSON *p = NULL; 2526 cJSON *a = NULL; 2527 2528 if ((count < 0) || (numbers == NULL)) 2529 { 2530 return NULL; 2531 } 2532 2533 a = cJSON_CreateArray(); 2534 for(i = 0; a && (i < (size_t)count); i++) 2535 { 2536 n = cJSON_CreateNumber(numbers[i]); 2537 if (!n) 2538 { 2539 cJSON_Delete(a); 2540 return NULL; 2541 } 2542 if(!i) 2543 { 2544 a->child = n; 2545 } 2546 else 2547 { 2548 suffix_object(p, n); 2549 } 2550 p = n; 2551 } 2552 2553 return a; 2554 } 2555 2556 CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count) 2557 { 2558 size_t i = 0; 2559 cJSON *n = NULL; 2560 cJSON *p = NULL; 2561 cJSON *a = NULL; 2562 2563 if ((count < 0) || (numbers == NULL)) 2564 { 2565 return NULL; 2566 } 2567 2568 a = cJSON_CreateArray(); 2569 2570 for(i = 0; a && (i < (size_t)count); i++) 2571 { 2572 n = cJSON_CreateNumber((double)numbers[i]); 2573 if(!n) 2574 { 2575 cJSON_Delete(a); 2576 return NULL; 2577 } 2578 if(!i) 2579 { 2580 a->child = n; 2581 } 2582 else 2583 { 2584 suffix_object(p, n); 2585 } 2586 p = n; 2587 } 2588 2589 return a; 2590 } 2591 2592 CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count) 2593 { 2594 size_t i = 0; 2595 cJSON *n = NULL; 2596 cJSON *p = NULL; 2597 cJSON *a = NULL; 2598 2599 if ((count < 0) || (numbers == NULL)) 2600 { 2601 return NULL; 2602 } 2603 2604 a = cJSON_CreateArray(); 2605 2606 for(i = 0;a && (i < (size_t)count); i++) 2607 { 2608 n = cJSON_CreateNumber(numbers[i]); 2609 if(!n) 2610 { 2611 cJSON_Delete(a); 2612 return NULL; 2613 } 2614 if(!i) 2615 { 2616 a->child = n; 2617 } 2618 else 2619 { 2620 suffix_object(p, n); 2621 } 2622 p = n; 2623 } 2624 2625 return a; 2626 } 2627 2628 CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count) 2629 { 2630 size_t i = 0; 2631 cJSON *n = NULL; 2632 cJSON *p = NULL; 2633 cJSON *a = NULL; 2634 2635 if ((count < 0) || (strings == NULL)) 2636 { 2637 return NULL; 2638 } 2639 2640 a = cJSON_CreateArray(); 2641 2642 for (i = 0; a && (i < (size_t)count); i++) 2643 { 2644 n = cJSON_CreateString(strings[i]); 2645 if(!n) 2646 { 2647 cJSON_Delete(a); 2648 return NULL; 2649 } 2650 if(!i) 2651 { 2652 a->child = n; 2653 } 2654 else 2655 { 2656 suffix_object(p,n); 2657 } 2658 p = n; 2659 } 2660 2661 return a; 2662 } 2663 2664 /* Duplication */ 2665 CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse) 2666 { 2667 cJSON *newitem = NULL; 2668 cJSON *child = NULL; 2669 cJSON *next = NULL; 2670 cJSON *newchild = NULL; 2671 2672 /* Bail on bad ptr */ 2673 if (!item) 2674 { 2675 goto fail; 2676 } 2677 /* Create new item */ 2678 newitem = cJSON_New_Item(&global_hooks); 2679 if (!newitem) 2680 { 2681 goto fail; 2682 } 2683 /* Copy over all vars */ 2684 newitem->type = item->type & (~cJSON_IsReference); 2685 newitem->valueint = item->valueint; 2686 newitem->valuedouble = item->valuedouble; 2687 if (item->valuestring) 2688 { 2689 newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks); 2690 if (!newitem->valuestring) 2691 { 2692 goto fail; 2693 } 2694 } 2695 if (item->string) 2696 { 2697 newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks); 2698 if (!newitem->string) 2699 { 2700 goto fail; 2701 } 2702 } 2703 /* If non-recursive, then we‘re done! */ 2704 if (!recurse) 2705 { 2706 return newitem; 2707 } 2708 /* Walk the ->next chain for the child. */ 2709 child = item->child; 2710 while (child != NULL) 2711 { 2712 newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */ 2713 if (!newchild) 2714 { 2715 goto fail; 2716 } 2717 if (next != NULL) 2718 { 2719 /* If newitem->child already set, then crosswire ->prev and ->next and move on */ 2720 next->next = newchild; 2721 newchild->prev = next; 2722 next = newchild; 2723 } 2724 else 2725 { 2726 /* Set newitem->child and move to it */ 2727 newitem->child = newchild; 2728 next = newchild; 2729 } 2730 child = child->next; 2731 } 2732 2733 return newitem; 2734 2735 fail: 2736 if (newitem != NULL) 2737 { 2738 cJSON_Delete(newitem); 2739 } 2740 2741 return NULL; 2742 } 2743 2744 static void skip_oneline_comment(char **input) 2745 { 2746 *input += static_strlen("//"); 2747 2748 for (; (*input)[0] != ‘\0‘; ++(*input)) 2749 { 2750 if ((*input)[0] == ‘\n‘) { 2751 *input += static_strlen("\n"); 2752 return; 2753 } 2754 } 2755 } 2756 2757 static void skip_multiline_comment(char **input) 2758 { 2759 *input += static_strlen("/*"); 2760 2761 for (; (*input)[0] != ‘\0‘; ++(*input)) 2762 { 2763 if (((*input)[0] == ‘*‘) && ((*input)[1] == ‘/‘)) 2764 { 2765 *input += static_strlen("*/"); 2766 return; 2767 } 2768 } 2769 } 2770 2771 static void minify_string(char **input, char **output) { 2772 (*output)[0] = (*input)[0]; 2773 *input += static_strlen("\""); 2774 *output += static_strlen("\""); 2775 2776 2777 for (; (*input)[0] != ‘\0‘; (void)++(*input), ++(*output)) { 2778 (*output)[0] = (*input)[0]; 2779 2780 if ((*input)[0] == ‘\"‘) { 2781 (*output)[0] = ‘\"‘; 2782 *input += static_strlen("\""); 2783 *output += static_strlen("\""); 2784 return; 2785 } else if (((*input)[0] == ‘\\‘) && ((*input)[1] == ‘\"‘)) { 2786 (*output)[1] = (*input)[1]; 2787 *input += static_strlen("\""); 2788 *output += static_strlen("\""); 2789 } 2790 } 2791 } 2792 2793 CJSON_PUBLIC(void) cJSON_Minify(char *json) 2794 { 2795 char *into = json; 2796 2797 if (json == NULL) 2798 { 2799 return; 2800 } 2801 2802 while (json[0] != ‘\0‘) 2803 { 2804 switch (json[0]) 2805 { 2806 case ‘ ‘: 2807 case ‘\t‘: 2808 case ‘\r‘: 2809 case ‘\n‘: 2810 json++; 2811 break; 2812 2813 case ‘/‘: 2814 if (json[1] == ‘/‘) 2815 { 2816 skip_oneline_comment(&json); 2817 } 2818 else if (json[1] == ‘*‘) 2819 { 2820 skip_multiline_comment(&json); 2821 } else { 2822 json++; 2823 } 2824 break; 2825 2826 case ‘\"‘: 2827 minify_string(&json, (char**)&into); 2828 break; 2829 2830 default: 2831 into[0] = json[0]; 2832 json++; 2833 into++; 2834 } 2835 } 2836 2837 /* and null-terminate. */ 2838 *into = ‘\0‘; 2839 } 2840 2841 CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item) 2842 { 2843 if (item == NULL) 2844 { 2845 return false; 2846 } 2847 2848 return (item->type & 0xFF) == cJSON_Invalid; 2849 } 2850 2851 CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item) 2852 { 2853 if (item == NULL) 2854 { 2855 return false; 2856 } 2857 2858 return (item->type & 0xFF) == cJSON_False; 2859 } 2860 2861 CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item) 2862 { 2863 if (item == NULL) 2864 { 2865 return false; 2866 } 2867 2868 return (item->type & 0xff) == cJSON_True; 2869 } 2870 2871 2872 CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item) 2873 { 2874 if (item == NULL) 2875 { 2876 return false; 2877 } 2878 2879 return (item->type & (cJSON_True | cJSON_False)) != 0; 2880 } 2881 CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item) 2882 { 2883 if (item == NULL) 2884 { 2885 return false; 2886 } 2887 2888 return (item->type & 0xFF) == cJSON_NULL; 2889 } 2890 2891 CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item) 2892 { 2893 if (item == NULL) 2894 { 2895 return false; 2896 } 2897 2898 return (item->type & 0xFF) == cJSON_Number; 2899 } 2900 2901 CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item) 2902 { 2903 if (item == NULL) 2904 { 2905 return false; 2906 } 2907 2908 return (item->type & 0xFF) == cJSON_String; 2909 } 2910 2911 CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item) 2912 { 2913 if (item == NULL) 2914 { 2915 return false; 2916 } 2917 2918 return (item->type & 0xFF) == cJSON_Array; 2919 } 2920 2921 CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item) 2922 { 2923 if (item == NULL) 2924 { 2925 return false; 2926 } 2927 2928 return (item->type & 0xFF) == cJSON_Object; 2929 } 2930 2931 CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item) 2932 { 2933 if (item == NULL) 2934 { 2935 return false; 2936 } 2937 2938 return (item->type & 0xFF) == cJSON_Raw; 2939 } 2940 2941 CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive) 2942 { 2943 if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF)) || cJSON_IsInvalid(a)) 2944 { 2945 return false; 2946 } 2947 2948 /* check if type is valid */ 2949 switch (a->type & 0xFF) 2950 { 2951 case cJSON_False: 2952 case cJSON_True: 2953 case cJSON_NULL: 2954 case cJSON_Number: 2955 case cJSON_String: 2956 case cJSON_Raw: 2957 case cJSON_Array: 2958 case cJSON_Object: 2959 break; 2960 2961 default: 2962 return false; 2963 } 2964 2965 /* identical objects are equal */ 2966 if (a == b) 2967 { 2968 return true; 2969 } 2970 2971 switch (a->type & 0xFF) 2972 { 2973 /* in these cases and equal type is enough */ 2974 case cJSON_False: 2975 case cJSON_True: 2976 case cJSON_NULL: 2977 return true; 2978 2979 case cJSON_Number: 2980 if (compare_double(a->valuedouble, b->valuedouble)) 2981 { 2982 return true; 2983 } 2984 return false; 2985 2986 case cJSON_String: 2987 case cJSON_Raw: 2988 if ((a->valuestring == NULL) || (b->valuestring == NULL)) 2989 { 2990 return false; 2991 } 2992 if (strcmp(a->valuestring, b->valuestring) == 0) 2993 { 2994 return true; 2995 } 2996 2997 return false; 2998 2999 case cJSON_Array: 3000 { 3001 cJSON *a_element = a->child; 3002 cJSON *b_element = b->child; 3003 3004 for (; (a_element != NULL) && (b_element != NULL);) 3005 { 3006 if (!cJSON_Compare(a_element, b_element, case_sensitive)) 3007 { 3008 return false; 3009 } 3010 3011 a_element = a_element->next; 3012 b_element = b_element->next; 3013 } 3014 3015 /* one of the arrays is longer than the other */ 3016 if (a_element != b_element) { 3017 return false; 3018 } 3019 3020 return true; 3021 } 3022 3023 case cJSON_Object: 3024 { 3025 cJSON *a_element = NULL; 3026 cJSON *b_element = NULL; 3027 cJSON_ArrayForEach(a_element, a) 3028 { 3029 /* TODO This has O(n^2) runtime, which is horrible! */ 3030 b_element = get_object_item(b, a_element->string, case_sensitive); 3031 if (b_element == NULL) 3032 { 3033 return false; 3034 } 3035 3036 if (!cJSON_Compare(a_element, b_element, case_sensitive)) 3037 { 3038 return false; 3039 } 3040 } 3041 3042 /* doing this twice, once on a and b to prevent true comparison if a subset of b 3043 * TODO: Do this the proper way, this is just a fix for now */ 3044 cJSON_ArrayForEach(b_element, b) 3045 { 3046 a_element = get_object_item(a, b_element->string, case_sensitive); 3047 if (a_element == NULL) 3048 { 3049 return false; 3050 } 3051 3052 if (!cJSON_Compare(b_element, a_element, case_sensitive)) 3053 { 3054 return false; 3055 } 3056 } 3057 3058 return true; 3059 } 3060 3061 default: 3062 return false; 3063 } 3064 } 3065 3066 CJSON_PUBLIC(void *) cJSON_malloc(size_t size) 3067 { 3068 return global_hooks.allocate(size); 3069 } 3070 3071 CJSON_PUBLIC(void) cJSON_free(void *object) 3072 { 3073 global_hooks.deallocate(object); 3074 }
参考：
https://blog.csdn.net/shizhe0123/article/details/94742514
https://blog.csdn.net/fengxinlinux/article/details/53121287