[fio.git] / json.c

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <stdarg.h>
#include "json.h"
#include "log.h"

struct json_object *json_create_object(void)
{
	struct json_object *obj = malloc(sizeof(struct json_object));
	if (obj)
		memset(obj, 0, sizeof(struct json_object));
	return obj;
}

struct json_array *json_create_array(void)
{
	struct json_array *array = malloc(sizeof(struct json_array));
	if (array)
		memset(array, 0, sizeof(struct json_array));
	return array;
}

static struct json_pair *json_create_pair(const char *name, struct json_value *value)
{
	struct json_pair *pair = malloc(sizeof(struct json_pair));
	if (pair) {
		pair->name = strdup(name);
		pair->value = value;

		value->parent_type = JSON_PARENT_TYPE_PAIR;
		value->parent_pair = pair;
	}
	return pair;
}

static struct json_value *json_create_value_int(long number)
{
	struct json_value *value = malloc(sizeof(struct json_value));

	if (value) {
		value->type = JSON_TYPE_INTEGER;
		value->integer_number = number;
	}
	return value;
}

static struct json_value *json_create_value_float(float number)
{
	struct json_value *value = malloc(sizeof(struct json_value));

	if (value) {
		value->type = JSON_TYPE_FLOAT;
		value->float_number = number;
	}
	return value;
}

static struct json_value *json_create_value_string(const char *str)
{
	struct json_value *value = malloc(sizeof(struct json_value));

	if (value) {
		value->type = JSON_TYPE_STRING;
		value->string = strdup(str);
		if (!value->string) {
			free(value);
			value = NULL;
		}
	}
	return value;
}

static struct json_value *json_create_value_object(struct json_object *obj)
{
	struct json_value *value = malloc(sizeof(struct json_value));

	if (value) {
		value->type = JSON_TYPE_OBJECT;
		value->object = obj;
		obj->parent = value;
	}
	return value;
}

static struct json_value *json_create_value_array(struct json_array *array)
{
	struct json_value *value = malloc(sizeof(struct json_value));

	if (value) {
		value->type = JSON_TYPE_ARRAY;
		value->array = array;
		array->parent = value;
	}
	return value;
}

static void json_free_pair(struct json_pair *pair);
static void json_free_value(struct json_value *value);

void json_free_object(struct json_object *obj)
{
	int i;

	for (i = 0; i < obj->pair_cnt; i++)
		json_free_pair(obj->pairs[i]);
	free(obj->pairs);
	free(obj);
}

static void json_free_array(struct json_array *array)
{
	int i;

	for (i = 0; i < array->value_cnt; i++)
		json_free_value(array->values[i]);
	free(array->values);
	free(array);
}

static void json_free_pair(struct json_pair *pair)
{
	json_free_value(pair->value);
	free(pair->name);
	free(pair);
}

static void json_free_value(struct json_value *value)
{
	switch (value->type) {
	case JSON_TYPE_STRING:
		free(value->string);
		break;
	case JSON_TYPE_OBJECT:
		json_free_object(value->object);
		break;
	case JSON_TYPE_ARRAY:
		json_free_array(value->array);
		break;
	}
	free(value);
}

static int json_array_add_value(struct json_array *array, struct json_value *value)
{
	struct json_value **values = realloc(array->values,
		sizeof(struct json_value *) * (array->value_cnt + 1));

	if (!values)
		return ENOMEM;
	values[array->value_cnt] = value;
	array->value_cnt++;
	array->values = values;

	value->parent_type = JSON_PARENT_TYPE_ARRAY;
	value->parent_array = array;
	return 0;
}

static int json_object_add_pair(struct json_object *obj, struct json_pair *pair)
{
	struct json_pair **pairs = realloc(obj->pairs,
		sizeof(struct json_pair *) * (obj->pair_cnt + 1));
	if (!pairs)
		return ENOMEM;
	pairs[obj->pair_cnt] = pair;
	obj->pair_cnt++;
	obj->pairs = pairs;

	pair->parent = obj;
	return 0;
}

int json_object_add_value_type(struct json_object *obj, const char *name, int type, ...)
{
	struct json_value *value;
	struct json_pair *pair;
	va_list args;
	int ret;

	va_start(args, type);
	if (type == JSON_TYPE_STRING)
		value = json_create_value_string(va_arg(args, char *));
	else if (type == JSON_TYPE_INTEGER)
		value = json_create_value_int(va_arg(args, long));
	else if (type == JSON_TYPE_FLOAT)
		value = json_create_value_float(va_arg(args, double));
	else if (type == JSON_TYPE_OBJECT)
		value = json_create_value_object(va_arg(args, struct json_object *));
	else
		value = json_create_value_array(va_arg(args, struct json_array *));
	va_end(args);

	if (!value)
		return ENOMEM;

	pair = json_create_pair(name, value);
	if (!pair) {
		json_free_value(value);
		return ENOMEM;
	}
	ret = json_object_add_pair(obj, pair);
	if (ret) {
		json_free_pair(pair);
		return ENOMEM;
	}
	return 0;
}

static void json_print_array(struct json_array *array);
int json_array_add_value_type(struct json_array *array, int type, ...)
{
	struct json_value *value;
	va_list args;
	int ret;

	va_start(args, type);
	if (type == JSON_TYPE_STRING)
		value = json_create_value_string(va_arg(args, char *));
	else if (type == JSON_TYPE_INTEGER)
		value = json_create_value_int(va_arg(args, long));
	else if (type == JSON_TYPE_FLOAT)
		value = json_create_value_float(va_arg(args, double));
	else if (type == JSON_TYPE_OBJECT)
		value = json_create_value_object(va_arg(args, struct json_object *));
	else
		value = json_create_value_array(va_arg(args, struct json_array *));
	va_end(args);

	if (!value)
		return ENOMEM;

	ret = json_array_add_value(array, value);
	if (ret) {
		json_free_value(value);
		return ENOMEM;
	}
	return 0;
}

static int json_value_level(struct json_value *value);
static int json_pair_level(struct json_pair *pair);
static int json_array_level(struct json_array *array);
static int json_object_level(struct json_object *object)
{
	if (object->parent == NULL)
		return 0;
	return json_value_level(object->parent);
}

static int json_pair_level(struct json_pair *pair)
{
	return json_object_level(pair->parent) + 1;
}

static int json_array_level(struct json_array *array)
{
	return json_value_level(array->parent);
}

static int json_value_level(struct json_value *value)
{
	if (value->parent_type == JSON_PARENT_TYPE_PAIR)
		return json_pair_level(value->parent_pair);
	else
		return json_array_level(value->parent_array) + 1;
}

static void json_print_level(int level)
{
	while (level-- > 0)
		log_info("  ");
}

static void json_print_pair(struct json_pair *pair);
static void json_print_array(struct json_array *array);
static void json_print_value(struct json_value *value);
void json_print_object(struct json_object *obj)
{
	int i;

	log_info("{\n");
	for (i = 0; i < obj->pair_cnt; i++) {
		if (i > 0)
			log_info(",\n");
		json_print_pair(obj->pairs[i]);
	}
	log_info("\n");
	json_print_level(json_object_level(obj));
	log_info("}");
}

static void json_print_pair(struct json_pair *pair)
{
	json_print_level(json_pair_level(pair));
	log_info("\"%s\" : ", pair->name);
	json_print_value(pair->value);
}

static void json_print_array(struct json_array *array)
{
	int i;

	log_info("[\n");
	for (i = 0; i < array->value_cnt; i++) {
		if (i > 0)
			log_info(",\n");
		json_print_level(json_value_level(array->values[i]));
		json_print_value(array->values[i]);
	}
	log_info("\n");
	json_print_level(json_array_level(array));
	log_info("]");
}

static void json_print_value(struct json_value *value)
{
	switch (value->type) {
	case JSON_TYPE_STRING:
		log_info("\"%s\"", value->string);
		break;
	case JSON_TYPE_INTEGER:
		log_info("%ld", value->integer_number);
		break;
	case JSON_TYPE_FLOAT:
		log_info("%.2f", value->float_number);
		break;
	case JSON_TYPE_OBJECT:
		json_print_object(value->object);
		break;
	case JSON_TYPE_ARRAY:
		json_print_array(value->array);
		break;
	}
}
Commit	Line	Data
cc372b17 SL	1	#include <stdlib.h>
	2	#include <string.h>
	3	#include <stdio.h>
	4	#include <errno.h>
	5	#include <stdarg.h>
	6	#include "json.h"
	7	#include "log.h"
	8
	9	struct json_object *json_create_object(void)
	10	{
	11	struct json_object *obj = malloc(sizeof(struct json_object));
	12	if (obj)
	13	memset(obj, 0, sizeof(struct json_object));
	14	return obj;
	15	}
	16
	17	struct json_array *json_create_array(void)
	18	{
	19	struct json_array *array = malloc(sizeof(struct json_array));
	20	if (array)
	21	memset(array, 0, sizeof(struct json_array));
	22	return array;
	23	}
	24
	25	static struct json_pair json_create_pair(const char name, struct json_value *value)
	26	{
	27	struct json_pair *pair = malloc(sizeof(struct json_pair));
	28	if (pair) {
	29	pair->name = strdup(name);
	30	pair->value = value;
	31
	32	value->parent_type = JSON_PARENT_TYPE_PAIR;
	33	value->parent_pair = pair;
	34	}
	35	return pair;
	36	}
	37
	38	static struct json_value *json_create_value_int(long number)
	39	{
	40	struct json_value *value = malloc(sizeof(struct json_value));
	41
	42	if (value) {
	43	value->type = JSON_TYPE_INTEGER;
	44	value->integer_number = number;
	45	}
	46	return value;
	47	}
	48
	49	static struct json_value *json_create_value_float(float number)
	50	{
	51	struct json_value *value = malloc(sizeof(struct json_value));
	52
	53	if (value) {
	54	value->type = JSON_TYPE_FLOAT;
	55	value->float_number = number;
	56	}
	57	return value;
	58	}
	59
	60	static struct json_value json_create_value_string(const char str)
	61	{
	62	struct json_value *value = malloc(sizeof(struct json_value));
	63
	64	if (value) {
65	value->type = JSON_TYPE_STRING;
66	value->string = strdup(str);
67	if (!value->string) {
68	free(value);
69	value = NULL;
70	}
71	}
72	return value;
73	}
74
75	static struct json_value json_create_value_object(struct json_object obj)
76	{
77	struct json_value *value = malloc(sizeof(struct json_value));
78
79	if (value) {
80	value->type = JSON_TYPE_OBJECT;
81	value->object = obj;
82	obj->parent = value;
83	}
84	return value;
85	}
86
87	static struct json_value json_create_value_array(struct json_array array)
88	{
89	struct json_value *value = malloc(sizeof(struct json_value));
90
91	if (value) {
92	value->type = JSON_TYPE_ARRAY;
93	value->array = array;
94	array->parent = value;
95	}
96	return value;
97	}
98
cc372b17 SL	99	static void json_free_pair(struct json_pair *pair);
cc372b17 SL	100	static void json_free_value(struct json_value *value);
f3afa57e	101
cc372b17 SL	102	void json_free_object(struct json_object *obj)
	103	{
	104	int i;
	105
	106	for (i = 0; i < obj->pair_cnt; i++)
	107	json_free_pair(obj->pairs[i]);
	108	free(obj->pairs);
	109	free(obj);
	110	}
	111
	112	static void json_free_array(struct json_array *array)
	113	{
	114	int i;
	115
	116	for (i = 0; i < array->value_cnt; i++)
	117	json_free_value(array->values[i]);
	118	free(array->values);
	119	free(array);
	120	}
	121
	122	static void json_free_pair(struct json_pair *pair)
	123	{
	124	json_free_value(pair->value);
	125	free(pair->name);
	126	free(pair);
	127	}
	128
	129	static void json_free_value(struct json_value *value)
	130	{
	131	switch (value->type) {
	132	case JSON_TYPE_STRING:
	133	free(value->string);
	134	break;
	135	case JSON_TYPE_OBJECT:
	136	json_free_object(value->object);
	137	break;
	138	case JSON_TYPE_ARRAY:
	139	json_free_array(value->array);
	140	break;
	141	}
	142	free(value);
	143	}
	144
	145	static int json_array_add_value(struct json_array array, struct json_value value)
	146	{
	147	struct json_value **values = realloc(array->values,
	148	sizeof(struct json_value ) (array->value_cnt + 1));
	149
	150	if (!values)
	151	return ENOMEM;
	152	values[array->value_cnt] = value;
	153	array->value_cnt++;
	154	array->values = values;
	155
	156	value->parent_type = JSON_PARENT_TYPE_ARRAY;
	157	value->parent_array = array;
	158	return 0;
	159	}
	160
	161	static int json_object_add_pair(struct json_object obj, struct json_pair pair)
	162	{
	163	struct json_pair **pairs = realloc(obj->pairs,
	164	sizeof(struct json_pair ) (obj->pair_cnt + 1));
	165	if (!pairs)
166	return ENOMEM;
167	pairs[obj->pair_cnt] = pair;
168	obj->pair_cnt++;
169	obj->pairs = pairs;
170
171	pair->parent = obj;
172	return 0;
173	}
174
175	int json_object_add_value_type(struct json_object obj, const char name, int type, ...)
176	{
177	struct json_value *value;
178	struct json_pair *pair;
179	va_list args;
180	int ret;
181
182	va_start(args, type);
183	if (type == JSON_TYPE_STRING)
184	value = json_create_value_string(va_arg(args, char *));
185	else if (type == JSON_TYPE_INTEGER)
186	value = json_create_value_int(va_arg(args, long));
187	else if (type == JSON_TYPE_FLOAT)
188	value = json_create_value_float(va_arg(args, double));
189	else if (type == JSON_TYPE_OBJECT)
190	value = json_create_value_object(va_arg(args, struct json_object *));
191	else
192	value = json_create_value_array(va_arg(args, struct json_array *));
193	va_end(args);
194
195	if (!value)
196	return ENOMEM;
197
198	pair = json_create_pair(name, value);
199	if (!pair) {
200	json_free_value(value);
201	return ENOMEM;
202	}
203	ret = json_object_add_pair(obj, pair);
204	if (ret) {
205	json_free_pair(pair);
206	return ENOMEM;
207	}
208	return 0;
209	}
210
211	static void json_print_array(struct json_array *array);
212	int json_array_add_value_type(struct json_array *array, int type, ...)
213	{
214	struct json_value *value;
215	va_list args;
216	int ret;
217
218	va_start(args, type);
219	if (type == JSON_TYPE_STRING)
220	value = json_create_value_string(va_arg(args, char *));
221	else if (type == JSON_TYPE_INTEGER)
222	value = json_create_value_int(va_arg(args, long));
223	else if (type == JSON_TYPE_FLOAT)
224	value = json_create_value_float(va_arg(args, double));
225	else if (type == JSON_TYPE_OBJECT)
226	value = json_create_value_object(va_arg(args, struct json_object *));
227	else
228	value = json_create_value_array(va_arg(args, struct json_array *));
229	va_end(args);
230
231	if (!value)
232	return ENOMEM;
233
234	ret = json_array_add_value(array, value);
235	if (ret) {
236	json_free_value(value);
237	return ENOMEM;
238	}
239	return 0;
240	}
241
242	static int json_value_level(struct json_value *value);
243	static int json_pair_level(struct json_pair *pair);
244	static int json_array_level(struct json_array *array);
245	static int json_object_level(struct json_object *object)
246	{
247	if (object->parent == NULL)
248	return 0;
249	return json_value_level(object->parent);
250	}
251
252	static int json_pair_level(struct json_pair *pair)
253	{
254	return json_object_level(pair->parent) + 1;
255	}
256
257	static int json_array_level(struct json_array *array)
258	{
259	return json_value_level(array->parent);
260	}
261
262	static int json_value_level(struct json_value *value)
263	{
264	if (value->parent_type == JSON_PARENT_TYPE_PAIR)
265	return json_pair_level(value->parent_pair);
266	else
267	return json_array_level(value->parent_array) + 1;
268	}
269
270	static void json_print_level(int level)
271	{
272	while (level-- > 0)
273	log_info(" ");
274	}
275
276	static void json_print_pair(struct json_pair *pair);
277	static void json_print_array(struct json_array *array);
278	static void json_print_value(struct json_value *value);
279	void json_print_object(struct json_object *obj)
280	{
281	int i;
282
283	log_info("{\n");
284	for (i = 0; i < obj->pair_cnt; i++) {
285	if (i > 0)
286	log_info(",\n");
287	json_print_pair(obj->pairs[i]);
288	}
289	log_info("\n");
290	json_print_level(json_object_level(obj));
291	log_info("}");
292	}
293
294	static void json_print_pair(struct json_pair *pair)
295	{
296	json_print_level(json_pair_level(pair));
297	log_info("\"%s\" : ", pair->name);
298	json_print_value(pair->value);
299	}
300
301	static void json_print_array(struct json_array *array)
302	{
303	int i;
304
305	log_info("[\n");
306	for (i = 0; i < array->value_cnt; i++) {
307	if (i > 0)
308	log_info(",\n");
309	json_print_level(json_value_level(array->values[i]));
310	json_print_value(array->values[i]);
311	}
312	log_info("\n");
313	json_print_level(json_array_level(array));
314	log_info("]");
315	}
316
317	static void json_print_value(struct json_value *value)
318	{
319	switch (value->type) {
320	case JSON_TYPE_STRING:
321	log_info("\"%s\"", value->string);
322	break;
323	case JSON_TYPE_INTEGER:
324	log_info("%ld", value->integer_number);
325	break;
326	case JSON_TYPE_FLOAT:
327	log_info("%.2f", value->float_number);
328	break;
329	case JSON_TYPE_OBJECT:
330	json_print_object(value->object);
331	break;
332	case JSON_TYPE_ARRAY:
333	json_print_array(value->array);
334	break;
335	}
336	}