斷斷續續的CJSON源碼看了也有一段時間了,研究一番還是收穫頗多!很適合有一點C基礎的想繼續提高練手的開源源碼!cJson.c代碼只有700多行,官網上下的,代碼風格個人感覺不是很方便閱讀,如果全部展開的話代碼估計至少不在1100行之下。網上也看了一些前輩們的cjson筆記!對於像我這這樣初次接觸CJSON還是相當有幫助的!下面就來一點一點的分析源碼!這裏記錄一下自己對源碼研究理解的筆記!同時也希望對別人作爲參考也有一點點的幫助!
研究源碼之前首先還是搞清楚CJSON到底是幹啥的!這樣可以對整個源碼有個大體的把握!下面是舉一些例子可以大致瞭解一下what is cjson?
CJSON:
解釋一:
JSON(JavaScript Object Notation) 是一種輕量級的數據交換格式,主要用於傳送數據。JSON 可以將 JavaScript 對象中表示的一組數據轉換爲字符串,然後就可以在函數之間輕鬆地傳遞這個字符串,或者在異步應用程序中將字符串從 Web 客戶機傳遞給服務器端程序。這個字符串看起來有點兒古怪,但是 JavaScript 很容易解釋它,而且 JSON 可以表示比"名稱 / 值對"更復雜的結構。例如,可以表示數組和複雜的對象,而不僅僅是鍵和值的簡單列表。JSON採用完全獨立於語言的文本格式,但是也使用了類似於C語言家族的習慣(包括C,
C++, C#, Java, JavaScript, Perl,Python等)。這些特性使JSON成爲理想的數據交換語言。易於人閱讀和編寫,同時也易於機器解析和生成。
解釋二:
就是一種數據格式,不必過於糾結於此。就像一種交通工具,就像你上班要開車一樣,可能騎自行車也是一種交通工具,但是json這種交通工具更方便,更快捷。
解釋三:
對於cJSON的使用,我主要是用來模擬遠程服務器端返回的一個json類型的目錄結構,客戶端進行獲取並進行解析,把解析出來的目錄按照原本的結構顯示在本地
當然除了上面的一些解釋最權威的還是CJSON官方解釋!這個自己直接搜,百度谷歌!上面不僅有可供下載的各種編程語言版本的源碼,也有很具體的介紹!下面就來逐步深入的分析研究源碼了!(源碼我是用SI來看的)
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <float.h>
#include <limits.h>
#include <ctype.h>
#include "cJSON.h"
static const char *global_ep;
const char *cJSON_GetErrorPtr(void) {return global_ep;}
static int cJSON_strcasecmp(const char *s1,const char *s2)
{
if (!s1) return (s1==s2)?0:1;
if (!s2) return 1;
for(; (*s1) == tolower(*s2); ++s1, ++s2)
if(*s1 == 0) return 0;
return tolower(*(const unsigned char *)s1) - tolower(*(const unsigned char *)s2);
}
從頭文件下的第一行代碼開始,定義了一個全局靜態字符指針變量,該指針指向一個常量(即指向的數據爲常量).然後下面一行代碼就使用了這個指針變量,搜索global_eq可以看到這個變量在整個.c文件中只出現在三個地方:
除了上面兩個地方,還有一個就是上圖中第四個箭頭所指的地方,
先來看看:
const char *cJSON_GetErrorPtr(void) {return global_ep;},
/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error. If not, then cJSON_GetErrorPtr() does the job. */
這個函數可以看下.h文件中的英文註釋,這個函數在官方的test.c中有一次調用!
if (!json) {printf("Error before: [%s]\n",cJSON_GetErrorPtr());}
這個短短一行代碼的函數其實就是當傳入的字符串解析失敗就返回解析失敗處的地址後邊的字符串!
下面再來逐行分析下面的代碼:
函數:int tolower(int c);
函數說明:若參數 c 爲大寫字母則將該對應的小寫字母返回。
返回值:返回轉換後的小寫字母,若不須轉換則將參數c 值返回。
函數說明
cJSON_strcasecmp()用來比較參數s1和s2字符串,比較時會自動忽略大小寫的差異。</span>
返回值 若參數s1和s2字符串相同則返回0。s1長度大於s2長度則返回大於0 的值,s1 長度若小於s2 長度則返回小於0的值.(對照着下面源碼分析應該已經很清晰了)static int cJSON_strcasecmp(const char *s1,const char *s2)
{
if (!s1) return (s1==s2)?0:1; //if語句裏面的我習慣這樣寫if(s1 == NULL) 不過這裏這樣寫感覺逼格要高一點的樣子
if (!s2) return 1;
for(; (*s1) == tolower(*s2); ++s1, ++s2)
if(*s1 == 0) return 0;
return tolower(*(const unsigned char *)s1) - tolower(*(const unsigned char *)s2);
}
首先對傳入的參數做合法性檢測,這個API的功能就是比較參數S1和S2字符串,當初看到這個for循環下面的一行代碼時比較不理解爲什麼用if(*s1 == 0)作爲這個for循環的一個出口!字符串結束符不是'\0'嗎?難道tolower函數在遇到結束符'\0'後返回的是0?搞明白了之後發現這裏原來是不按套路出牌!
而在ASCII碼錶中,NULL 就是0!
順便查了下C庫中的strcasecmp函數是這麼實現的:
int strcasecmp(const char *s1, const char *s2)
{
int c1, c2;
do {
c1 = tolower(*s1++);
c2 = tolower(*s2++);
} while(c1 == c2 && c1 != 0);
return c1 - c2;
}
static void *(*cJSON_malloc)(size_t sz) = malloc;//定義一個函數指針並初始化指向malloc函數
static void (*cJSON_free)(void *ptr) = free;//同上,這裏有一個很巧妙靈活的功能,下邊會提到
//將傳入的字符串複製一副本並返回新的字符串指針
static char* cJSON_strdup(const char* str)
{
size_t len;
char* copy;
len = strlen(str) + 1;
if (!(copy = (char*)cJSON_malloc(len))) return 0;
memcpy(copy,str,len);
return copy;
}
//Hook內存管理函數,默認申請、釋放內存函數malloc、free 也可以自定內存管理函數,增加靈活度,順便這裏的三目運算符還有函數指針結合用在這裏簡直是大寫的贊!(代碼的安全考慮的也比較全)
void cJSON_InitHooks(cJSON_Hooks* hooks)
{
if (!hooks) { /* Reset hooks */ //如果hooks爲空,使用默認的內存管理
cJSON_malloc = malloc;
cJSON_free = free;
return;
}
cJSON_malloc = (hooks->malloc_fn)?hooks->malloc_fn:malloc;
cJSON_free = (hooks->free_fn)?hooks->free_fn:free;
}
這裏順便貼上cJSON_Hook結構體定義:
typedef struct cJSON_Hooks {
void *(*malloc_fn)(size_t sz);
void (*free_fn)(void *ptr);
} cJSON_Hooks;
//內存管理函數,new一個cJSON節點(對象)出來,並返回指向該節點的地址, 注意返回類型爲(cJSON *)型
/* Internal constructor. */
static cJSON *cJSON_New_Item(void)
{
cJSON* node = (cJSON*)cJSON_malloc(sizeof(cJSON));//malloc出一個節點
if (node) memset(node,0,sizeof(cJSON));//將內存初始化爲0
return node;
}
這裏順便說一下cJSON結構體的類型:
/* The cJSON structure: */
typedef struct cJSON {
struct cJSON *next,*prev; //雙向鏈表指針
struct cJSON *child; //第一個兒子的指針 這個後邊用到會具體說道
int type; /* The type of the item, as above. */
char *valuestring; /* The item's string, if type==cJSON_String */
int valueint; /* The item's number, if type==cJSON_Number */
double valuedouble; /* The item's number, if type==cJSON_Number */
char *string; //如果是對象的key_value元素的話, key值
} cJSON;
type:
/* cJSON Types: */
#define cJSON_False (1 << 0)
#define cJSON_True (1 << 1)
#define cJSON_NULL (1 << 2)
#define cJSON_Number (1 << 3)
#define cJSON_String (1 << 4)
#define cJSON_Array (1 << 5)
#define cJSON_Object (1 << 6)
//刪除一個cJSON節點, 先刪除兒子節點,然後刪除自己。對於字符串,需要先釋放字符串的內存然後再釋放自己的這塊內存,對於其他節點,直接釋放自己這塊內存(目前對這裏的兒子節點還是有點不理解,兒子節點(struct cJSON類型)到底是什麼?幹嘛用的?刪除的時候爲啥要這樣做?後邊繼續分析)
#define cJSON_IsReference 256
#define cJSON_StringIsConst 512
/* Delete a cJSON structure. */
void cJSON_Delete(cJSON *c)
{
cJSON *next;
while (c)
{
next=c->next;
if (!(c->type&cJSON_IsReference) && c->child)
cJSON_Delete(c->child); //先遞歸刪除自己的兒子節點
if (!(c->type&cJSON_IsReference) && c->valuestring)
cJSON_free(c->valuestring);
if (!(c->type&cJSON_StringIsConst) && c->string)
cJSON_free(c->string);
cJSON_free(c);
c=next;
}
}
//解析數字,源碼風格就是這樣的,反正我閱讀起來相當不方便!建議閱讀之前格式還是自己先調整一下!
//解析輸入文本生成一個數字,並填充結果項
//傳入的參數有兩個,這裏先只關注num, 返回值是一個字符串
<span style="font-size:18px;">/* Parse the input text to generate a number, and populate the result into item. */
static const char *parse_number(cJSON *item,const char *num)
{
double n=0,sign=1,scale=0;int subscale=0,signsubscale=1;
if (*num=='-') sign=-1,num++; /* 判斷是否爲正負數 */
if (*num=='0') num++; /* is zero */
if (*num>='1' && *num<='9')
do n=(n*10.0)+(*num++ -'0'); while (*num>='0' && *num<='9'); //注意一下這裏的語法,兩個分號
if (*num=='.' && num[1]>='0' && num[1]<='9') //對小數點後邊的部分進行處理 scale記錄小數點後邊的位數
{num++; do n=(n*10.0)+(*num++ -'0'),scale--; while (*num>='0' && *num<='9');}
if (*num=='e' || *num=='E') /* 是否爲指數,科學計數法 */
{ num++;if (*num=='+') num++; else if (*num=='-') signsubscale=-1,num++;//判斷指數後邊冪的正負號
while (*num>='0' && *num<='9') subscale=(subscale*10)+(*num++ - '0');//指數後邊10的冪
}
//將字符串轉換爲相應的數值
n=sign*n*pow(10.0,(scale+subscale*signsubscale));/* number = +/- number.fraction * 10^+/- exponent */
item->valuedouble=n;//將算出來的值存入緩存
item->valueint=(int)n;//同上
item->type=cJSON_Number; //目標類型爲數字
return num;
}</span>
其實上面的看着稍微有點複雜,但是仔細分析其實還是很簡單的!最簡單的就是隨便寫個數然後把自己當計算機一步一步執行上面的代碼然後看結果!這裏主要是字符串的科學計數法轉變爲數學上的科學計數法!
繼續next one!
static int pow2gt (int x)
{ --x; x|=x>>1; x|=x>>2; x|=x>>4; x|=x>>8; x|=x>>16; return x+1; }
吐槽一下,源碼中這種編碼風格真的很彆扭!__pow2gt(x) 函數技巧, 返回 一個比x 的 n (其中n是2的冪),並且是最小的冪!說白了就是將一個數後邊所有的位都置1然後再+1,自己可以隨便代個數中手算驗證一下!這裏參數是int型,如果是負數怎麼辦?這個還沒驗證過!繼續向下看吧!
typedef struct {char *buffer; int length; int offset; } printbuffer;
/* ensure 函數 是一個 協助 printbuffer 分配內存的一個函數
* len 表示當前字符串的字符串起始偏移量 即 newbuffer+p->offset 起始的
*/
static char* ensure(printbuffer *p,int needed)
{
char *newbuffer;int newsize;
if (!p || !p->buffer) return 0;//傳入參數合法性檢測
needed+=p->offset;//需要額外分配的內存 也就是偏移量
if (needed<=p->length) return p->buffer+p->offset;//內存夠用直接返回
newsize=pow2gt(needed);//不得不說這個用的很巧妙
newbuffer=(char*)cJSON_malloc(newsize);//malloc出新內存 用來放什麼?後邊來看是放buffer裏面的內容
if (!newbuffer) {cJSON_free(p->buffer);p->length=0,p->buffer=0;return 0;}
if (newbuffer) memcpy(newbuffer,p->buffer,p->length);//複製內容 這一行有點不明白意圖?爲啥要這樣做?
cJSON_free(p->buffer);//釋放掉之前的buffer
p->length=newsize;
p->buffer=newbuffer;
return newbuffer+p->offset;//爲什麼要返回這個?這個函數到底要幹嗎?
}
這個函數大概的功能就是協助分配內存,還沒摸透具體爲什麼要這麼做,後邊邊看邊理解吧!static int update(printbuffer *p)
{
char *str;
if (!p || !p->buffer) return 0;
str=p->buffer+p->offset;
return p->offset+strlen(str);
}
返回的是一個地址,偏移量加上字符串str長度的地址,但這裏char *str只是個局部指針變量!該指針指向原有的buffer+offset地址處後面的字符串,返回值是一個int型!
//先看函數參數、返回值!返回值爲一個字符串地址,這裏看到sprintf的這種用法就知道是講數字轉換爲字符串數組!
//也就是 300轉換爲“300”
static char *print_number(cJSON *item,printbuffer *p)
{
char *str=0;
double d=item->valuedouble;//取出item裏面的valuedouble
if (d==0)
{
if (p) str=ensure(p,2);//申請兩個字節內存 這個結合pow2gt函數
else str=(char*)cJSON_malloc(2); /* special case for 0. */
if (str) strcpy(str,"0");//加一個字符0 ???
}
else if (fabs(((double)item->valueint)-d)<=DBL_EPSILON && d<=INT_MAX && d>=INT_MIN)
{
if (p) str=ensure(p,21);
else str=(char*)cJSON_malloc(21); /* 2^64+1 can be represented in 21 chars. */
if (str) sprintf(str,"%d",item->valueint);
}
else
{
if (p) str=ensure(p,64);
else str=(char*)cJSON_malloc(64); /* This is a nice tradeoff. */
if (str)
{
if (fpclassify(d) != FP_ZERO && !isnormal(d))
sprintf(str,"null");
else if (fabs(floor(d)-d)<=DBL_EPSILON && fabs(d)<1.0e60)
sprintf(str,"%.0f",d);
else if (fabs(d)<1.0e-6 || fabs(d)>1.0e9)
sprintf(str,"%e",d);
else sprintf(str,"%f",d);
}
}
return str;
}
上面的函數中有個地方可以關注一下DBL_EPSILON 繼續next one!
//將十六進制的字符串轉換爲數字表示!這個函數自己也可以單獨寫個小程序測試一下,比較簡單明瞭!
static unsigned parse_hex4(const char *str)
{
unsigned h=0;
if (*str>='0' && *str<='9') h+=(*str)-'0';
else if (*str>='A' && *str<='F') h+=10+(*str)-'A';
else if (*str>='a' && *str<='f') h+=10+(*str)-'a';
else return 0;
h=h<<4;str++;
if (*str>='0' && *str<='9') h+=(*str)-'0';
else if (*str>='A' && *str<='F') h+=10+(*str)-'A';
else if (*str>='a' && *str<='f') h+=10+(*str)-'a';
else return 0;
h=h<<4;str++;
if (*str>='0' && *str<='9') h+=(*str)-'0';
else if (*str>='A' && *str<='F') h+=10+(*str)-'A';
else if (*str>='a' && *str<='f') h+=10+(*str)-'a';
else return 0;
h=h<<4;str++;
if (*str>='0' && *str<='9') h+=(*str)-'0';
else if (*str>='A' && *str<='F') h+=10+(*str)-'A';
else if (*str>='a' && *str<='f') h+=10+(*str)-'a';
else return 0;
return h;
}
//輸入文本解析成一個因爲保有的字符串,並填充項
static const unsigned char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
static const char *parse_string(cJSON *item,const char *str,const char **ep)
{
const char *ptr=str+1,*end_ptr=str+1;char *ptr2;char *out;int len=0;unsigned uc,uc2;
if (*str!='\"') {*ep=str;return 0;} /* not a string! */
while (*end_ptr!='\"' && *end_ptr && ++len) if (*end_ptr++ == '\\') end_ptr++; /* Skip escaped quotes. */
out=(char*)cJSON_malloc(len+1); /* This is how long we need for the string, roughly. */
if (!out) return 0;
item->valuestring=out; /* assign here so out will be deleted during cJSON_Delete() later */
item->type=cJSON_String;
ptr=str+1;ptr2=out;
while (ptr < end_ptr)
{
if (*ptr!='\\') *ptr2++=*ptr++;
else
{
ptr++;
switch (*ptr)
{
case 'b': *ptr2++='\b'; break;
case 'f': *ptr2++='\f'; break;
case 'n': *ptr2++='\n'; break;
case 'r': *ptr2++='\r'; break;
case 't': *ptr2++='\t'; break;
case 'u': /* transcode utf16 to utf8. */
uc=parse_hex4(ptr+1);ptr+=4; /* get the unicode char. */
if (ptr >= end_ptr) {*ep=str;return 0;} /* invalid */
if ((uc>=0xDC00 && uc<=0xDFFF) || uc==0) {*ep=str;return 0;}
if (uc>=0xD800 && uc<=0xDBFF) /* UTF16 surrogate pairs. */
{
if (ptr+6 > end_ptr) {*ep=str;return 0;} /* invalid */
if (ptr[1]!='\\' || ptr[2]!='u') {*ep=str;return 0;}
uc2=parse_hex4(ptr+3);ptr+=6;
if (uc2<0xDC00 || uc2>0xDFFF) {*ep=str;return 0;}
uc=0x10000 + (((uc&0x3FF)<<10) | (uc2&0x3FF));
}
len=4;
if (uc<0x80) len=1;
else if (uc<0x800) len=2;
else if (uc<0x10000) len=3;
ptr2+=len;
switch (len) {
case 4: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
case 3: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
case 2: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
case 1: *--ptr2 =(uc | firstByteMark[len]);
}
ptr2+=len;
break;
default: *ptr2++=*ptr; break;
}
ptr++;
}
}
*ptr2=0;
if (*ptr=='\"') ptr++;
return ptr;
}
函數有點長,理解起來也稍微有點費勁!反正函數的大體功能還有裏面的處理流程還沒弄明白!先看後邊,看的差不多再測試程序!通過運行效果反過來再看程序裏面的函數處理,先只能迂迴戰術了!//下面的一個函數功能和上面差不多,就是將數據填充成可以打印出來的字符串
static char *print_string_ptr(const char *str,printbuffer *p)
{
const char *ptr;char *ptr2,*out;int len=0,flag=0;unsigned char token;
if (!str)
{
if (p) out=ensure(p,3);
else out=(char*)cJSON_malloc(3);
if (!out) return 0;
strcpy(out,"\"\"");
return out;
}
for (ptr=str;*ptr;ptr++) flag|=((*ptr>0 && *ptr<32)||(*ptr=='\"')||(*ptr=='\\'))?1:0;
if (!flag)
{
len=ptr-str;
if (p) out=ensure(p,len+3);
else out=(char*)cJSON_malloc(len+3);
if (!out) return 0;
ptr2=out;*ptr2++='\"';
strcpy(ptr2,str);
ptr2[len]='\"';
ptr2[len+1]=0;
return out;
}
ptr=str;
while ((token=*ptr) && ++len)
{if (strchr("\"\\\b\f\n\r\t",token)) len++; else if (token<32) len+=5;ptr++;}
if (p) out=ensure(p,len+3);
else out=(char*)cJSON_malloc(len+3);
if (!out) return 0;
ptr2=out;ptr=str;
*ptr2++='\"';
while (*ptr)
{
if ((unsigned char)*ptr>31 && *ptr!='\"' && *ptr!='\\') *ptr2++=*ptr++;
else
{
*ptr2++='\\';
switch (token=*ptr++)
{
case '\\': *ptr2++='\\'; break;
case '\"': *ptr2++='\"'; break;
case '\b': *ptr2++='b'; break;
case '\f': *ptr2++='f'; break;
case '\n': *ptr2++='n'; break;
case '\r': *ptr2++='r'; break;
case '\t': *ptr2++='t'; break;
default: sprintf(ptr2,"u%04x",token);ptr2+=5; break; /* escape and print */
}
}
}
*ptr2++='\"';*ptr2++=0;
return out;
}
//做了一層封裝 以字符的形式填充
<span style="font-size:18px;">static char *print_string(cJSON *item,printbuffer *p) {return print_string_ptr(item->valuestring,p);}</span>
//跳過空格
<span style="font-size:18px;">static const char *skip(const char *in) {while (in && *in && (unsigned char)*in<=32) in++; return in;}</span>
//解析對象,創建一個新的根並初始化,返回一個cJSON類型
cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated)
{
const char *end=0,**ep=return_parse_end?return_parse_end:&global_ep;
cJSON *c=cJSON_New_Item();
*ep=0;
if (!c) return 0; /* memory fail */
end=parse_value(c,skip(value),ep);
if (!end) {cJSON_Delete(c);return 0;} /* parse failure. ep is set. */
/* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
if (require_null_terminated) {end=skip(end);if (*end) {cJSON_Delete(c);*ep=end;return 0;}}
if (return_parse_end) *return_parse_end=end;
return c;
}
/* Default options for cJSON_Parse */
cJSON *cJSON_Parse(const char *value) {return cJSON_ParseWithOpts(value,0,0);}
/* Render a cJSON item/entity/structure to text. */
char *cJSON_Print(cJSON *item) {return print_value(item,0,1,0);}
char *cJSON_PrintUnformatted(cJSON *item) {return print_value(item,0,0,0);}
//先繼續向下看
char *cJSON_PrintBuffered(cJSON *item,int prebuffer,int fmt)
{
printbuffer p;
p.buffer=(char*)cJSON_malloc(prebuffer);
p.length=prebuffer;
p.offset=0;
return print_value(item,0,fmt,&p);
}
static const char *parse_value(cJSON *item,const char *value,const char **ep)
{
if (!value) return 0; /* Fail on null. */
if (!strncmp(value,"null",4)) { item->type=cJSON_NULL; return value+4; }
if (!strncmp(value,"false",5)) { item->type=cJSON_False; return value+5; }
if (!strncmp(value,"true",4)) { item->type=cJSON_True; item->valueint=1;return value+4; }
if (*value=='\"') { return parse_string(item,value,ep); }
if (*value=='-' || (*value>='0' && *value<='9')) { return parse_number(item,value); }
if (*value=='[') { return parse_array(item,value,ep); }
if (*value=='{') { return parse_object(item,value,ep); }
*ep=value;return 0; /* failure. */
}
//解析數組 終於看到了最核心的代碼了 下面的代碼大多是合法性檢測,實際上代碼沒兩行
static const char *parse_array(cJSON *item,const char *value,const char **ep)
{
cJSON *child;
if (*value!='[') {*ep=value;return 0;} /* not an array! */
item->type=cJSON_Array;
value=skip(value+1);
if (*value==']') return value+1; /* empty array. */
item->child=child=cJSON_New_Item();
if (!item->child) return 0; /* memory fail */
value=skip(parse_value(child,skip(value),ep)); /* skip any spacing, get the value. */
if (!value) return 0;
while (*value==',')
{
cJSON *new_item;
if (!(new_item=cJSON_New_Item())) return 0; /* memory fail */
child->next=new_item;new_item->prev=child;child=new_item;//原來child指針是指向cJson節點的,還有兩個指針作爲雙向鏈表指針
value=skip(parse_value(child,skip(value+1),ep));
if (!value) return 0; /* memory fail */
}
if (*value==']') return value+1; /* end of array */
*ep=value;return 0; /* malformed. */
}
//下面這個函數就比較長了,返回值爲一個要out的字符串!關於下面的解析,代碼稍微比較長一點,可以對照着後邊的測試程序看,然後可以將測試例程塞進這個函數,看看out出的結果,然後還是把自己當計算機,照着代碼一步一步執行!等大體吸收了下面編程的精華,然後就可以回過頭來反觀大局了!
static char *print_array(cJSON *item,int depth,int fmt,printbuffer *p)
{
char **entries;
char *out=0,*ptr,*ret;int len=5;
cJSON *child=item->child;
int numentries=0,i=0,fail=0;
size_t tmplen=0;
/* How many entries in the array? */
while (child) numentries++,child=child->next;
/* Explicitly handle numentries==0 */
if (!numentries)
{
if (p) out=ensure(p,3);
else out=(char*)cJSON_malloc(3);
if (out) strcpy(out,"[]");
return out;
}
if (p)
{
/* Compose the output array. */
i=p->offset;
ptr=ensure(p,1);if (!ptr) return 0; *ptr='['; p->offset++;
child=item->child;
while (child && !fail)
{
print_value(child,depth+1,fmt,p);
p->offset=update(p);
if (child->next)
{
len=fmt?2:1;ptr=ensure(p,len+1);
if (!ptr) return 0;*ptr++=',';
if(fmt)*ptr++=' ';*ptr=0;p->offset+=len;
}
child=child->next;
}
ptr=ensure(p,2);if (!ptr) return 0; *ptr++=']';*ptr=0;
out=(p->buffer)+i;
}
else
{
/* Allocate an array to hold the values for each */
entries=(char**)cJSON_malloc(numentries*sizeof(char*));
if (!entries) return 0;
memset(entries,0,numentries*sizeof(char*));
/* Retrieve all the results: */
child=item->child;
while (child && !fail)
{
ret=print_value(child,depth+1,fmt,0);
entries[i++]=ret;
if (ret) len+=strlen(ret)+2+(fmt?1:0); else fail=1;
child=child->next;
}
/* If we didn't fail, try to malloc the output string */
if (!fail) out=(char*)cJSON_malloc(len);
/* If that fails, we fail. */
if (!out) fail=1;
/* Handle failure. */
if (fail)
{
for (i=0;i<numentries;i++) if (entries[i]) cJSON_free(entries[i]);
cJSON_free(entries);
return 0;
}
/* Compose the output array. */
*out='[';
ptr=out+1;*ptr=0;
for (i=0;i<numentries;i++)
{
tmplen=strlen(entries[i]);memcpy(ptr,entries[i],tmplen);ptr+=tmplen;
if (i!=numentries-1) {*ptr++=',';if(fmt)*ptr++=' ';*ptr=0;}
cJSON_free(entries[i]);
}
cJSON_free(entries);
*ptr++=']';*ptr++=0;
}
return out;
}
下面兩個函數是解析對象和out一個字符串形式的對象!和上面兩個API一樣
/* Build an object from the text. */
static const char *parse_object(cJSON *item,const char *value,const char **ep)
{
cJSON *child;
if (*value!='{') {*ep=value;return 0;} /* not an object! */
item->type=cJSON_Object;
value=skip(value+1);
if (*value=='}') return value+1; /* empty array. */
item->child=child=cJSON_New_Item();
if (!item->child) return 0;
value=skip(parse_string(child,skip(value),ep));
if (!value) return 0;
child->string=child->valuestring;child->valuestring=0;
if (*value!=':') {*ep=value;return 0;} /* fail! */
value=skip(parse_value(child,skip(value+1),ep)); /* skip any spacing, get the value. */
if (!value) return 0;
while (*value==',')
{
cJSON *new_item;
if (!(new_item=cJSON_New_Item())) return 0; /* memory fail */
child->next=new_item;new_item->prev=child;child=new_item;
value=skip(parse_string(child,skip(value+1),ep));
if (!value) return 0;
child->string=child->valuestring;child->valuestring=0;
if (*value!=':') {*ep=value;return 0;} /* fail! */
value=skip(parse_value(child,skip(value+1),ep)); /* skip any spacing, get the value. */
if (!value) return 0;
}
if (*value=='}') return value+1; /* end of array */
*ep=value;return 0; /* malformed. */
}
/* Render an object to text. */
static char *print_object(cJSON *item,int depth,int fmt,printbuffer *p)
{
char **entries=0,**names=0;
char *out=0,*ptr,*ret,*str;int len=7,i=0,j;
cJSON *child=item->child;
int numentries=0,fail=0;
size_t tmplen=0;
/* Count the number of entries. */
while (child) numentries++,child=child->next;
/* Explicitly handle empty object case */
if (!numentries)
{
if (p) out=ensure(p,fmt?depth+4:3);
else out=(char*)cJSON_malloc(fmt?depth+4:3);
if (!out) return 0;
ptr=out;*ptr++='{';
if (fmt) {*ptr++='\n';for (i=0;i<depth;i++) *ptr++='\t';}
*ptr++='}';*ptr++=0;
return out;
}
if (p)
{
/* Compose the output: */
i=p->offset;
len=fmt?2:1; ptr=ensure(p,len+1); if (!ptr) return 0;
*ptr++='{'; if (fmt) *ptr++='\n'; *ptr=0; p->offset+=len;
child=item->child;depth++;
while (child)
{
if (fmt)
{
ptr=ensure(p,depth); if (!ptr) return 0;
for (j=0;j<depth;j++) *ptr++='\t';
p->offset+=depth;
}
print_string_ptr(child->string,p);
p->offset=update(p);
len=fmt?2:1;
ptr=ensure(p,len); if (!ptr) return 0;
*ptr++=':';if (fmt) *ptr++='\t';
p->offset+=len;
print_value(child,depth,fmt,p);
p->offset=update(p);
len=(fmt?1:0)+(child->next?1:0);
ptr=ensure(p,len+1); if (!ptr) return 0;
if (child->next) *ptr++=',';
if (fmt) *ptr++='\n';*ptr=0;
p->offset+=len;
child=child->next;
}
ptr=ensure(p,fmt?(depth+1):2); if (!ptr) return 0;
if (fmt) for (i=0;i<depth-1;i++) *ptr++='\t';
*ptr++='}';*ptr=0;
out=(p->buffer)+i;
}
else
{
/* Allocate space for the names and the objects */
entries=(char**)cJSON_malloc(numentries*sizeof(char*));
if (!entries) return 0;
names=(char**)cJSON_malloc(numentries*sizeof(char*));
if (!names) {cJSON_free(entries);return 0;}
memset(entries,0,sizeof(char*)*numentries);
memset(names,0,sizeof(char*)*numentries);
/* Collect all the results into our arrays: */
child=item->child;depth++;if (fmt) len+=depth;
while (child && !fail)
{
names[i]=str=print_string_ptr(child->string,0);
entries[i++]=ret=print_value(child,depth,fmt,0);
if (str && ret) len+=strlen(ret)+strlen(str)+2+(fmt?2+depth:0); else fail=1;
child=child->next;
}
/* Try to allocate the output string */
if (!fail) out=(char*)cJSON_malloc(len);
if (!out) fail=1;
/* Handle failure */
if (fail)
{
for (i=0;i<numentries;i++) {if (names[i]) cJSON_free(names[i]);if (entries[i]) cJSON_free(entries[i]);}
cJSON_free(names);cJSON_free(entries);
return 0;
}
/* Compose the output: */
*out='{';ptr=out+1;if (fmt)*ptr++='\n';*ptr=0;
for (i=0;i<numentries;i++)
{
if (fmt) for (j=0;j<depth;j++) *ptr++='\t';
tmplen=strlen(names[i]);memcpy(ptr,names[i],tmplen);ptr+=tmplen;
*ptr++=':';if (fmt) *ptr++='\t';
strcpy(ptr,entries[i]);ptr+=strlen(entries[i]);
if (i!=numentries-1) *ptr++=',';
if (fmt) *ptr++='\n';*ptr=0;
cJSON_free(names[i]);cJSON_free(entries[i]);
}
cJSON_free(names);cJSON_free(entries);
if (fmt) for (i=0;i<depth-1;i++) *ptr++='\t';
*ptr++='}';*ptr++=0;
}
return out;
}
/* Get Array size/item / object item. */
int cJSON_GetArraySize(cJSON *array)
{cJSON *c=array->child;int i=0;while(c)i++,c=c->next;return i;}//返回節點的個數
cJSON *cJSON_GetArrayItem(cJSON *array,int item)
{cJSON *c=array?array->child:0;while (c && item>0) item--,c=c->next; return c;}//返回第item個節點地址
cJSON *cJSON_GetObjectItem(cJSON *object,const char *string)//同上,只是類型不一樣
{cJSON *c=object?object->child:0;while (c && cJSON_strcasecmp(c->string,string)) c=c->next; return c;}
int cJSON_HasObjectItem(cJSON *object,const char *string)//二次封裝,暫時還沒明白這樣做的優勢
{return cJSON_GetObjectItem(object,string)?1:0;}
/* Utility for array list handling. */
static void suffix_object(cJSON *prev,cJSON *item)
{prev->next=item;item->prev=prev;}//個人理解在鏈表尾插入一個節點
/* Utility for handling references. */
static cJSON *create_reference(cJSON *item)
{
cJSON *ref=cJSON_New_Item();
if (!ref) return 0;
memcpy(ref,item,sizeof(cJSON));
ref->string=0;
ref->type|=cJSON_IsReference;// 與256相與 1 0000 0000(256的二進制表示)這裏暫時有點不明白
ref->next=ref->prev=0;//都置空
return ref;
}
/* Add item to array/object. */
void cJSON_AddItemToArray(cJSON *array, cJSON *item)//將item節點插入array鏈表
{
cJSON *c=array->child;
if (!item) return;
if (!c) {array->child=item;} //如果爲空鏈表 直接插入
else
{while (c && c->next) c=c->next; suffix_object(c,item);}
}
//將字符串添加進對象
void cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item)
{
if (!item) return;
if (item->string) cJSON_free(item->string);
item->string=cJSON_strdup(string);
cJSON_AddItemToArray(object,item);
}
void cJSON_AddItemToObjectCS(cJSON *object,const char *string,cJSON *item)
{
if (!item) return;
if (!(item->type&cJSON_StringIsConst) && item->string)
cJSON_free(item->string);
item->string=(char*)string;
item->type|=cJSON_StringIsConst;//512 (10 0000 0000b)
cJSON_AddItemToArray(object,item);
}
void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)
{
cJSON_AddItemToArray(array,create_reference(item));
}
void cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item)
{
cJSON_AddItemToObject(object,string,create_reference(item));
}
cJSON *cJSON_DetachItemFromArray(cJSON *array,int which)//分離鏈表中第which位置的節點並返回
{
cJSON *c=array->child;
while (c && which>0) c=c->next,which--;//c指向第which個節點
if (!c) return 0;
if (c->prev)
c->prev->next=c->next;
if (c->next)
c->next->prev=c->prev;
if (c==array->child)
array->child=c->next;
c->prev=c->next=0;
return c;
}
void cJSON_DeleteItemFromArray(cJSON *array,int which)
{
cJSON_Delete(cJSON_DetachItemFromArray(array,which));
}
//功能同上差不多 只是類型不同
cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string)
{
int i=0;
cJSON *c=object->child;
while (c && cJSON_strcasecmp(c->string,string)) i++,c=c->next;
if (c)
return cJSON_DetachItemFromArray(object,i);
return 0;
}
void cJSON_DeleteItemFromObject(cJSON *object,const char *string)
{
cJSON_Delete(cJSON_DetachItemFromObject(object,string));
}
//下面的API也是核心部分,要好好分析吸收
/* Replace array/object items with new ones. */
void cJSON_InsertItemInArray(cJSON *array,int which,cJSON *newitem)//在鏈表中插入一個新的節點
{
cJSON *c=array->child;
while (c && which>0) c=c->next,which--;//先定位到替換的位置
if (!c) {cJSON_AddItemToArray(array,newitem);return;}
newitem->next=c;
newitem->prev=c->prev;
c->prev=newitem;
if (c==array->child)
array->child=newitem;
else
newitem->prev->next=newitem;
}
void cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem)<span style="font-family: Tahoma, Arial, 宋體, 'Malgun Gothic'; widows: auto;">//用新的節點替換原有的某一個節點</span>
{
cJSON *c=array->child;
while (c && which>0) c=c->next,which--;
if (!c) return;
newitem->next=c->next;
newitem->prev=c->prev;
if (newitem->next)
newitem->next->prev=newitem;
if (c==array->child)
array->child=newitem;
else
newitem->prev->next=newitem;
c->next=c->prev=0;
cJSON_Delete(c);
}
void cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem)//同上,只是換個類型
{
int i=0;
cJSON *c=object->child;
while(c && cJSON_strcasecmp(c->string,string))
i++,c=c->next;
if(c)
{
newitem->string=cJSON_strdup(string);
cJSON_ReplaceItemInArray(object,i,newitem);
}
}
1.重要函數說明【1】兩個創建
【創建JSON對象】cJSON *cJSON_CreateObject(void);
【創建JSON數組】cJSON *cJSON_CreateArray(void);
【2】兩種添加
【向對象中添加】voidcJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item);
【向數組中添加】void cJSON_AddItemToArray(cJSON *array, cJSON *item);
【3】常用幾招
【向對象中增加數字】cJSON_AddItemToObject(root, "value", cJSON_CreateNumber(value));
【向對象中增加文件】cJSON_AddItemToObject(root, "string", cJSON_CreateString(string));
【4】JSON嵌套
【向對象中增加數組】cJSON_AddItemToObject(root, "rows", rows = cJSON_CreateArray());
【向數組中增加對象】cJSON_AddItemToArray(rows, row = cJSON_CreateObject());
【簡單說明】
【1】cJSON_AddItemToObject(root, "value", cJSON_CreateNumber(value));
【2】cJSON_AddNumberToObject(root, "value", value);
【1】和【2】效果完全相同。
【簡單說明】
【1】 cJSON_AddItemToObject(root, "name", cJSON_CreateString(name));
【2】 cJSON_AddStringToObject(root, "name",name);
【1】和【2】效果完全相同。
//源碼的格式稍微調整了了一下
/* Create basic types: */
cJSON *cJSON_CreateNull(void)
{
cJSON *item=cJSON_New_Item();
if(item)
item->type=cJSON_NULL;
return item;
}
cJSON *cJSON_CreateTrue(void)
{
cJSON *item=cJSON_New_Item();
if(item)
item->type=cJSON_True;
return item;
}
cJSON *cJSON_CreateFalse(void)
{
cJSON *item=cJSON_New_Item();
if(item)
item->type=cJSON_False;
return item;
}
cJSON *cJSON_CreateBool(int b)
{
cJSON *item=cJSON_New_Item();
if(item)
item->type=b?cJSON_True:cJSON_False;
return item;
}
cJSON *cJSON_CreateNumber(double num)
{
cJSON *item=cJSON_New_Item();
if(item)
{
item->type=cJSON_Number;
item->valuedouble=num;
item->valueint=(int)num;
}
return item;
}
cJSON *cJSON_CreateString(const char *string)
{
cJSON *item=cJSON_New_Item();
if(item)
{
item->type=cJSON_String;
item->valuestring=cJSON_strdup(string);
if(!item->valuestring)
{
cJSON_Delete(item);
return 0;
}
}
return item;
}
cJSON *cJSON_CreateArray(void)
{
cJSON *item=cJSON_New_Item();
if(item)
item->type=cJSON_Array;
return item;
}
cJSON *cJSON_CreateObject(void)
{
cJSON *item=cJSON_New_Item();
if(item)
item->type=cJSON_Object;
return item;
}
上的API函數筆記簡單!這裏就不囉嗦了!//下面的四個API都差不多,只是創建不同類型的數組
/* Create Arrays: */
cJSON *cJSON_CreateIntArray(const int *numbers,int count)
{
int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();
for(i=0;a && i<count;i++)
{
n=cJSON_CreateNumber(numbers[i]);//填充cJSON *n 的部分結構,具體看上面函數實現
if(!n){cJSON_Delete(a);return 0;}
if(!i)
a->child=n;
else
suffix_object(p,n);//插入節點
p=n;
}
return a;
}
cJSON *cJSON_CreateFloatArray(const float *numbers,int count)
{
int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();
for(i=0;a && i<count;i++)
{
n=cJSON_CreateNumber(numbers[i]);
if(!n){cJSON_Delete(a);return 0;}
if(!i)
a->child=n;
else
suffix_object(p,n);
p=n;
}
return a;
}
cJSON *cJSON_CreateDoubleArray(const double *numbers,int count)
{
int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();
for(i=0;a && i<count;i++)
{
n=cJSON_CreateNumber(numbers[i]);
if(!n){cJSON_Delete(a);return 0;}
if(!i)
a->child=n;
else
suffix_object(p,n);
p=n;
}
return a;
}
cJSON *cJSON_CreateStringArray(const char **strings,int count)
{
int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();
for(i=0;a && i<count;i++)
{
n=cJSON_CreateString(strings[i]);
if(!n){cJSON_Delete(a);return 0;}
if(!i)
a->child=n;
else
suffix_object(p,n);
p=n;
}
return a;
}
//最後兩個API
/* Duplication */
cJSON *cJSON_Duplicate(cJSON *item,int recurse)//拷貝副本 是否遞歸拷貝
{
cJSON *newitem,*cptr,*nptr=0,*newchild;
if (!item) return 0;
/* Create new item */
newitem=cJSON_New_Item();
if (!newitem) return 0;
/* Copy over all vars */
newitem->type=item->type&(~cJSON_IsReference),newitem->valueint=item->valueint,newitem->valuedouble=item->valuedouble;
if (item->valuestring)
{
newitem->valuestring=cJSON_strdup(item->valuestring);
if (!newitem->valuestring) {cJSON_Delete(newitem);return 0;}
}
if (item->string)
{
newitem->string=cJSON_strdup(item->string);
if (!newitem->string) {cJSON_Delete(newitem);return 0;}
}
/* If non-recursive, then we're done! */
if (!recurse) return newitem;
/* Walk the ->next chain for the child. */
cptr=item->child;
while (cptr)
{
newchild=cJSON_Duplicate(cptr,1);
if (!newchild) {cJSON_Delete(newitem);return 0;}
if (nptr)
{
nptr->next=newchild,newchild->prev=nptr;
nptr=newchild;
}
else {newitem->child=newchild;nptr=newchild;}
cptr=cptr->next;
}
return newitem;
}
void cJSON_Minify(char *json)
{
char *into=json;
while (*json)
{
if (*json==' ') json++;
else if (*json=='\t') json++; /* Whitespace characters. */
else if (*json=='\r') json++;
else if (*json=='\n') json++;
else if (*json=='/' && json[1]=='/') while (*json && *json!='\n') json++;
else if (*json=='/' && json[1]=='*') {while (*json && !(*json=='*' && json[1]=='/')) json++;json+=2;} /* multiline comments. */
else if (*json=='\"'){*into++=*json++;while (*json && *json!='\"'){if (*json=='\\') *into++=*json++;*into++=*json++;}*into++=*json++;}
else *into++=*json++; /* All other characters. */
}
*into=0; /* and null-terminate. */
}
cJSON.h
#ifndef cJSON__h
#define cJSON__h
#ifdef __cplusplus
extern "C"
{
#endif
/* cJSON Types: */
#define cJSON_False (1 << 0)
#define cJSON_True (1 << 1)
#define cJSON_NULL (1 << 2)
#define cJSON_Number (1 << 3)
#define cJSON_String (1 << 4)
#define cJSON_Array (1 << 5)
#define cJSON_Object (1 << 6)
#define cJSON_IsReference 256
#define cJSON_StringIsConst 512
/* The cJSON structure: */
typedef struct cJSON {
/* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
struct cJSON *next,*prev;
/* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
struct cJSON *child;
int type; /* The type of the item, as above. */
char *valuestring; /* The item's string, if type==cJSON_String */
int valueint; /* The item's number, if type==cJSON_Number */
double valuedouble; /* The item's number, if type==cJSON_Number */
/* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
char *string;
} cJSON;
typedef struct cJSON_Hooks {
void *(*malloc_fn)(size_t sz);
void (*free_fn)(void *ptr);
} cJSON_Hooks;
/* Supply malloc, realloc and free functions to cJSON */
extern void cJSON_InitHooks(cJSON_Hooks* hooks);
extern cJSON *cJSON_Parse(const char *value);
/* Render a cJSON entity to text for transfer/storage. Free the char* when finished. */
extern char *cJSON_Print(cJSON *item);
extern char *cJSON_PrintUnformatted(cJSON *item);
/* 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
*/
extern char *cJSON_PrintBuffered(cJSON *item,int prebuffer,int fmt);
/* Delete a cJSON entity and all subentities. */
extern void cJSON_Delete(cJSON *c);
/* Returns the number of items in an array (or object). */
extern int cJSON_GetArraySize(cJSON *array);
/* Retrieve item number "item" from array "array". Returns NULL if unsuccessful. */
extern cJSON *cJSON_GetArrayItem(cJSON *array,int item);
/* Get item "string" from object. Case insensitive. */
extern cJSON *cJSON_GetObjectItem(cJSON *object,const char *string);
extern int cJSON_HasObjectItem(cJSON *object,const char *string);
/* 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.
*/
extern const char *cJSON_GetErrorPtr(void);
/* These calls create a cJSON item of the appropriate type. */
extern cJSON *cJSON_CreateNull(void);
extern cJSON *cJSON_CreateTrue(void);
extern cJSON *cJSON_CreateFalse(void);
extern cJSON *cJSON_CreateBool(int b);
extern cJSON *cJSON_CreateNumber(double num);
extern cJSON *cJSON_CreateString(const char *string);
extern cJSON *cJSON_CreateArray(void);
extern cJSON *cJSON_CreateObject(void);
/* These utilities create an Array of count items. */
extern cJSON *cJSON_CreateIntArray(const int *numbers,int count);
extern cJSON *cJSON_CreateFloatArray(const float *numbers,int count);
extern cJSON *cJSON_CreateDoubleArray(const double *numbers,int count);
extern cJSON *cJSON_CreateStringArray(const char **strings,int count);
/* Append item to the specified array/object. */
extern void cJSON_AddItemToArray(cJSON *array, cJSON *item);
extern void cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item);
extern void cJSON_AddItemToObjectCS(cJSON *object,const char *string,cJSON *item);
/* 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.
*/
extern void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
extern void cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item);
/* Remove/Detatch items from Arrays/Objects. */
extern cJSON *cJSON_DetachItemFromArray(cJSON *array,int which);
extern void cJSON_DeleteItemFromArray(cJSON *array,int which);
extern cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string);
extern void cJSON_DeleteItemFromObject(cJSON *object,const char *string);
/* Update array items. */
extern void cJSON_InsertItemInArray(cJSON *array,int which,cJSON *newitem);
extern void cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem);
extern void cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
/* Duplicate a cJSON item */
extern cJSON *cJSON_Duplicate(cJSON *item,int recurse);
/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
*need to be released. With recurse!=0, it will duplicate any children connected to the item.
*The item->next and ->prev pointers are always zero on return from Duplicate.
*/
/* ParseWithOpts allows you to require (and check) that the JSON is null terminated,
*and to retrieve the pointer to the final byte parsed.
*/
extern cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated);
extern void cJSON_Minify(char *json);
Makefile (這個Makefile 可以將目標文件編譯出動態庫,靜態庫,自帶的測試程序編譯成目標文件,對於我這樣的小白來說還是很值得學習研究的)
OBJ = cJSON.o
LIBNAME = libcjson
TESTS = test
PREFIX ?= /usr/local
INCLUDE_PATH ?= include/cjson
LIBRARY_PATH ?= lib
INSTALL_INCLUDE_PATH = $(DESTDIR)$(PREFIX)/$(INCLUDE_PATH)
INSTALL_LIBRARY_PATH = $(DESTDIR)$(PREFIX)/$(LIBRARY_PATH)
INSTALL ?= cp -a
R_CFLAGS = -fpic $(CFLAGS) -Wall -Werror -Wstrict-prototypes -Wwrite-strings -D_POSIX_C_SOURCE=200112L
uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo false')
## shared lib
DYLIBNAME = $(LIBNAME).so
DYLIBCMD = $(CC) -shared -o $(DYLIBNAME)
## create dynamic (shared) library on Darwin (base OS for MacOSX and IOS)
ifeq (Darwin, $(uname_S))
DYLIBNAME = $(LIBNAME).dylib
## create dyanmic (shared) library on SunOS
else ifeq (SunOS, $(uname_S))
DYLIBCMD = $(CC) -G -o $(DYLIBNAME)
INSTALL = cp -r
endif
## static lib
STLIBNAME = $(LIBNAME).a
.PHONY: all clean install
all: $(DYLIBNAME) $(STLIBNAME) $(TESTS)
$(DYLIBNAME): $(OBJ)
$(DYLIBCMD) $< $(LDFLAGS)
$(STLIBNAME): $(OBJ)
ar rcs $@ $<
$(OBJ): cJSON.c cJSON.h
.c.o:
$(CC) -ansi -pedantic -c $(R_CFLAGS) $<
$(TESTS): cJSON.c cJSON.h test.c
$(CC) cJSON.c test.c -o test -lm -I.
install: $(DYLIBNAME) $(STLIBNAME)
mkdir -p $(INSTALL_LIBRARY_PATH) $(INSTALL_INCLUDE_PATH)
$(INSTALL) cJSON.h $(INSTALL_INCLUDE_PATH)
$(INSTALL) $(DYLIBNAME) $(INSTALL_LIBRARY_PATH)
$(INSTALL) $(STLIBNAME) $(INSTALL_LIBRARY_PATH)
uninstall:
rm -rf $(INSTALL_LIBRARY_PATH)/$(DYLIBNAME)
rm -rf $(INSTALL_LIBRARY_PATH)/$(STLIBNAME)
rm -rf $(INSTALL_INCLUDE_PATH)/cJSON.h
clean:
rm -rf $(DYLIBNAME) $(STLIBNAME) $(TESTS) *.o
test.c
#include <stdio.h>
#include <stdlib.h>
#include "cJSON.h"
/* Parse text to JSON, then render back to text, and print! */
void doit(char *text)
{
char *out;cJSON *json;
json=cJSON_Parse(text);
if (!json) {printf("Error before: [%s]\n",cJSON_GetErrorPtr());}
else
{
out=cJSON_Print(json);
cJSON_Delete(json);
printf("%s\n",out);
free(out);
}
}
/* Read a file, parse, render back, etc. */
void dofile(char *filename)
{
FILE *f;long len;char *data;
f=fopen(filename,"rb");fseek(f,0,SEEK_END);len=ftell(f);fseek(f,0,SEEK_SET);
data=(char*)malloc(len+1);fread(data,1,len,f);data[len]='\0';fclose(f);
doit(data);
free(data);
}
/* Used by some code below as an example datatype. */
struct record {const char *precision;double lat,lon;const char *address,*city,*state,*zip,*country; };
/* Create a bunch of objects as demonstration. */
void create_objects()
{
cJSON *root,*fmt,*img,*thm,*fld;char *out;int i; /* declare a few. */
/* Our "days of the week" array: */
const char *strings[7]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};
/* Our matrix: */
int numbers[3][3]={{0,-1,0},{1,0,0},{0,0,1}};
/* Our "gallery" item: */
int ids[4]={116,943,234,38793};
/* Our array of "records": */
struct record fields[2]={
{"zip",37.7668,-1.223959e+2,"","SAN FRANCISCO","CA","94107","US"},
{"zip",37.371991,-1.22026e+2,"","SUNNYVALE","CA","94085","US"}};
/* Here we construct some JSON standards, from the JSON site. */
/* Our "Video" datatype: */
root=cJSON_CreateObject();
cJSON_AddItemToObject(root, "name", cJSON_CreateString("Jack (\"Bee\") Nimble"));
cJSON_AddItemToObject(root, "format", fmt=cJSON_CreateObject());
cJSON_AddStringToObject(fmt,"type", "rect");
cJSON_AddNumberToObject(fmt,"width", 1920);
cJSON_AddNumberToObject(fmt,"height", 1080);
cJSON_AddFalseToObject (fmt,"interlace");
cJSON_AddNumberToObject(fmt,"frame rate", 24);
out=cJSON_Print(root); cJSON_Delete(root); printf("%s\n",out); free(out); /* Print to text, Delete the cJSON, print it, release the string. */
/* Our "days of the week" array: */
root=cJSON_CreateStringArray(strings,7);
out=cJSON_Print(root); cJSON_Delete(root); printf("%s\n",out); free(out);
/* Our matrix: */
root=cJSON_CreateArray();
for (i=0;i<3;i++) cJSON_AddItemToArray(root,cJSON_CreateIntArray(numbers[i],3));
/* cJSON_ReplaceItemInArray(root,1,cJSON_CreateString("Replacement")); */
out=cJSON_Print(root); cJSON_Delete(root); printf("%s\n",out); free(out);
/* Our "gallery" item: */
root=cJSON_CreateObject();
cJSON_AddItemToObject(root, "Image", img=cJSON_CreateObject());
cJSON_AddNumberToObject(img,"Width",800);
cJSON_AddNumberToObject(img,"Height",600);
cJSON_AddStringToObject(img,"Title","View from 15th Floor");
cJSON_AddItemToObject(img, "Thumbnail", thm=cJSON_CreateObject());
cJSON_AddStringToObject(thm, "Url", "http:/*www.example.com/image/481989943");
cJSON_AddNumberToObject(thm,"Height",125);
cJSON_AddStringToObject(thm,"Width","100");
cJSON_AddItemToObject(img,"IDs", cJSON_CreateIntArray(ids,4));
out=cJSON_Print(root); cJSON_Delete(root); printf("%s\n",out); free(out);
/* Our array of "records": */
root=cJSON_CreateArray();
for (i=0;i<2;i++)
{
cJSON_AddItemToArray(root,fld=cJSON_CreateObject());
cJSON_AddStringToObject(fld, "precision", fields[i].precision);
cJSON_AddNumberToObject(fld, "Latitude", fields[i].lat);
cJSON_AddNumberToObject(fld, "Longitude", fields[i].lon);
cJSON_AddStringToObject(fld, "Address", fields[i].address);
cJSON_AddStringToObject(fld, "City", fields[i].city);
cJSON_AddStringToObject(fld, "State", fields[i].state);
cJSON_AddStringToObject(fld, "Zip", fields[i].zip);
cJSON_AddStringToObject(fld, "Country", fields[i].country);
}
/* cJSON_ReplaceItemInObject(cJSON_GetArrayItem(root,1),"City",cJSON_CreateIntArray(ids,4)); */
out=cJSON_Print(root); cJSON_Delete(root); printf("%s\n",out); free(out);
root=cJSON_CreateObject();
cJSON_AddNumberToObject(root,"number", 1.0/0.0);
out=cJSON_Print(root); cJSON_Delete(root); printf("%s\n",out); free(out);
}
int main (int argc, const char * argv[]) {
/* a bunch of json: */
char text1[]="{\n\"name\": \"Jack (\\\"Bee\\\") Nimble\", \n\"format\": {\"type\": \"rect\", \n\"width\": 1920, \n\"height\": 1080, \n\"interlace\": false,\"frame rate\": 24\n}\n}";
char text2[]="[\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"]";
char text3[]="[\n [0, -1, 0],\n [1, 0, 0],\n [0, 0, 1]\n ]\n";
char text4[]="{\n \"Image\": {\n \"Width\": 800,\n \"Height\": 600,\n \"Title\": \"View from 15th Floor\",\n \"Thumbnail\": {\n \"Url\": \"http:/*www.example.com/image/481989943\",\n \"Height\": 125,\n \"Width\": \"100\"\n },\n \"IDs\": [116, 943, 234, 38793]\n }\n }";
char text5[]="[\n {\n \"precision\": \"zip\",\n \"Latitude\": 37.7668,\n \"Longitude\": -122.3959,\n \"Address\": \"\",\n \"City\": \"SAN FRANCISCO\",\n \"State\": \"CA\",\n \"Zip\": \"94107\",\n \"Country\": \"US\"\n },\n {\n \"precision\": \"zip\",\n \"Latitude\": 37.371991,\n \"Longitude\": -122.026020,\n \"Address\": \"\",\n \"City\": \"SUNNYVALE\",\n \"State\": \"CA\",\n \"Zip\": \"94085\",\n \"Country\": \"US\"\n }\n ]";
char text6[] = "<!DOCTYPE html>"
"<html>\n"
"<head>\n"
" <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n"
" <style type=\"text/css\">\n"
" html, body, iframe { margin: 0; padding: 0; height: 100%; }\n"
" iframe { display: block; width: 100%; border: none; }\n"
" </style>\n"
"<title>Application Error</title>\n"
"</head>\n"
"<body>\n"
" <iframe src="//s3.amazonaws.com/heroku_pages/error.html">\n"
" <p>Application Error</p>\n"
" </iframe>\n"
"</body>\n"
"</html>\n";
/* Process each json textblock by parsing, then rebuilding: */
doit(text1);
doit(text2);
doit(text3);
doit(text4);
doit(text5);
doit(text6);
/* Parse standard testfiles: */
/* dofile("../../tests/test1"); */
/* dofile("../../tests/test2"); */
/* dofile("../../tests/test3"); */
/* dofile("../../tests/test4"); */
/* dofile("../../tests/test5"); */
/* dofile("../../tests/test6"); */
/* Now some samplecode for building objects concisely: */
create_objects();
return 0;
}
編譯運行效果部分截圖:
上面的test.c中也可以一個一個的測試,針對測試用例還有運行的結果再反過來分析源碼!這樣理解起來也會更容易一點!其中下面是doit函數調用的幾個函數關係!
下面是其他網友關於cjson的博客文章,可以結合參考的來看:
http://blog.csdn.net/xukai871105/article/details/33013455
http://blog.sina.com.cn/s/blog_a6fb6cc90101ffme.html
http://blog.sina.com.cn/s/blog_5f28333901017kql.html
http://www.0xffffff.org/2014/02/10/29-cjson-analyse/
源碼後邊接着分析!未完!