Utility functions for udp / json-parser

Recently, I needed a json parser for a small C project, and -after googling- found this great library udp / json-parser.

It is great, because it does what it says and it’s really low-footprint.

Soon I realized that I needed two things for my project: a) modifying a string on the json and b) dumping an already parsed json to a file. So, probably json-parser was not the right choice for my project and since I don’t have time to change it now, I decided to implement these functions myself.

Feel free to use, modify or fix as you need.

Disclaimer: note that this code is not 100% ANSI C (specially the json_dump_file function), since my project will only run on Windows you might find crazy things like TCHAR, etc… but it shouldn’t be that difficult to make it ANSI.

/**
 * Adds a key / value pair to an existing json_object node
 * @param  settings	pointer to settings
 * @param  obj		the parent object to add the key / value
 * @param  name		the key
 * @param  val		the value
 */
void json_add_object_value_ex (json_settings * settings, json_value * obj, json_char * name, json_value * val)
{
	unsigned int i, values_size;
	json_value *values;

	if (obj->type != json_object) {
		// unexpected type!
		return;
	}
	// check if the value already exists
	for (i = 0; i < obj->u.object.length; i++) {
		if (!strcmp(obj->u.object.values[i].name, name)) {
			// in this case just need to change the value
			json_value_free_ex (settings, obj->u.object.values[i].value);
			obj->u.object.values[i].value = val;
			val->parent = obj;
			return;
		}
	}
	// need to realloc the object values array
	// increment array length
	obj->u.object.length++;
	values_size = obj->u.object.length * sizeof (*obj->u.object.values);
	values = (json_value *)settings->mem_alloc(values_size, 0, settings->user_data);
	memcpy(values, obj->u.object.values, (obj->u.object.length - 1) * sizeof (*obj->u.object.values));
	*(void **)obj->u.object.values = &values;
	// set the name and value on the last element of the array
	obj->u.object.values[obj->u.object.length-1].name = (json_char *) settings->mem_alloc(sizeof(json_char) * strlen(name), 0, settings->user_data);
	strcpy_s(obj->u.object.values[obj->u.object.length-1].name, sizeof(json_char) * strlen(name), name);
	obj->u.object.values[obj->u.object.length-1].value = val;
	val->parent = obj;
}

/**
 * Shortcut to json_add_object_value_ex using default memory allocation functions
 */
void json_add_object_value (json_value * obj, json_char * name, json_value * val)
{
	json_settings settings = { 0 };
	memset(&settings, '\0', sizeof(json_settings));
	settings.mem_free = default_free;
	settings.mem_alloc = default_alloc;
	json_add_object_value_ex (&settings, obj, name, val);
}

/**
 * Allocate a json_string
 * @param  settings	pointer to settings
 * @param  string	the string to allocate
 * @return a json_value of type json_string with the string on it
 */
json_value * json_alloc_string_ex (json_settings * settings, json_char * string)
{
	json_value * val;
	int len = strlen(string);

	val = (json_value *)settings->mem_alloc(sizeof(json_value), 0, settings->user_data);
	val->type = json_string;
	val->u.string.length = len;
	val->u.string.ptr = (json_char *)settings->mem_alloc(len + 1, 0, settings->user_data);
	strcpy_s(val->u.string.ptr, len + 1, string);
	return val;
}

/**
 * Shortcut to json_alloc_string_ex using default memory allocation functions
 */
json_value * json_alloc_string (json_char * string)
{
	json_settings settings = { 0 };
	memset(&settings, '\0', sizeof(json_settings));
	settings.mem_free = default_free;
	settings.mem_alloc = default_alloc;
	return json_alloc_string_ex (&settings, string);
}

static void json_dump_escaped(FILE *f, char *buf, size_t len)
{
	size_t	i;

	for (i=0; i < len; i++) {
		switch(*buf) {
		case '\\': fprintf(f, "%s", "\\\\"); break;
		case '"':  fprintf(f, "%s", "\\\""); break;
		case '/':  fprintf(f, "%s", "\\/"); break;
		case '\b': fprintf(f, "%s", "\\b"); break;
		case '\f': fprintf(f, "%s", "\\f"); break;
		case '\n': fprintf(f, "%s", "\\n"); break;
		case '\r': fprintf(f, "%s", "\\r"); break;
		case '\t': fprintf(f, "%s", "\\t"); break;
		default: fputc(*buf, f); break;
		}
		buf++;
	}
}

static void json_dump_helper(FILE *f, json_value *v, int prettyprint, unsigned int level)
{
	unsigned int		i, j;

	switch(v->type) {
	case json_object:
		fputc('{', f);
		if (prettyprint) {
			if (v->u.object.length > 0) fprintf(f, "\n");
		}
		for (i=0; i < v->u.object.length; i++) {
			for(j=0; j < level; j++) fputc('\t', f);
			if (prettyprint) fputc('\t', f);
			fputc('"', f);
			json_dump_escaped(f, v->u.object.values[i].name, strlen(v->u.object.values[i].name));
			fprintf(f, "\":%s", (prettyprint) ? " "  : "");
			json_dump_helper(f, v->u.object.values[i].value, prettyprint, level + 1);
			if (i < (v->u.object.length - 1)) {
				fputc(',', f);
				if (prettyprint) fputc('\n', f);
			}
		}
		if (prettyprint) {
			fputc('\n', f);
			for(j=0; j < level; j++) fputc('\t', f);
		}
		fputc('}', f);
		break;
	case json_array:
		fputc('[', f);
		for (i=0; i < v->u.array.length; i++) {
			json_dump_helper(f, v->u.array.values[i], prettyprint, level + 1);
			if (i < (v->u.array.length - 1)) {
				fputc(',', f);
				if (prettyprint) fputc(' ', f);
			}
		}
		fputc(']', f);
		break;
	case json_integer:
		fprintf(f, "%lld", v->u.integer);
		break;
	case json_double:
		fprintf(f, "%f", v->u.dbl);
		break;
	case json_string:
		fputc('"', f);
		json_dump_escaped(f, v->u.string.ptr, v->u.string.length);
		fputc('"', f);
		break;
	case json_boolean:
		fprintf(f, "%s", (v->u.boolean) ? "true" : "false");
		break;
	case json_null:
		fprintf(f, "null");
		break;
	}
}

/**
 * Dumps a json object into a file
 */
int json_dump_file(TCHAR *fname, json_value *json, int prettyprint)
{
	FILE		*f;
	errno_t		rt = _tfopen_s(&f, fname, _T("wb+"));

	if (!rt) {
		json_dump_helper(f, json, prettyprint, 0);
		fclose(f);
		return 0;
	}
	return 1;
}