CJSON原始碼研究筆記

coding__madman發表於2016-06-06

斷斷續續的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);
}

//上面還沒有說到print_value函式，下面繼續！下面這個函式是解析器的核心！程式碼比較簡潔理解也很容易！

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】效果完全相同。

CJSON的程式碼風格！程式碼很緊湊，但是不是很方便閱讀！

//原始碼的格式稍微調整了了一下

/* 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.kuqin.com/shuoit/20141224/344068.html
http://www.0xffffff.org/2014/02/10/29-cjson-analyse/

原始碼後邊接著分析！未完！

Netty原始碼研究筆記（4）——EventLoop系列
2022-05-23
Netty原始碼筆記OOP
Spring IOC原始碼研究筆記（2）——ApplicationContext系列
2022-06-03
Spring原始碼筆記APPContext
原始碼筆記 — MBProgressHUD
2016-10-19
原始碼筆記
FutureTask原始碼分析筆記
2019-01-19
原始碼筆記
原始碼分析筆記——OkHttp
2018-04-02
原始碼筆記HTTP
koa原始碼筆記(二)
2018-05-15
原始碼筆記
YYCache原始碼筆記2
2017-12-13
原始碼筆記
YYCache原始碼筆記1
2017-12-13
原始碼筆記
libphenom 原始碼筆記
2014-05-06
原始碼筆記
腳踏實地的Netty原始碼研究筆記（1）——開篇
2022-05-20
Netty原始碼筆記
cJSON使用問題記錄
2020-12-14
JSON
ArrayList原始碼閱讀筆記
2020-08-18
原始碼筆記
CopyOnWriteArrayList原始碼閱讀筆記
2020-08-17
原始碼筆記
Retrofit原始碼學習筆記
2019-05-14
原始碼筆記
Koa 原始碼閱讀筆記
2018-09-30
原始碼筆記
memcached 原始碼閱讀筆記
2013-12-23
原始碼筆記
讀碼筆記-YYWebImage原始碼 (三) -YYImageCache
2016-01-09
筆記Web原始碼
Laravel 原始碼筆記容器 register 方法
2020-03-07
Laravel原始碼筆記
Laravel 原始碼筆記容器 alias 方法
2020-03-07
Laravel原始碼筆記
LinkedList原始碼閱讀筆記
2020-08-20
原始碼筆記
vue原始碼學習筆記1
2019-03-07
Vue原始碼筆記
Express Session 原始碼閱讀筆記
2019-04-20
ExpressSession原始碼筆記
guavacache原始碼閱讀筆記
2021-06-18
Guava原始碼筆記
SpringBoot 原始碼解析筆記
2021-08-06
Spring Boot原始碼筆記
jQuery原始碼學習筆記一
2018-10-30
jQuery原始碼筆記
學習筆記 sync/RWMutex原始碼
2020-12-28
筆記Mutex原始碼
Tomcat原始碼閱讀筆記
2018-01-29
Tomcat原始碼筆記
Vue2.5.16原始碼筆記
2018-05-30
Vue原始碼筆記
python原始碼閱讀筆記
2024-11-10
Python原始碼筆記
PHP原始碼研究
2019-02-16
PHP原始碼
ICE原始碼研究
2007-09-03
原始碼
【初學】Spring原始碼筆記之零：閱讀原始碼
2020-07-10
Spring原始碼筆記
ClickHouse原始碼筆記5:聚合函式的原始碼再梳理
2021-04-20
原始碼筆記函式
三方庫原始碼筆記（1）-EventBus 原始碼詳解
2020-12-14
原始碼筆記
Laravel 原始碼筆記容器類 Container
2020-03-04
Laravel原始碼筆記AI
goroutine排程原始碼閱讀筆記
2020-07-29
Go原始碼筆記
Flask 原始碼閱讀筆記開篇
2019-03-03
Flask原始碼筆記
JDK1.8原始碼分析筆記-HashMap
2019-03-03
JDK原始碼筆記HashMap

CJSON原始碼研究筆記

相關文章