羽量级json解析

#ifndef SIM_JSON_H_
#define SIM_JSON_H_
#ifdef __cplusplus
extern "C" {
#endif
	struct json_object;
	typedef struct json_object* json_object_handle;
	json_object_handle create_json_object(const char* const buffer,int len);
	const char* get_object_value(json_object_handle h, const char*const name);
	void desdroy_json_object(json_object_handle h);
	struct json_array;
	typedef struct json_array* json_array_handle;
	json_array_handle create_json_array(const char* const buffer, int len);
	const char* get_array_value(json_array_handle h, int index);
	void destroy_json_array(json_array_handle h);
#ifdef __cplusplus
}
#endif

#endif /* SIM_JSON_H_ */

#include "sim_json.h"
#include "string.h"
#include "stdlib.h"
#include "stdio.h"

#define hint printf


#define json_name_len 64
#define json_value_len 1024*16
#define json_item_counts 32

typedef struct json_object_item_tag {
	char name[json_name_len];
	char value[json_value_len];
} json_object_item, *json_object_item_hanle;
struct json_object {
	unsigned item_counts;
	json_object_item items[json_item_counts];
};

#define char_convertor(str) (('\\' == *str) ? *(++str) : *(str))

static const char*const split_object(char* dst,const char* str,int len,const char split[2]){
	unsigned object_counts = 1;
	for (*dst++ = *str++; len > 0 && object_counts; --len, ++str) {
		if(split[0] == *str){
			++object_counts;
		}
		if(split[1] == *str){
			--object_counts;
		}
		*dst++ = char_convertor(str);
	}
	return (0 == object_counts) ? str : NULL;
}

static const char* const get_json_value(char* value,const char* str, int len) {
	for (; ',' != *str && '}' != *str && len > 0; --len,++str) {
		*value++ = char_convertor(str);
	}
	return str;
}

static const char* const get_json_object(char* value,const char* str, int len) {
	char spliter[2] = {'{','}'};
	return split_object(value,str,len,spliter);
}

static const char*const get_json_array(char* value,const char* str, int len) {
	char spliter[2] = {'[',']'};
	return split_object(value,str,len,spliter);
}

static const char* const pass_json_item(json_object_item_hanle h,const char* str, int len) {
	const char*const org_str = str;
	memset(h, 0 , sizeof(*h));
	str = strchr(str,'"');
	if(NULL == str){
		return NULL;
	}
	sscanf(++str,"%[^\"]",h->name);
	str = strchr(str,':');
	if(NULL == str){
		return NULL;
	}
	++str;
	len -= (str - org_str);
	for(;' ' == *str && len > 0;++str,--len){
		;
	}
	switch(*str){
	case '{': return get_json_object(h->value,str,len); break;
	case '[': return get_json_array(h->value,str,len); break;
	default: return get_json_value(h->value,str,len);
	}
}

json_object_handle create_json_object(const char* const buffer, int len){
	const char* str = buffer;
	json_object_handle ret = malloc(sizeof(struct json_object));
	if(NULL == ret){
		return NULL;
	}
	memset(ret , 0 , sizeof(struct json_object));
	for(;NULL != str && len > 0 ;++str,--len){
		str = pass_json_item(&ret->items[ret->item_counts++],str,len);
		len = strlen(str);
	}
	if(NULL == str){
		hint("parse buffer failed:%s\n",buffer);
		free(ret);
		return NULL;
	}
	return ret;
}
const char*  get_object_value(json_object_handle h, const char* const name){
	int i = 0;
	if(NULL == h){
		return NULL;
	}
	for(; i < h->item_counts;++i){
		if(0 == strcmp(name,h->items[i].name)){
			return h->items[i].value;
		}
	}
	return NULL;
}
void desdroy_json_object(json_object_handle h){
	free(h);
}
struct json_array{
	int item_counts;
	char items[json_item_counts][json_value_len];
};

static const char*const pass_array_item(char* dst,const char* str){
	int len = strlen(str);
	for(;' ' == *str && len > 0; --len,++str){
		;
	}
	switch(*str){
	case '{' : return get_json_object(dst,str,len);
	case '[' : return get_json_array(dst,str,len);
	default  : return get_json_value(dst,str,len);
	}
}


json_array_handle create_json_array(const char* const buffer, int len){
	const char* str = buffer;
	json_array_handle ret = malloc(sizeof(struct json_array));
	if(NULL == ret){
		hint("alloc failed\n");
		return NULL;
	}
	memset(ret , 0 , sizeof(struct json_array));
	for(;' ' == *str && len > 0; --len,++str){
		;
	}
	++str;
	for(;']' != *str && len > 0; ){
		str = pass_array_item(ret->items[ret->item_counts++],str);
		len = strlen(str);
	}
	return ret;
}


const char*  get_array_value(json_array_handle h, int index){
	if(NULL == h){
		return NULL;
	}
	if(index > h->item_counts){
		return NULL;
	}
	return h->items[index];
}


void destroy_json_array(json_array_handle h){
	free(h);
}

#ifdef test_debug
static const char*const json_str1="{\"command\":123,\"parament\":[{\"u_name\":'aaa',\"pass\":'123456'}],\"client_context\":\\\"aaa\\\",\"server_context\":3321}";
int main(int argn,char* argv[]){
	json_object_handle jh = create_json_object(json_str1,strlen(json_str1));
	json_object_handle jh2 = NULL;
	json_array_handle jah = NULL;
	const char* json_a_str = NULL;
	const char* json_str2 = NULL;
	printf("%s\n",json_str1);
	if(NULL == jh){
		return -1;
	}
	printf("command:%s\n",get_object_value(jh,"command"));
	printf("parament:%s\n",get_object_value(jh,"parament"));
	printf("client_context:%s\n",get_object_value(jh,"client_context"));
	printf("server_context:%s\n",get_object_value(jh,"server_context"));
	json_a_str = get_object_value(jh,"parament");
	jah = create_json_array(json_a_str,strlen(json_a_str));
	if(NULL == jah){
		hint("create array failed:%s\n",json_a_str);
		return -2;
	}
	json_str2 = get_array_value(jah,0);
	if(NULL == json_str2){
		hint("get array 0 failed\n");
		return -3;
	}
	jh2 = create_json_object(json_str2,strlen(json_str2));
	printf("u_name:%s\n",get_object_value(jh2,"u_name"));
	printf("pass:%s\n",get_object_value(jh2,"pass"));
	desdroy_json_object(jh2);
	desdroy_json_object(jh);
	destroy_json_array(jah);
	return 0;
}
#endif