Index: lib/Makefile
===================================================================
--- lib/Makefile	(revision 73f0a012a1f6b3e5fa3c7905e4f216b5ac29a30c)
+++ lib/Makefile	(revision b75671d9ac15f883ddb0103e5fa33c6186c32f37)
@@ -13,5 +13,5 @@
 
 # [SH] Program variables
-objects = arc.o base64.o $(EVENT_HANDLER) ftutil.o http_client.o ini.o json.o json_util.o md5.o misc.o oauth.o oauth2.o proxy.o sha1.o $(SSL_CLIENT) url.o xmltree.o ns_parse.o
+objects = arc.o base64.o $(EVENT_HANDLER) ftutil.o http_client.o ini.o md5.o misc.o oauth.o oauth2.o parson.o proxy.o sha1.o $(SSL_CLIENT) url.o xmltree.o ns_parse.o
 
 LFLAGS += -r
Index: lib/json.c
===================================================================
--- lib/json.c	(revision 73f0a012a1f6b3e5fa3c7905e4f216b5ac29a30c)
+++ 	(revision )
@@ -1,972 +1,0 @@
-/* vim: set et ts=3 sw=3 sts=3 ft=c:
- *
- * Copyright (C) 2012, 2013, 2014 James McLaughlin et al.  All rights reserved.
- * https://github.com/udp/json-parser
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- *   notice, this list of conditions and the following disclaimer in the
- *   documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <glib.h>
-
-#include "json.h"
-
-#ifdef _MSC_VER
-   #ifndef _CRT_SECURE_NO_WARNINGS
-      #define _CRT_SECURE_NO_WARNINGS
-   #endif
-#endif
-
-#ifdef __cplusplus
-const struct _json_value json_value_none;    /* zero-d by ctor */
-#else
-const struct _json_value json_value_none = { 0 };
-#endif
-
-#include <stdio.h>
-#include <string.h>
-#include <ctype.h>
-#include <math.h>
-
-typedef unsigned int json_uchar;
-
-static unsigned char hex_value(json_char c)
-{
-	if (g_ascii_isdigit(c)) {
-		return c - '0';
-	}
-
-	switch (c) {
-	case 'a': case 'A': return 0x0A;
-	case 'b': case 'B': return 0x0B;
-	case 'c': case 'C': return 0x0C;
-	case 'd': case 'D': return 0x0D;
-	case 'e': case 'E': return 0x0E;
-	case 'f': case 'F': return 0x0F;
-	default: return 0xFF;
-	}
-}
-
-typedef struct {
-	unsigned long used_memory;
-
-	unsigned int uint_max;
-	unsigned long ulong_max;
-
-	json_settings settings;
-	int first_pass;
-
-} json_state;
-
-static void * default_alloc(size_t size, int zero, void * user_data)
-{
-	return zero ? calloc(1, size) : malloc(size);
-}
-
-static void default_free(void * ptr, void * user_data)
-{
-	free(ptr);
-}
-
-static void * json_alloc(json_state * state, unsigned long size, int zero)
-{
-	if ((state->ulong_max - state->used_memory) < size) {
-		return 0;
-	}
-
-	if (state->settings.max_memory
-	    && (state->used_memory += size) > state->settings.max_memory) {
-		return 0;
-	}
-
-	return state->settings.mem_alloc(size, zero, state->settings.user_data);
-}
-
-static int new_value
-        (json_state * state, json_value ** top, json_value ** root, json_value ** alloc, json_type type)
-{
-	json_value * value;
-	int values_size;
-
-	if (!state->first_pass) {
-		value = *top = *alloc;
-		*alloc = (*alloc)->_reserved.next_alloc;
-
-		if (!*root) {
-			*root = value;
-		}
-
-		switch (value->type) {
-		case json_array:
-
-			if (!(value->u.array.values = (json_value **) json_alloc
-			                                      (state, value->u.array.length * sizeof(json_value *),
-			                                      0))) {
-				return 0;
-			}
-
-			value->u.array.length = 0;
-			break;
-
-		case json_object:
-
-			values_size = sizeof(*value->u.object.values) * value->u.object.length;
-
-			if (!((*(void **) &value->u.object.values) = json_alloc
-			                                                     (state, values_size +
-			                                                     ((unsigned long) value->u.object.values),
-			                                                     0))) {
-				return 0;
-			}
-
-			value->_reserved.object_mem = (*(char **) &value->u.object.values) + values_size;
-
-			value->u.object.length = 0;
-			break;
-
-		case json_string:
-
-			if (!(value->u.string.ptr = (json_char *) json_alloc
-			                                    (state, (value->u.string.length + 1) * sizeof(json_char),
-			                                    0))) {
-				return 0;
-			}
-
-			value->u.string.length = 0;
-			break;
-
-		default:
-			break;
-		}
-		;
-
-		return 1;
-	}
-
-	value = (json_value *) json_alloc(state, sizeof(json_value), 1);
-
-	if (!value) {
-		return 0;
-	}
-
-	if (!*root) {
-		*root = value;
-	}
-
-	value->type = type;
-	value->parent = *top;
-
-	if (*alloc) {
-		(*alloc)->_reserved.next_alloc = value;
-	}
-
-	*alloc = *top = value;
-
-	return 1;
-}
-
-#define e_off \
-	((int) (i - cur_line_begin))
-
-#define whitespace \
-case '\n': ++cur_line;  cur_line_begin = i; \
-case ' ': case '\t': case '\r'
-
-#define string_add(b)  \
-	do { if (!state.first_pass) { string [string_length] = b; } ++string_length; } while (0);
-
-static const long
-        flag_next             = 1 << 0,
-        flag_reproc           = 1 << 1,
-        flag_need_comma       = 1 << 2,
-        flag_seek_value       = 1 << 3,
-        flag_escaped          = 1 << 4,
-        flag_string           = 1 << 5,
-        flag_need_colon       = 1 << 6,
-        flag_done             = 1 << 7,
-        flag_num_negative     = 1 << 8,
-        flag_num_zero         = 1 << 9,
-        flag_num_e            = 1 << 10,
-        flag_num_e_got_sign   = 1 << 11,
-        flag_num_e_negative   = 1 << 12,
-        flag_line_comment     = 1 << 13,
-        flag_block_comment    = 1 << 14;
-
-json_value * json_parse_ex(json_settings * settings,
-                           const json_char * json,
-                           size_t length,
-                           char * error_buf)
-{
-	json_char error [json_error_max];
-	unsigned int cur_line;
-	const json_char * cur_line_begin, * i, * end;
-	json_value * top, * root, * alloc = 0;
-	json_state state = { 0 };
-	long flags;
-	long num_digits = 0, num_e = 0;
-	json_int_t num_fraction = 0;
-
-	/* Skip UTF-8 BOM
-	 */
-	if (length >= 3 && ((unsigned char) json [0]) == 0xEF
-	    && ((unsigned char) json [1]) == 0xBB
-	    && ((unsigned char) json [2]) == 0xBF) {
-		json += 3;
-		length -= 3;
-	}
-
-	error[0] = '\0';
-	end = (json + length);
-
-	memcpy(&state.settings, settings, sizeof(json_settings));
-
-	if (!state.settings.mem_alloc) {
-		state.settings.mem_alloc = default_alloc;
-	}
-
-	if (!state.settings.mem_free) {
-		state.settings.mem_free = default_free;
-	}
-
-	memset(&state.uint_max, 0xFF, sizeof(state.uint_max));
-	memset(&state.ulong_max, 0xFF, sizeof(state.ulong_max));
-
-	state.uint_max -= 8; /* limit of how much can be added before next check */
-	state.ulong_max -= 8;
-
-	for (state.first_pass = 1; state.first_pass >= 0; --state.first_pass) {
-		json_uchar uchar;
-		unsigned char uc_b1, uc_b2, uc_b3, uc_b4;
-		json_char * string = 0;
-		unsigned int string_length = 0;
-
-		top = root = 0;
-		flags = flag_seek_value;
-
-		cur_line = 1;
-		cur_line_begin = json;
-
-		for (i = json;; ++i) {
-			json_char b = (i == end ? 0 : *i);
-
-			if (flags & flag_string) {
-				if (!b) {
-					sprintf(error, "Unexpected EOF in string (at %d:%d)", cur_line, e_off);
-					goto e_failed;
-				}
-
-				if (string_length > state.uint_max) {
-					goto e_overflow;
-				}
-
-				if (flags & flag_escaped) {
-					flags &= ~flag_escaped;
-
-					switch (b) {
-					case 'b':  string_add('\b');  break;
-					case 'f':  string_add('\f');  break;
-					case 'n':  string_add('\n');  break;
-					case 'r':  string_add('\r');  break;
-					case 't':  string_add('\t');  break;
-					case 'u':
-
-						if (end - i < 4 ||
-						    (uc_b1 = hex_value(*++i)) == 0xFF || (uc_b2 = hex_value(*++i)) ==
-						    0xFF
-						    || (uc_b3 = hex_value(*++i)) == 0xFF || (uc_b4 = hex_value(*++i)) ==
-						    0xFF) {
-							sprintf(error, "Invalid character value `%c` (at %d:%d)", b,
-							        cur_line, e_off);
-							goto e_failed;
-						}
-
-						uc_b1 = (uc_b1 << 4) | uc_b2;
-						uc_b2 = (uc_b3 << 4) | uc_b4;
-						uchar = (uc_b1 << 8) | uc_b2;
-
-						if ((uchar & 0xF800) == 0xD800) {
-							json_uchar uchar2;
-
-							if (end - i < 6 || (*++i) != '\\' || (*++i) != 'u' ||
-							    (uc_b1 = hex_value(*++i)) == 0xFF ||
-							    (uc_b2 = hex_value(*++i)) == 0xFF
-							    || (uc_b3 = hex_value(*++i)) == 0xFF ||
-							    (uc_b4 = hex_value(*++i)) == 0xFF) {
-								sprintf(error,
-								        "Invalid character value `%c` (at %d:%d)", b,
-								        cur_line, e_off);
-								goto e_failed;
-							}
-
-							uc_b1 = (uc_b1 << 4) | uc_b2;
-							uc_b2 = (uc_b3 << 4) | uc_b4;
-							uchar2 = (uc_b1 << 8) | uc_b2;
-
-							uchar = 0x010000 | ((uchar & 0x3FF) << 10) | (uchar2 & 0x3FF);
-						}
-
-						if (sizeof(json_char) >= sizeof(json_uchar) || (uchar <= 0x7F)) {
-							string_add((json_char) uchar);
-							break;
-						}
-
-						if (uchar <= 0x7FF) {
-							if (state.first_pass) {
-								string_length += 2;
-							} else {                    string [string_length++] = 0xC0 |
-								                                               (uchar >>
-								                                                6);
-								                    string [string_length++] = 0x80 |
-								                                               (uchar &
-								                                                0x3F); }
-
-							break;
-						}
-
-						if (uchar <= 0xFFFF) {
-							if (state.first_pass) {
-								string_length += 3;
-							} else {                    string [string_length++] = 0xE0 |
-								                                               (uchar >>
-								                                                12);
-								                    string [string_length++] = 0x80 |
-								                                               ((uchar
-								                                                 >> 6) &
-								                                                0x3F);
-								                    string [string_length++] = 0x80 |
-								                                               (uchar &
-								                                                0x3F); }
-
-							break;
-						}
-
-						if (state.first_pass) {
-							string_length += 4;
-						} else {                string [string_length++] = 0xF0 | (uchar >> 18);
-							                string [string_length++] = 0x80 |
-							                                           ((uchar >>
-							                                             12) & 0x3F);
-							                string [string_length++] = 0x80 |
-							                                           ((uchar >>
-							                                             6) & 0x3F);
-							                string [string_length++] = 0x80 |
-							                                           (uchar & 0x3F); }
-
-						break;
-
-					default:
-						string_add(b);
-					}
-					;
-
-					continue;
-				}
-
-				if (b == '\\') {
-					flags |= flag_escaped;
-					continue;
-				}
-
-				if (b == '"') {
-					if (!state.first_pass) {
-						string [string_length] = 0;
-					}
-
-					flags &= ~flag_string;
-					string = 0;
-
-					switch (top->type) {
-					case json_string:
-
-						top->u.string.length = string_length;
-						flags |= flag_next;
-
-						break;
-
-					case json_object:
-
-						if (state.first_pass) {
-							(*(json_char **) &top->u.object.values) += string_length + 1;
-						} else {
-							top->u.object.values [top->u.object.length].name
-							        = (json_char *) top->_reserved.object_mem;
-
-							top->u.object.values [top->u.object.length].name_length
-							        = string_length;
-
-							(*(json_char **) &top->_reserved.object_mem) += string_length +
-							                                                1;
-						}
-
-						flags |= flag_seek_value | flag_need_colon;
-						continue;
-
-					default:
-						break;
-					}
-					;
-				} else {
-					string_add(b);
-					continue;
-				}
-			}
-
-			if (state.settings.settings & json_enable_comments) {
-				if (flags & (flag_line_comment | flag_block_comment)) {
-					if (flags & flag_line_comment) {
-						if (b == '\r' || b == '\n' || !b) {
-							flags &= ~flag_line_comment;
-							--i; /* so null can be reproc'd */
-						}
-
-						continue;
-					}
-
-					if (flags & flag_block_comment) {
-						if (!b) {
-							sprintf(error, "%d:%d: Unexpected EOF in block comment",
-							        cur_line, e_off);
-							goto e_failed;
-						}
-
-						if (b == '*' && i < (end - 1) && i [1] == '/') {
-							flags &= ~flag_block_comment;
-							++i; /* skip closing sequence */
-						}
-
-						continue;
-					}
-				} else if (b == '/') {
-					if (!(flags & (flag_seek_value | flag_done)) && top->type != json_object) {
-						sprintf(error, "%d:%d: Comment not allowed here", cur_line, e_off);
-						goto e_failed;
-					}
-
-					if (++i == end) {
-						sprintf(error, "%d:%d: EOF unexpected", cur_line, e_off);
-						goto e_failed;
-					}
-
-					switch (b = *i) {
-					case '/':
-						flags |= flag_line_comment;
-						continue;
-
-					case '*':
-						flags |= flag_block_comment;
-						continue;
-
-					default:
-						sprintf(error, "%d:%d: Unexpected `%c` in comment opening sequence",
-						        cur_line, e_off, b);
-						goto e_failed;
-					}
-					;
-				}
-			}
-
-			if (flags & flag_done) {
-				if (!b) {
-					break;
-				}
-
-				switch (b) {
-whitespace:
-					continue;
-
-				default:
-					sprintf(error, "%d:%d: Trailing garbage: `%c`", cur_line, e_off, b);
-					goto e_failed;
-				}
-				;
-			}
-
-			if (flags & flag_seek_value) {
-				switch (b) {
-whitespace:
-					continue;
-
-				case ']':
-
-					if (top->type == json_array) {
-						flags = (flags & ~(flag_need_comma | flag_seek_value)) | flag_next;
-					} else {              sprintf(error, "%d:%d: Unexpected ]", cur_line, e_off);
-						              goto e_failed; }
-
-					break;
-
-				default:
-
-					if (flags & flag_need_comma) {
-						if (b == ',') {
-							flags &= ~flag_need_comma;
-							continue;
-						} else { sprintf(error, "%d:%d: Expected , before %c", cur_line, e_off,
-							         b);
-							 goto e_failed; }
-					}
-
-					if (flags & flag_need_colon) {
-						if (b == ':') {
-							flags &= ~flag_need_colon;
-							continue;
-						} else { sprintf(error, "%d:%d: Expected : before %c", cur_line, e_off,
-							         b);
-							 goto e_failed; }
-					}
-
-					flags &= ~flag_seek_value;
-
-					switch (b) {
-					case '{':
-
-						if (!new_value(&state, &top, &root, &alloc, json_object)) {
-							goto e_alloc_failure;
-						}
-
-						continue;
-
-					case '[':
-
-						if (!new_value(&state, &top, &root, &alloc, json_array)) {
-							goto e_alloc_failure;
-						}
-
-						flags |= flag_seek_value;
-						continue;
-
-					case '"':
-
-						if (!new_value(&state, &top, &root, &alloc, json_string)) {
-							goto e_alloc_failure;
-						}
-
-						flags |= flag_string;
-
-						string = top->u.string.ptr;
-						string_length = 0;
-
-						continue;
-
-					case 't':
-
-						if ((end - i) < 3 || *(++i) != 'r' || *(++i) != 'u' || *(++i) != 'e') {
-							goto e_unknown_value;
-						}
-
-						if (!new_value(&state, &top, &root, &alloc, json_boolean)) {
-							goto e_alloc_failure;
-						}
-
-						top->u.boolean = 1;
-
-						flags |= flag_next;
-						break;
-
-					case 'f':
-
-						if ((end - i) < 4 || *(++i) != 'a' || *(++i) != 'l' || *(++i) != 's' ||
-						    *(++i) != 'e') {
-							goto e_unknown_value;
-						}
-
-						if (!new_value(&state, &top, &root, &alloc, json_boolean)) {
-							goto e_alloc_failure;
-						}
-
-						flags |= flag_next;
-						break;
-
-					case 'n':
-
-						if ((end - i) < 3 || *(++i) != 'u' || *(++i) != 'l' || *(++i) != 'l') {
-							goto e_unknown_value;
-						}
-
-						if (!new_value(&state, &top, &root, &alloc, json_null)) {
-							goto e_alloc_failure;
-						}
-
-						flags |= flag_next;
-						break;
-
-					default:
-
-						if (g_ascii_isdigit(b) || b == '-') {
-							if (!new_value(&state, &top, &root, &alloc, json_integer)) {
-								goto e_alloc_failure;
-							}
-
-							if (!state.first_pass) {
-								while (g_ascii_isdigit(b) || b == '+' || b == '-'
-								       || b == 'e' || b == 'E' || b == '.') {
-									if ((++i) == end) {
-										b = 0;
-										break;
-									}
-
-									b = *i;
-								}
-
-								flags |= flag_next | flag_reproc;
-								break;
-							}
-
-							flags &= ~(flag_num_negative | flag_num_e |
-							           flag_num_e_got_sign | flag_num_e_negative |
-							           flag_num_zero);
-
-							num_digits = 0;
-							num_fraction = 0;
-							num_e = 0;
-
-							if (b != '-') {
-								flags |= flag_reproc;
-								break;
-							}
-
-							flags |= flag_num_negative;
-							continue;
-						} else { sprintf(error, "%d:%d: Unexpected %c when seeking value",
-							         cur_line, e_off, b);
-							 goto e_failed; }
-					}
-					;
-				}
-				;
-			} else {
-				switch (top->type) {
-				case json_object:
-
-					switch (b) {
-whitespace:
-						continue;
-
-					case '"':
-
-						if (flags & flag_need_comma) {
-							sprintf(error, "%d:%d: Expected , before \"", cur_line, e_off);
-							goto e_failed;
-						}
-
-						flags |= flag_string;
-
-						string = (json_char *) top->_reserved.object_mem;
-						string_length = 0;
-
-						break;
-
-					case '}':
-
-						flags = (flags & ~flag_need_comma) | flag_next;
-						break;
-
-					case ',':
-
-						if (flags & flag_need_comma) {
-							flags &= ~flag_need_comma;
-							break;
-						}
-
-					default:
-
-						sprintf(error, "%d:%d: Unexpected `%c` in object", cur_line, e_off, b);
-						goto e_failed;
-					}
-					;
-
-					break;
-
-				case json_integer:
-				case json_double:
-
-					if (g_ascii_isdigit(b)) {
-						++num_digits;
-
-						if (top->type == json_integer || flags & flag_num_e) {
-							if (!(flags & flag_num_e)) {
-								if (flags & flag_num_zero) {
-									sprintf(error,
-									        "%d:%d: Unexpected `0` before `%c`",
-									        cur_line, e_off, b);
-									goto e_failed;
-								}
-
-								if (num_digits == 1 && b == '0') {
-									flags |= flag_num_zero;
-								}
-							} else {
-								flags |= flag_num_e_got_sign;
-								num_e = (num_e * 10) + (b - '0');
-								continue;
-							}
-
-							top->u.integer = (top->u.integer * 10) + (b - '0');
-							continue;
-						}
-
-						num_fraction = (num_fraction * 10) + (b - '0');
-						continue;
-					}
-
-					if (b == '+' || b == '-') {
-						if ((flags & flag_num_e) && !(flags & flag_num_e_got_sign)) {
-							flags |= flag_num_e_got_sign;
-
-							if (b == '-') {
-								flags |= flag_num_e_negative;
-							}
-
-							continue;
-						}
-					} else if (b == '.' && top->type == json_integer) {
-						if (!num_digits) {
-							sprintf(error, "%d:%d: Expected digit before `.`", cur_line,
-							        e_off);
-							goto e_failed;
-						}
-
-						top->type = json_double;
-						top->u.dbl = (double) top->u.integer;
-
-						num_digits = 0;
-						continue;
-					}
-
-					if (!(flags & flag_num_e)) {
-						if (top->type == json_double) {
-							if (!num_digits) {
-								sprintf(error, "%d:%d: Expected digit after `.`",
-								        cur_line, e_off);
-								goto e_failed;
-							}
-
-							top->u.dbl += ((double) num_fraction) /
-							              (pow(10, (double) num_digits));
-						}
-
-						if (b == 'e' || b == 'E') {
-							flags |= flag_num_e;
-
-							if (top->type == json_integer) {
-								top->type = json_double;
-								top->u.dbl = (double) top->u.integer;
-							}
-
-							num_digits = 0;
-							flags &= ~flag_num_zero;
-
-							continue;
-						}
-					} else {
-						if (!num_digits) {
-							sprintf(error, "%d:%d: Expected digit after `e`", cur_line,
-							        e_off);
-							goto e_failed;
-						}
-
-						top->u.dbl *=
-						        pow(10,
-						            (double) (flags & flag_num_e_negative ? -num_e : num_e));
-					}
-
-					if (flags & flag_num_negative) {
-						if (top->type == json_integer) {
-							top->u.integer = -top->u.integer;
-						} else {
-							top->u.dbl = -top->u.dbl;
-						}
-					}
-
-					flags |= flag_next | flag_reproc;
-					break;
-
-				default:
-					break;
-				}
-				;
-			}
-
-			if (flags & flag_reproc) {
-				flags &= ~flag_reproc;
-				--i;
-			}
-
-			if (flags & flag_next) {
-				flags = (flags & ~flag_next) | flag_need_comma;
-
-				if (!top->parent) {
-					/* root value done */
-
-					flags |= flag_done;
-					continue;
-				}
-
-				if (top->parent->type == json_array) {
-					flags |= flag_seek_value;
-				}
-
-				if (!state.first_pass) {
-					json_value * parent = top->parent;
-
-					switch (parent->type) {
-					case json_object:
-
-						parent->u.object.values
-						[parent->u.object.length].value = top;
-
-						break;
-
-					case json_array:
-
-						parent->u.array.values
-						[parent->u.array.length] = top;
-
-						break;
-
-					default:
-						break;
-					}
-					;
-				}
-
-				if ((++top->parent->u.array.length) > state.uint_max) {
-					goto e_overflow;
-				}
-
-				top = top->parent;
-
-				continue;
-			}
-		}
-
-		alloc = root;
-	}
-
-	return root;
-
-e_unknown_value:
-
-	sprintf(error, "%d:%d: Unknown value", cur_line, e_off);
-	goto e_failed;
-
-e_alloc_failure:
-
-	strcpy(error, "Memory allocation failure");
-	goto e_failed;
-
-e_overflow:
-
-	sprintf(error, "%d:%d: Too long (caught overflow)", cur_line, e_off);
-	goto e_failed;
-
-e_failed:
-
-	if (error_buf) {
-		if (*error) {
-			strcpy(error_buf, error);
-		} else {
-			strcpy(error_buf, "Unknown error");
-		}
-	}
-
-	if (state.first_pass) {
-		alloc = root;
-	}
-
-	while (alloc) {
-		top = alloc->_reserved.next_alloc;
-		state.settings.mem_free(alloc, state.settings.user_data);
-		alloc = top;
-	}
-
-	if (!state.first_pass) {
-		json_value_free_ex(&state.settings, root);
-	}
-
-	return 0;
-}
-
-json_value * json_parse(const json_char * json, size_t length)
-{
-	json_settings settings = { 0 };
-
-	return json_parse_ex(&settings, json, length, 0);
-}
-
-void json_value_free_ex(json_settings * settings, json_value * value)
-{
-	json_value * cur_value;
-
-	if (!value) {
-		return;
-	}
-
-	value->parent = 0;
-
-	while (value) {
-		switch (value->type) {
-		case json_array:
-
-			if (!value->u.array.length) {
-				settings->mem_free(value->u.array.values, settings->user_data);
-				break;
-			}
-
-			value = value->u.array.values [--value->u.array.length];
-			continue;
-
-		case json_object:
-
-			if (!value->u.object.length) {
-				settings->mem_free(value->u.object.values, settings->user_data);
-				break;
-			}
-
-			value = value->u.object.values [--value->u.object.length].value;
-			continue;
-
-		case json_string:
-
-			settings->mem_free(value->u.string.ptr, settings->user_data);
-			break;
-
-		default:
-			break;
-		}
-		;
-
-		cur_value = value;
-		value = value->parent;
-		settings->mem_free(cur_value, settings->user_data);
-	}
-}
-
-void json_value_free(json_value * value)
-{
-	json_settings settings = { 0 };
-
-	settings.mem_free = default_free;
-	json_value_free_ex(&settings, value);
-}
-
Index: lib/json.h
===================================================================
--- lib/json.h	(revision 73f0a012a1f6b3e5fa3c7905e4f216b5ac29a30c)
+++ 	(revision )
@@ -1,262 +1,0 @@
-
-/* vim: set et ts=3 sw=3 sts=3 ft=c:
- *
- * Copyright (C) 2012, 2013, 2014 James McLaughlin et al.  All rights reserved.
- * https://github.com/udp/json-parser
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- *   notice, this list of conditions and the following disclaimer in the
- *   documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#ifndef _JSON_H
-#define _JSON_H
-
-#ifndef json_char
-   #define json_char char
-#endif
-
-#ifndef json_int_t
-   #ifndef _MSC_VER
-      #include <inttypes.h>
-      #define json_int_t int64_t
-   #else
-      #define json_int_t __int64
-   #endif
-#endif
-
-#include <stdlib.h>
-
-#ifdef __cplusplus
-
-   #include <string.h>
-
-extern "C"
-{
-
-#endif
-
-typedef struct {
-	unsigned long max_memory;
-	int settings;
-
-	/* Custom allocator support (leave null to use malloc/free)
-	 */
-
-	void * (*mem_alloc)(size_t, int zero, void * user_data);
-	void (* mem_free)(void *, void * user_data);
-
-	void * user_data; /* will be passed to mem_alloc and mem_free */
-
-} json_settings;
-
-#define json_enable_comments  0x01
-
-typedef enum {
-	json_none,
-	json_object,
-	json_array,
-	json_integer,
-	json_double,
-	json_string,
-	json_boolean,
-	json_null
-
-} json_type;
-
-extern const struct _json_value json_value_none;
-
-typedef struct _json_value {
-	struct _json_value * parent;
-
-	json_type type;
-
-	union {
-		int boolean;
-		json_int_t integer;
-		double dbl;
-
-		struct {
-			unsigned int length;
-			json_char * ptr; /* null terminated */
-
-		} string;
-
-		struct {
-			unsigned int length;
-
-			struct {
-				json_char * name;
-				unsigned int name_length;
-
-				struct _json_value * value;
-
-			} * values;
-
-	 #if defined(__cplusplus) && __cplusplus >= 201103L
-			decltype(values) begin() const
-			{  return values; }
-			decltype(values) end() const
-			{  return values + length; }
-	 #endif
-
-		} object;
-
-		struct {
-			unsigned int length;
-			struct _json_value ** values;
-
-	 #if defined(__cplusplus) && __cplusplus >= 201103L
-			decltype(values) begin() const
-			{  return values; }
-			decltype(values) end() const
-			{  return values + length; }
-	 #endif
-
-		} array;
-
-	} u;
-
-	union {
-		struct _json_value * next_alloc;
-		void * object_mem;
-
-	} _reserved;
-
-
-	/* Some C++ operator sugar */
-
-   #ifdef __cplusplus
-
-public:
-
-	inline _json_value ()
-	{
-		memset(this, 0, sizeof(_json_value));
-	}
-
-	inline const struct _json_value &operator [](int index) const
-	{
-		if (type != json_array || index < 0
-		    || ((unsigned int)index) >= u.array.length) {
-			return json_value_none;
-		}
-
-		return *u.array.values [index];
-	}
-
-	inline const struct _json_value &operator [](const char * index) const
-	{
-		if (type != json_object) {
-			return json_value_none;
-		}
-
-		for (unsigned int i = 0; i < u.object.length; ++i) {
-			if (!strcmp(u.object.values [i].name, index)) {
-				return *u.object.values [i].value;
-			}
-		}
-
-		return json_value_none;
-	}
-
-	inline operator const char *() const
-	{
-		switch (type) {
-		case json_string:
-			return u.string.ptr;
-
-		default:
-			return "";
-		}
-		;
-	}
-
-	inline operator json_int_t() const
-	{
-		switch (type) {
-		case json_integer:
-			return u.integer;
-
-		case json_double:
-			return (json_int_t)u.dbl;
-
-		default:
-			return 0;
-		}
-		;
-	}
-
-	inline operator bool() const
-	{
-		if (type != json_boolean) {
-			return false;
-		}
-
-		return u.boolean != 0;
-	}
-
-	inline operator double() const
-	{
-		switch (type) {
-		case json_integer:
-			return (double)u.integer;
-
-		case json_double:
-			return u.dbl;
-
-		default:
-			return 0;
-		}
-		;
-	}
-
-   #endif
-
-} json_value;
-
-json_value * json_parse(const json_char * json,
-                        size_t length);
-
-#define json_error_max 128
-json_value * json_parse_ex(json_settings * settings,
-                           const json_char * json,
-                           size_t length,
-                           char * error);
-
-void json_value_free(json_value *);
-
-
-/* Not usually necessary, unless you used a custom mem_alloc and now want to
- * use a custom mem_free.
- */
-void json_value_free_ex(json_settings * settings,
-                        json_value *);
-
-
-#ifdef __cplusplus
-}    /* extern "C" */
-#endif
-
-#endif
-
-
Index: lib/json_util.c
===================================================================
--- lib/json_util.c	(revision 73f0a012a1f6b3e5fa3c7905e4f216b5ac29a30c)
+++ 	(revision )
@@ -1,67 +1,0 @@
-/***************************************************************************\
-*                                                                           *
-*  BitlBee - An IRC to IM gateway                                           *
-*  Helper functions for json.c                                              *
-*                                                                           *
-*  Copyright 2012-2012 Wilmer van der Gaast <wilmer@gaast.net>              *
-*                                                                           *
-*  This program is free software; you can redistribute it and/or modify     *
-*  it under the terms of the GNU General Public License as published by     *
-*  the Free Software Foundation; either version 2 of the License, or        *
-*  (at your option) any later version.                                      *
-*                                                                           *
-*  This program is distributed in the hope that it will be useful,          *
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *
-*  GNU General Public License for more details.                             *
-*                                                                           *
-*  You should have received a copy of the GNU General Public License along  *
-*  with this program; if not, write to the Free Software Foundation, Inc.,  *
-*  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.              *
-*                                                                           *
-****************************************************************************/
-
-#include <stdlib.h>
-#include <string.h>
-#include <glib.h>
-
-#include "json_util.h"
-
-json_value *json_o_get(const json_value *obj, const json_char *name)
-{
-	int i;
-
-	if (!obj || obj->type != json_object) {
-		return NULL;
-	}
-
-	for (i = 0; i < obj->u.object.length; ++i) {
-		if (strcmp(obj->u.object.values[i].name, name) == 0) {
-			return obj->u.object.values[i].value;
-		}
-	}
-
-	return NULL;
-}
-
-const char *json_o_str(const json_value *obj, const json_char *name)
-{
-	json_value *ret = json_o_get(obj, name);
-
-	if (ret && ret->type == json_string) {
-		return ret->u.string.ptr;
-	} else {
-		return NULL;
-	}
-}
-
-char *json_o_strdup(const json_value *obj, const json_char *name)
-{
-	json_value *ret = json_o_get(obj, name);
-
-	if (ret && ret->type == json_string && ret->u.string.ptr) {
-		return g_memdup(ret->u.string.ptr, ret->u.string.length + 1);
-	} else {
-		return NULL;
-	}
-}
Index: lib/json_util.h
===================================================================
--- lib/json_util.h	(revision 73f0a012a1f6b3e5fa3c7905e4f216b5ac29a30c)
+++ 	(revision )
@@ -1,35 +1,0 @@
-/***************************************************************************\
-*                                                                           *
-*  BitlBee - An IRC to IM gateway                                           *
-*  Helper functions for json.c                                              *
-*                                                                           *
-*  Copyright 2012-2012 Wilmer van der Gaast <wilmer@gaast.net>              *
-*                                                                           *
-*  This program is free software; you can redistribute it and/or modify     *
-*  it under the terms of the GNU General Public License as published by     *
-*  the Free Software Foundation; either version 2 of the License, or        *
-*  (at your option) any later version.                                      *
-*                                                                           *
-*  This program is distributed in the hope that it will be useful,          *
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *
-*  GNU General Public License for more details.                             *
-*                                                                           *
-*  You should have received a copy of the GNU General Public License along  *
-*  with this program; if not, write to the Free Software Foundation, Inc.,  *
-*  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.              *
-*                                                                           *
-****************************************************************************/
-
-#include "json.h"
-
-#define JSON_O_FOREACH(o, k, v) \
-	char *k; json_value *v; int __i; \
-	for (__i = 0; (__i < (o)->u.object.length) && \
-	     (k = (o)->u.object.values[__i].name) && \
-	     (v = (o)->u.object.values[__i].value); \
-	     __i ++)
-
-json_value *json_o_get(const json_value *obj, const json_char *name);
-const char *json_o_str(const json_value *obj, const json_char *name);
-char *json_o_strdup(const json_value *obj, const json_char *name);
Index: lib/misc.c
===================================================================
--- lib/misc.c	(revision 73f0a012a1f6b3e5fa3c7905e4f216b5ac29a30c)
+++ lib/misc.c	(revision b75671d9ac15f883ddb0103e5fa33c6186c32f37)
@@ -427,5 +427,5 @@
 }
 
-int is_bool(char *value)
+int is_bool(const char *value)
 {
 	if (*value == 0) {
@@ -453,5 +453,5 @@
 }
 
-int bool2int(char *value)
+int bool2int(const char *value)
 {
 	int i;
Index: lib/misc.h
===================================================================
--- lib/misc.h	(revision 73f0a012a1f6b3e5fa3c7905e4f216b5ac29a30c)
+++ lib/misc.h	(revision b75671d9ac15f883ddb0103e5fa33c6186c32f37)
@@ -137,6 +137,6 @@
 G_MODULE_EXPORT void random_bytes(unsigned char *buf, int count);
 
-G_MODULE_EXPORT int is_bool(char *value);
-G_MODULE_EXPORT int bool2int(char *value);
+G_MODULE_EXPORT int is_bool(const char *value);
+G_MODULE_EXPORT int bool2int(const char *value);
 
 G_MODULE_EXPORT struct ns_srv_reply **srv_lookup(char *service, char *protocol, char *domain);
Index: lib/oauth2.c
===================================================================
--- lib/oauth2.c	(revision 73f0a012a1f6b3e5fa3c7905e4f216b5ac29a30c)
+++ lib/oauth2.c	(revision b75671d9ac15f883ddb0103e5fa33c6186c32f37)
@@ -42,7 +42,10 @@
 #include "oauth2.h"
 #include "oauth.h"
-#include "json.h"
-#include "json_util.h"
+#include "parson.h"
 #include "url.h"
+
+#define JSON_O_FOREACH(o, k, v) \
+    const char *k; const JSON_Value *v; int __i; \
+    for (__i = 0; json_object_get_tuple(o, __i, &k, &v); __i++)
 
 char *oauth2_url(const struct oauth2_service *sp)
@@ -113,23 +116,18 @@
 }
 
-static char* oauth2_parse_error(json_value *e)
+static char* oauth2_parse_error(const JSON_Value *e)
 {
 	/* This does a reasonable job with some of the flavours of error
 	   responses I've seen. Because apparently it's not standardised. */
 
-	if (e->type == json_object) {
+	if (json_type(e) == JSONObject) {
 		/* Facebook style */
-		const char *msg = json_o_str(e, "message");
-		const char *type = json_o_str(e, "type");
-		json_value *code_o = json_o_get(e, "code");
-		int code = 0;
-
-		if (code_o && code_o->type == json_integer) {
-			code = code_o->u.integer;
-		}
-
+		const char *msg = json_object_get_string(json_object(e), "message");
+		const char *type = json_object_get_string(json_object(e), "type");
+		JSON_Value *code_o = json_object_get_value(json_object(e), "code");
+		int code = json_value_get_integer(code_o);
 		return g_strdup_printf("Error %d: %s", code, msg ? msg : type ? type : "Unknown error");
-	} else if (e->type == json_string) {
-		return g_strdup(e->u.string.ptr);
+	} else if (json_type(e) == JSONString) {
+		return g_strdup(json_string(e));
 	}
 	return NULL;
@@ -156,18 +154,18 @@
 	if (content_type && (strstr(content_type, "application/json") ||
 	                     strstr(content_type, "text/javascript"))) {
-		json_value *js = json_parse(req->reply_body, req->body_size);
-		if (js && js->type == json_object) {
-			JSON_O_FOREACH(js, k, v){
+		JSON_Value *js = json_parse_string(req->reply_body);
+		if (js && json_type(js) == JSONObject) {
+			JSON_O_FOREACH(json_object(js), k, v){
 				if (strcmp(k, "error") == 0) {
 					error = oauth2_parse_error(v);
 				}
-				if (v->type != json_string) {
+				if (json_type(v) != JSONString) {
 					continue;
 				}
 				if (strcmp(k, "access_token") == 0) {
-					atoken = g_strdup(v->u.string.ptr);
+					atoken = g_strdup(json_string(v));
 				}
 				if (strcmp(k, "refresh_token") == 0) {
-					rtoken = g_strdup(v->u.string.ptr);
+					rtoken = g_strdup(json_string(v));
 				}
 			}
Index: lib/parson.c
===================================================================
--- lib/parson.c	(revision b75671d9ac15f883ddb0103e5fa33c6186c32f37)
+++ lib/parson.c	(revision b75671d9ac15f883ddb0103e5fa33c6186c32f37)
@@ -0,0 +1,1771 @@
+/*
+ Parson ( http://kgabis.github.com/parson/ )
+ Copyright (c) 2012 - 2014 Krzysztof Gabis
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+*/
+#ifdef _MSC_VER
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "parson.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+
+#define STARTING_CAPACITY         15
+#define ARRAY_MAX_CAPACITY    122880 /* 15*(2^13) */
+#define OBJECT_MAX_CAPACITY      960 /* 15*(2^6)  */
+#define MAX_NESTING               19
+#define DOUBLE_SERIALIZATION_FORMAT "%f"
+#define JINT_SERIALIZATION_FORMAT "%lld"
+
+#define SIZEOF_TOKEN(a)       (sizeof(a) - 1)
+#define SKIP_CHAR(str)        ((*str)++)
+#define SKIP_WHITESPACES(str) while (isspace(**str)) { SKIP_CHAR(str); }
+#define MAX(a, b)             ((a) > (b) ? (a) : (b))
+
+#define PARSON_MALLOC(a)     malloc(a)
+#define PARSON_FREE(a)       free((void*)(a))
+#define PARSON_REALLOC(a, b) realloc((a), (b))
+
+#define PRINT_AND_SKIP(str, to_append) str += sprintf(str, to_append);
+#define PRINTF_AND_SKIP(str, format, to_append) str += sprintf(str, format, to_append);
+
+#define IS_CONT(b) (((unsigned char)(b) & 0xC0) == 0x80) /* is utf-8 continuation byte */
+
+/* Type definitions */
+typedef union json_value_value {
+    const char  *string;
+    double       number;
+    jint         integer;
+    JSON_Object *object;
+    JSON_Array  *array;
+    int          boolean;
+    int          null;
+} JSON_Value_Value;
+
+struct json_value_t {
+    JSON_Value_Type     type;
+    JSON_Value_Value    value;
+};
+
+struct json_object_t {
+    const char **names;
+    JSON_Value **values;
+    size_t       count;
+    size_t       capacity;
+};
+
+struct json_array_t {
+    JSON_Value **items;
+    size_t       count;
+    size_t       capacity;
+};
+
+/* Various */
+static char * read_file(const char *filename);
+static void   remove_comments(char *string, const char *start_token, const char *end_token);
+static int    try_realloc(void **ptr, size_t new_size);
+static char * parson_strndup(const char *string, size_t n);
+static char * parson_strdup(const char *string);
+static int    is_utf16_hex(const unsigned char *string);
+static int    num_bytes_in_utf8_sequence(unsigned char c);
+static int    verify_utf8_sequence(const unsigned char *string, int *len);
+static int    is_valid_utf8(const char *string, size_t string_len);
+static int    is_decimal(const char *string, size_t length);
+static size_t serialization_strlen(const char *string);
+
+/* JSON Object */
+static JSON_Object * json_object_init(void);
+static JSON_Status   json_object_add(JSON_Object *object, const char *name, JSON_Value *value);
+static JSON_Status   json_object_resize(JSON_Object *object, size_t capacity);
+static JSON_Value  * json_object_nget_value(const JSON_Object *object, const char *name, size_t n);
+static void          json_object_free(JSON_Object *object);
+
+/* JSON Array */
+static JSON_Array * json_array_init(void);
+static JSON_Status  json_array_add(JSON_Array *array, JSON_Value *value);
+static JSON_Status  json_array_resize(JSON_Array *array, size_t capacity);
+static void         json_array_free(JSON_Array *array);
+
+/* JSON Value */
+static JSON_Value * json_value_init_string_no_copy(const char *string);
+
+/* Parser */
+static void         skip_quotes(const char **string);
+static int          parse_utf_16(const char **unprocessed, char **processed);
+static char*        process_string(const char *input, size_t len);
+static const char * get_quoted_string(const char **string);
+static JSON_Value * parse_object_value(const char **string, size_t nesting);
+static JSON_Value * parse_array_value(const char **string, size_t nesting);
+static JSON_Value * parse_string_value(const char **string);
+static JSON_Value * parse_boolean_value(const char **string);
+static JSON_Value * parse_number_value(const char **string);
+static JSON_Value * parse_null_value(const char **string);
+static JSON_Value * parse_value(const char **string, size_t nesting);
+
+/* Serialization */
+static size_t json_serialization_size_r(const JSON_Value *value, char *buf);
+static char * json_serialize_to_buffer_r(const JSON_Value *value, char *buf);
+static char * json_serialize_string(const char *string, char *buf);
+
+/* Various */
+static int try_realloc(void **ptr, size_t new_size) {
+    void *reallocated_ptr = NULL;
+    if (new_size == 0) {
+        return JSONFailure;
+    }
+    reallocated_ptr = PARSON_REALLOC(*ptr, new_size);
+    if (reallocated_ptr == NULL) {
+        return JSONFailure;
+    }
+    *ptr = reallocated_ptr;
+    return JSONSuccess;
+}
+
+static char * parson_strndup(const char *string, size_t n) {
+    char *output_string = (char*)PARSON_MALLOC(n + 1);
+    if (!output_string)
+        return NULL;
+    output_string[n] = '\0';
+    strncpy(output_string, string, n);
+    return output_string;
+}
+
+static char * parson_strdup(const char *string) {
+    return parson_strndup(string, strlen(string));
+}
+
+static int is_utf16_hex(const unsigned char *s) {
+    return isxdigit(s[0]) && isxdigit(s[1]) && isxdigit(s[2]) && isxdigit(s[3]);
+}
+
+static int num_bytes_in_utf8_sequence(unsigned char c) {
+    if (c == 0xC0 || c == 0xC1 || c > 0xF4 || IS_CONT(c)) {
+        return 0;
+    } else if ((c & 0x80) == 0) {    /* 0xxxxxxx */
+        return 1;
+    } else if ((c & 0xE0) == 0xC0) { /* 110xxxxx */
+        return 2;
+    } else if ((c & 0xF0) == 0xE0) { /* 1110xxxx */
+        return 3;
+    } else if ((c & 0xF8) == 0xF0) { /* 11110xxx */
+        return 4;
+    }
+    return 0; /* won't happen */
+}
+
+static int verify_utf8_sequence(const unsigned char *string, int *len) {
+    unsigned int cp = 0;
+    *len = num_bytes_in_utf8_sequence(string[0]);
+    
+    if (*len == 1) {
+        cp = string[0];
+    } else if (*len == 2 && IS_CONT(string[1])) {
+        cp = string[0] & 0x1F;
+        cp = (cp << 6) | (string[1] & 0x3F);
+    } else if (*len == 3 && IS_CONT(string[1]) && IS_CONT(string[2])) {
+        cp = ((unsigned char)string[0]) & 0xF;
+        cp = (cp << 6) | (string[1] & 0x3F);
+        cp = (cp << 6) | (string[2] & 0x3F);
+    } else if (*len == 4 && IS_CONT(string[1]) && IS_CONT(string[2]) && IS_CONT(string[3])) {
+        cp = string[0] & 0x7;
+        cp = (cp << 6) | (string[1] & 0x3F);
+        cp = (cp << 6) | (string[2] & 0x3F);
+        cp = (cp << 6) | (string[3] & 0x3F);
+    } else {
+        return 0;
+    }
+    
+    /* overlong encodings */
+    if ((cp < 0x80    && *len > 1) ||
+        (cp < 0x800   && *len > 2) ||
+        (cp < 0x10000 && *len > 3)) {
+        return 0;
+    }
+    
+    /* invalid unicode */
+    if (cp > 0x10FFFF) {
+        return 0;
+    }
+    
+    /* surrogate halves */
+    if (cp >= 0xD800 && cp <= 0xDFFF) {
+        return 0;
+    }
+    
+    return 1;
+}
+
+static int is_valid_utf8(const char *string, size_t string_len) {
+    int len = 0;
+    const char *string_end =  string + string_len;
+    while (string < string_end) {
+        if (!verify_utf8_sequence((const unsigned char*)string, &len)) {
+            return 0;
+        }
+        string += len;
+    }
+    return 1;
+}
+
+static int is_decimal(const char *string, size_t length) {
+    if (length > 1 && string[0] == '0' && string[1] != '.')
+        return 0;
+    if (length > 2 && !strncmp(string, "-0", 2) && string[2] != '.')
+        return 0;
+    while (length--)
+        if (strchr("xX", string[length]))
+            return 0;
+    return 1;
+}
+
+static size_t serialization_strlen(const char *string) {
+    size_t result = 0;
+    size_t i = 0, len = strlen(string);
+    for (i = 0; i < len; i++) {
+        if (strchr("\"\\\b\f\n\r\t", string[i])) /* must be escaped */
+            result += 2;
+        else
+            result += 1;
+    }
+    return result;
+}
+
+static char * read_file(const char * filename) {
+    FILE *fp = fopen(filename, "r");
+    size_t file_size;
+    long pos;
+    char *file_contents;
+    if (!fp)
+        return NULL;
+    fseek(fp, 0L, SEEK_END);
+    pos = ftell(fp);
+    if (pos < 0) {
+        fclose(fp);
+        return NULL;
+    }
+    file_size = pos;
+    rewind(fp);
+    file_contents = (char*)PARSON_MALLOC(sizeof(char) * (file_size + 1));
+    if (!file_contents) {
+        fclose(fp);
+        return NULL;
+    }
+    if (fread(file_contents, file_size, 1, fp) < 1) {
+        if (ferror(fp)) {
+            fclose(fp);
+            PARSON_FREE(file_contents);
+            return NULL;
+        }
+    }
+    fclose(fp);
+    file_contents[file_size] = '\0';
+    return file_contents;
+}
+
+static void remove_comments(char *string, const char *start_token, const char *end_token) {
+    int in_string = 0, escaped = 0;
+    size_t i;
+    char *ptr = NULL, current_char;
+    size_t start_token_len = strlen(start_token);
+    size_t end_token_len = strlen(end_token);
+    if (start_token_len == 0 || end_token_len == 0)
+    	return;
+    while ((current_char = *string) != '\0') {
+        if (current_char == '\\' && !escaped) {
+            escaped = 1;
+            string++;
+            continue;
+        } else if (current_char == '\"' && !escaped) {
+            in_string = !in_string;
+        } else if (!in_string && strncmp(string, start_token, start_token_len) == 0) {
+			for(i = 0; i < start_token_len; i++)
+                string[i] = ' ';
+        	string = string + start_token_len;
+            ptr = strstr(string, end_token);
+            if (!ptr)
+                return;
+            for (i = 0; i < (ptr - string) + end_token_len; i++)
+                string[i] = ' ';
+          	string = ptr + end_token_len - 1;
+        }
+        escaped = 0;
+        string++;
+    }
+}
+
+/* JSON Object */
+static JSON_Object * json_object_init(void) {
+    JSON_Object *new_obj = (JSON_Object*)PARSON_MALLOC(sizeof(JSON_Object));
+    if (!new_obj)
+        return NULL;
+    new_obj->names = (const char**)NULL;
+    new_obj->values = (JSON_Value**)NULL;
+    new_obj->capacity = 0;
+    new_obj->count = 0;
+    return new_obj;
+}
+
+static JSON_Status json_object_add(JSON_Object *object, const char *name, JSON_Value *value) {
+    size_t index = 0;
+    if (object == NULL || name == NULL || value == NULL) {
+        return JSONFailure;
+    }
+    if (object->count >= object->capacity) {
+        size_t new_capacity = MAX(object->capacity * 2, STARTING_CAPACITY);
+        if (new_capacity > OBJECT_MAX_CAPACITY)
+            return JSONFailure;
+        if (json_object_resize(object, new_capacity) == JSONFailure)
+            return JSONFailure;
+    }
+    if (json_object_get_value(object, name) != NULL)
+        return JSONFailure;
+    index = object->count;
+    object->names[index] = parson_strdup(name);
+    if (object->names[index] == NULL)
+        return JSONFailure;
+    object->values[index] = value;
+    object->count++;
+    return JSONSuccess;
+}
+
+static JSON_Status json_object_resize(JSON_Object *object, size_t capacity) {
+    if (try_realloc((void**)&object->names, capacity * sizeof(char*)) == JSONFailure)
+        return JSONFailure;
+    if (try_realloc((void**)&object->values, capacity * sizeof(JSON_Value*)) == JSONFailure)
+        return JSONFailure;
+    object->capacity = capacity;
+    return JSONSuccess;
+}
+
+static JSON_Value * json_object_nget_value(const JSON_Object *object, const char *name, size_t n) {
+    size_t i, name_length;
+    for (i = 0; i < json_object_get_count(object); i++) {
+        name_length = strlen(object->names[i]);
+        if (name_length != n)
+            continue;
+        if (strncmp(object->names[i], name, n) == 0)
+            return object->values[i];
+    }
+    return NULL;
+}
+
+static void json_object_free(JSON_Object *object) {
+    while(object->count--) {
+        PARSON_FREE(object->names[object->count]);
+        json_value_free(object->values[object->count]);
+    }
+    PARSON_FREE(object->names);
+    PARSON_FREE(object->values);
+    PARSON_FREE(object);
+}
+
+/* JSON Array */
+static JSON_Array * json_array_init(void) {
+    JSON_Array *new_array = (JSON_Array*)PARSON_MALLOC(sizeof(JSON_Array));
+    if (!new_array)
+        return NULL;
+    new_array->items = (JSON_Value**)NULL;
+    new_array->capacity = 0;
+    new_array->count = 0;
+    return new_array;
+}
+
+static JSON_Status json_array_add(JSON_Array *array, JSON_Value *value) {
+    if (array->count >= array->capacity) {
+        size_t new_capacity = MAX(array->capacity * 2, STARTING_CAPACITY);
+        if (new_capacity > ARRAY_MAX_CAPACITY)
+            return JSONFailure;
+        if (json_array_resize(array, new_capacity) == JSONFailure)
+            return JSONFailure;
+    }
+    array->items[array->count] = value;
+    array->count++;
+    return JSONSuccess;
+}
+
+static JSON_Status json_array_resize(JSON_Array *array, size_t capacity) {
+    if (try_realloc((void**)&array->items, capacity * sizeof(JSON_Value*)) == JSONFailure)
+        return JSONFailure;
+    array->capacity = capacity;
+    return JSONSuccess;
+}
+
+static void json_array_free(JSON_Array *array) {
+    while (array->count--)
+        json_value_free(array->items[array->count]);
+    PARSON_FREE(array->items);
+    PARSON_FREE(array);
+}
+
+/* JSON Value */
+static JSON_Value * json_value_init_string_no_copy(const char *string) {
+    JSON_Value *new_value = (JSON_Value*)PARSON_MALLOC(sizeof(JSON_Value));
+    if (!new_value)
+        return NULL;
+    new_value->type = JSONString;
+    new_value->value.string = string;
+    return new_value;
+}
+
+/* Parser */
+static void skip_quotes(const char **string) {
+    SKIP_CHAR(string);
+    while (**string != '\"') {
+        if (**string == '\0')
+            return;
+        if (**string == '\\') {
+            SKIP_CHAR(string);
+            if (**string == '\0')
+                return;
+        }
+        SKIP_CHAR(string);
+    }
+    SKIP_CHAR(string);
+}
+
+static int parse_utf_16(const char **unprocessed, char **processed) {
+    unsigned int cp, lead, trail;
+    char *processed_ptr = *processed;
+    const char *unprocessed_ptr = *unprocessed;
+    unprocessed_ptr++; /* skips u */
+    if (!is_utf16_hex((const unsigned char*)unprocessed_ptr) || sscanf(unprocessed_ptr, "%4x", &cp) == EOF)
+            return JSONFailure;
+    if (cp < 0x80) {
+        *processed_ptr = cp; /* 0xxxxxxx */
+    } else if (cp < 0x800) {
+        *processed_ptr++ = ((cp >> 6) & 0x1F) | 0xC0; /* 110xxxxx */
+        *processed_ptr   = ((cp     ) & 0x3F) | 0x80; /* 10xxxxxx */
+    } else if (cp < 0xD800 || cp > 0xDFFF) {
+        *processed_ptr++ = ((cp >> 12) & 0x0F) | 0xE0; /* 1110xxxx */
+        *processed_ptr++ = ((cp >> 6)  & 0x3F) | 0x80; /* 10xxxxxx */
+        *processed_ptr   = ((cp     )  & 0x3F) | 0x80; /* 10xxxxxx */
+    } else if (cp >= 0xD800 && cp <= 0xDBFF) { /* lead surrogate (0xD800..0xDBFF) */
+        lead = cp;
+        unprocessed_ptr += 4; /* should always be within the buffer, otherwise previous sscanf would fail */
+        if (*unprocessed_ptr++ != '\\' || *unprocessed_ptr++ != 'u' || /* starts with \u? */
+            !is_utf16_hex((const unsigned char*)unprocessed_ptr)          ||
+            sscanf(unprocessed_ptr, "%4x", &trail) == EOF           ||
+            trail < 0xDC00 || trail > 0xDFFF) { /* valid trail surrogate? (0xDC00..0xDFFF) */
+                return JSONFailure;
+        }
+        cp = ((((lead-0xD800)&0x3FF)<<10)|((trail-0xDC00)&0x3FF))+0x010000;
+        *processed_ptr++ = (((cp >> 18) & 0x07) | 0xF0); /* 11110xxx */
+        *processed_ptr++ = (((cp >> 12) & 0x3F) | 0x80); /* 10xxxxxx */
+        *processed_ptr++ = (((cp >> 6)  & 0x3F) | 0x80); /* 10xxxxxx */
+        *processed_ptr   = (((cp     )  & 0x3F) | 0x80); /* 10xxxxxx */
+    } else { /* trail surrogate before lead surrogate */
+        return JSONFailure;
+    }
+    unprocessed_ptr += 3;
+    *processed = processed_ptr;
+    *unprocessed = unprocessed_ptr;
+    return JSONSuccess;
+}
+
+
+/* Copies and processes passed string up to supplied length.
+Example: "\u006Corem ipsum" -> lorem ipsum */
+static char* process_string(const char *input, size_t len) {
+    const char *input_ptr = input;
+    char *output = (char*)PARSON_MALLOC((len + 1) * sizeof(char));
+    char *output_ptr = output;
+    while ((*input_ptr != '\0') && (size_t)(input_ptr - input) < len) {
+        if (*input_ptr == '\\') {
+            input_ptr++;
+            switch (*input_ptr) {
+                case '\"': *output_ptr = '\"'; break;
+                case '\\': *output_ptr = '\\'; break;
+                case '/':  *output_ptr = '/';  break;
+                case 'b':  *output_ptr = '\b'; break;
+                case 'f':  *output_ptr = '\f'; break;
+                case 'n':  *output_ptr = '\n'; break;
+                case 'r':  *output_ptr = '\r'; break;
+                case 't':  *output_ptr = '\t'; break;
+                case 'u':
+                    if (parse_utf_16(&input_ptr, &output_ptr) == JSONFailure)
+                        goto error;
+                    break;
+                default:
+                    goto error;
+            }
+        } else if ((unsigned char)*input_ptr < 0x20) {
+            goto error; /* 0x00-0x19 are invalid characters for json string (http://www.ietf.org/rfc/rfc4627.txt) */
+        } else {
+            *output_ptr = *input_ptr;
+        }
+        output_ptr++;
+        input_ptr++;
+    }
+    *output_ptr = '\0';
+    if (try_realloc((void**)&output, (size_t)(output_ptr-output) + 1) == JSONFailure) /* resize to new length */
+        goto error;
+    return output;
+error:
+    free(output);
+    return NULL;
+}
+
+/* Return processed contents of a string between quotes and
+   skips passed argument to a matching quote. */
+static const char * get_quoted_string(const char **string) {
+    const char *string_start = *string;
+    size_t string_len = 0;
+    skip_quotes(string);
+    if (**string == '\0')
+        return NULL;
+    string_len = *string - string_start - 2; /* length without quotes */
+    return process_string(string_start + 1, string_len);
+}
+
+static JSON_Value * parse_value(const char **string, size_t nesting) {
+    if (nesting > MAX_NESTING)
+        return NULL;
+    SKIP_WHITESPACES(string);
+    switch (**string) {
+        case '{':
+            return parse_object_value(string, nesting + 1);
+        case '[':
+            return parse_array_value(string, nesting + 1);
+        case '\"':
+            return parse_string_value(string);
+        case 'f': case 't':
+            return parse_boolean_value(string);
+        case '-':
+        case '0': case '1': case '2': case '3': case '4':
+        case '5': case '6': case '7': case '8': case '9':
+            return parse_number_value(string);
+        case 'n':
+            return parse_null_value(string);
+        default:
+            return NULL;
+    }
+}
+
+static JSON_Value * parse_object_value(const char **string, size_t nesting) {
+    JSON_Value *output_value = json_value_init_object(), *new_value = NULL;
+    JSON_Object *output_object = json_value_get_object(output_value);
+    const char *new_key = NULL;
+    if (output_value == NULL)
+        return NULL;
+    SKIP_CHAR(string);
+    SKIP_WHITESPACES(string);
+    if (**string == '}') { /* empty object */
+        SKIP_CHAR(string);
+        return output_value;
+    }
+    while (**string != '\0') {
+        new_key = get_quoted_string(string);
+        SKIP_WHITESPACES(string);
+        if (new_key == NULL || **string != ':') {
+            json_value_free(output_value);
+            return NULL;
+        }
+        SKIP_CHAR(string);
+        new_value = parse_value(string, nesting);
+        if (new_value == NULL) {
+            PARSON_FREE(new_key);
+            json_value_free(output_value);
+            return NULL;
+        }
+        if(json_object_add(output_object, new_key, new_value) == JSONFailure) {
+            PARSON_FREE(new_key);
+            PARSON_FREE(new_value);
+            json_value_free(output_value);
+            return NULL;
+        }
+        PARSON_FREE(new_key);
+        SKIP_WHITESPACES(string);
+        if (**string != ',')
+            break;
+        SKIP_CHAR(string);
+        SKIP_WHITESPACES(string);
+    }
+    SKIP_WHITESPACES(string);
+    if (**string != '}' || /* Trim object after parsing is over */
+        json_object_resize(output_object, json_object_get_count(output_object)) == JSONFailure) {
+            json_value_free(output_value);
+            return NULL;
+    }
+    SKIP_CHAR(string);
+    return output_value;
+}
+
+static JSON_Value * parse_array_value(const char **string, size_t nesting) {
+    JSON_Value *output_value = json_value_init_array(), *new_array_value = NULL;
+    JSON_Array *output_array = json_value_get_array(output_value);
+    if (!output_value)
+        return NULL;
+    SKIP_CHAR(string);
+    SKIP_WHITESPACES(string);
+    if (**string == ']') { /* empty array */
+        SKIP_CHAR(string);
+        return output_value;
+    }
+    while (**string != '\0') {
+        new_array_value = parse_value(string, nesting);
+        if (!new_array_value) {
+            json_value_free(output_value);
+            return NULL;
+        }
+        if(json_array_add(output_array, new_array_value) == JSONFailure) {
+            PARSON_FREE(new_array_value);
+            json_value_free(output_value);
+            return NULL;
+        }
+        SKIP_WHITESPACES(string);
+        if (**string != ',')
+            break;
+        SKIP_CHAR(string);
+        SKIP_WHITESPACES(string);
+    }
+    SKIP_WHITESPACES(string);
+    if (**string != ']' || /* Trim array after parsing is over */
+        json_array_resize(output_array, json_array_get_count(output_array)) == JSONFailure) {
+            json_value_free(output_value);
+            return NULL;
+    }
+    SKIP_CHAR(string);
+    return output_value;
+}
+
+static JSON_Value * parse_string_value(const char **string) {
+    const char *new_string = get_quoted_string(string);
+    if (!new_string)
+        return NULL;
+    return json_value_init_string_no_copy(new_string);
+}
+
+static JSON_Value * parse_boolean_value(const char **string) {
+    size_t true_token_size = SIZEOF_TOKEN("true");
+    size_t false_token_size = SIZEOF_TOKEN("false");
+    if (strncmp("true", *string, true_token_size) == 0) {
+        *string += true_token_size;
+        return json_value_init_boolean(1);
+    } else if (strncmp("false", *string, false_token_size) == 0) {
+        *string += false_token_size;
+        return json_value_init_boolean(0);
+    }
+    return NULL;
+}
+
+static JSON_Value * parse_number_value(const char **string) {
+    char *jint_end, *double_end;
+    double number = strtod(*string, &double_end);
+    jint integer = strtoll(*string, &jint_end, 10);
+    JSON_Value *output_value;
+    if (double_end > jint_end || errno == ERANGE) {
+        if (is_decimal(*string, double_end - *string)) {
+            *string = double_end;
+            output_value = json_value_init_number(number);
+        } else {
+            output_value = NULL;
+        }
+    } else {
+        *string = jint_end;
+        output_value = json_value_init_integer(integer);
+    }
+    return output_value;
+}
+
+static JSON_Value * parse_null_value(const char **string) {
+    size_t token_size = SIZEOF_TOKEN("null");
+    if (strncmp("null", *string, token_size) == 0) {
+        *string += token_size;
+        return json_value_init_null();
+    }
+    return NULL;
+}
+
+/* Serialization */
+static size_t json_serialization_size_r(const JSON_Value *value, char *buf) {
+    size_t result_size = 0;
+    const char *key = NULL;
+    JSON_Value *temp_value = NULL;
+    JSON_Array *array = NULL;
+    JSON_Object *object = NULL;
+    size_t i = 0, count = 0;
+    double num = 0.0;
+    jint intnum = 0;
+    switch (json_value_get_type(value)) {
+        case JSONArray:
+            array = json_value_get_array(value);
+            count = json_array_get_count(array);
+            result_size += 2; /* [ and ] brackets */
+            if (count > 0)
+                result_size += count - 1; /* , between items */
+            for (i = 0; i < count; i++) {
+                temp_value = json_array_get_value(array, i);
+                result_size += json_serialization_size_r(temp_value, buf);
+            }
+            return result_size;
+        case JSONObject:
+            object = json_value_get_object(value);
+            count  = json_object_get_count(object);
+            result_size += 2; /* { and } brackets */
+            if (count > 0)
+                result_size += (count * 2) - 1; /* : between keys and values and , between items */
+            for (i = 0; i < count; i++) {
+                key = json_object_get_name(object, i);
+                result_size += serialization_strlen(key) + 2; /* string and quotes */
+                result_size += json_serialization_size_r(json_object_get_value(object, key), buf);
+            }
+            return result_size;
+        case JSONString:
+            return serialization_strlen(json_value_get_string(value)) + 2; /* string and quotes */
+        case JSONBoolean:
+            if (json_value_get_boolean(value))
+                return 4; /* strlen("true"); */
+            else
+                return 5; /* strlen("false"); */
+        case JSONInteger:
+            intnum = json_value_get_integer(value);
+            return (size_t)sprintf(buf, JINT_SERIALIZATION_FORMAT, intnum);
+        case JSONNumber:
+            num = json_value_get_number(value);
+            if (num == ((double)(jint)num) ) /*  check if num is integer */
+                return (size_t)sprintf(buf, JINT_SERIALIZATION_FORMAT, (jint)num);
+            return (size_t)sprintf(buf, DOUBLE_SERIALIZATION_FORMAT, num);
+        case JSONNull:
+            return 4; /* strlen("null"); */
+        case JSONError:
+            return 0;
+        default:
+            return 0;
+    }
+}
+
+char* json_serialize_to_buffer_r(const JSON_Value *value, char *buf)
+{
+    const char *key = NULL, *string = NULL;
+    JSON_Value *temp_value = NULL;
+    JSON_Array *array = NULL;
+    JSON_Object *object = NULL;
+    size_t i = 0, count = 0;
+    double num = 0.0;
+    jint intnum = 0;
+    switch (json_value_get_type(value)) {
+        case JSONArray:
+            array = json_value_get_array(value);
+            count = json_array_get_count(array);
+            PRINT_AND_SKIP(buf, "[");
+            for (i = 0; i < count; i++) {
+                temp_value = json_array_get_value(array, i);
+                buf = json_serialize_to_buffer_r(temp_value, buf);
+                if (buf == NULL)
+                    return NULL;
+                if (i < (count - 1))
+                    PRINT_AND_SKIP(buf, ",");
+            }
+            PRINT_AND_SKIP(buf, "]");
+            return buf;
+        case JSONObject:
+            object = json_value_get_object(value);
+            count  = json_object_get_count(object);
+            PRINT_AND_SKIP(buf, "{");
+            for (i = 0; i < count; i++) {
+                key = json_object_get_name(object, i);
+                buf = json_serialize_string(key, buf);
+                if (buf == NULL)
+                    return NULL;
+                PRINT_AND_SKIP(buf, ":");
+                temp_value = json_object_get_value(object, key);
+                buf = json_serialize_to_buffer_r(temp_value, buf);
+                if (buf == NULL)
+                    return NULL;
+                if (i < (count - 1))
+                    PRINT_AND_SKIP(buf, ",");
+            }
+            PRINT_AND_SKIP(buf, "}");
+            return buf;
+        case JSONString:
+            string = json_value_get_string(value);
+            buf = json_serialize_string(string, buf);
+            return buf;
+        case JSONBoolean:
+            if (json_value_get_boolean(value)) {
+                PRINT_AND_SKIP(buf, "true");
+            } else {
+                PRINT_AND_SKIP(buf, "false");
+            }
+            return buf;
+        case JSONInteger:
+            intnum = json_value_get_integer(value);
+            PRINTF_AND_SKIP(buf, JINT_SERIALIZATION_FORMAT, intnum);
+            return buf;
+        case JSONNumber:
+            num = json_value_get_number(value);
+            if (num == ((double)(int)num)) { /*  check if num is integer */
+                PRINTF_AND_SKIP(buf, "%d", (int)num);
+            } else {
+                PRINTF_AND_SKIP(buf, DOUBLE_SERIALIZATION_FORMAT, num);
+            }
+            return buf;
+        case JSONNull:
+            PRINT_AND_SKIP(buf, "null");
+            return buf;
+        case JSONError:
+            return NULL;
+        default:
+            return NULL;
+    }
+}
+
+static char * json_serialize_string(const char *string, char *buf) {
+    size_t i = 0, len = strlen(string);
+    char c = '\0';
+    PRINT_AND_SKIP(buf, "\"")
+    for (i = 0; i < len; i++) {
+        c = string[i];
+        switch (c) {
+            case '\"': PRINT_AND_SKIP(buf, "\\\"");   break;
+            case '\\': PRINT_AND_SKIP(buf, "\\\\");   break;
+            case '\b': PRINT_AND_SKIP(buf, "\\b");    break;
+            case '\f': PRINT_AND_SKIP(buf, "\\f");    break;
+            case '\n': PRINT_AND_SKIP(buf, "\\n");    break;
+            case '\r': PRINT_AND_SKIP(buf, "\\r");    break;
+            case '\t': PRINT_AND_SKIP(buf, "\\t");    break;
+            default:   PRINTF_AND_SKIP(buf, "%c", c); break;
+        }
+    }
+    PRINT_AND_SKIP(buf, "\"");
+    return buf;
+}
+
+/* Parser API */
+JSON_Value * json_parse_file(const char *filename) {
+    char *file_contents = read_file(filename);
+    JSON_Value *output_value = NULL;
+    if (file_contents == NULL)
+        return NULL;
+    output_value = json_parse_string(file_contents);
+    PARSON_FREE(file_contents);
+    return output_value;
+}
+
+JSON_Value * json_parse_file_with_comments(const char *filename) {
+    char *file_contents = read_file(filename);
+    JSON_Value *output_value = NULL;
+    if (file_contents == NULL)
+        return NULL;
+    output_value = json_parse_string_with_comments(file_contents);
+    PARSON_FREE(file_contents);
+    return output_value;
+}
+
+JSON_Value * json_parse_first(const char *string, const char **end) {
+    const char *pos;
+    JSON_Value *ret;
+
+    if (string == NULL)
+        return NULL;
+    SKIP_WHITESPACES(&string);
+    if (*string != '{' && *string != '[')
+        return NULL;
+
+    pos = string;
+    ret = parse_value(&pos, 0);
+    if (end)
+        *end = pos;
+
+    return ret;
+}
+
+JSON_Value * json_parse_string(const char *string) {
+    return json_parse_first(string, NULL);
+}
+
+JSON_Value * json_parse_string_with_comments(const char *string) {
+    JSON_Value *result = NULL;
+    char *string_mutable_copy = NULL, *string_mutable_copy_ptr = NULL;
+    string_mutable_copy = parson_strdup(string);
+    if (string_mutable_copy == NULL)
+        return NULL;
+    remove_comments(string_mutable_copy, "/*", "*/");
+    remove_comments(string_mutable_copy, "//", "\n");
+    string_mutable_copy_ptr = string_mutable_copy;
+    SKIP_WHITESPACES(&string_mutable_copy_ptr);
+    if (*string_mutable_copy_ptr != '{' && *string_mutable_copy_ptr != '[') {
+        PARSON_FREE(string_mutable_copy);
+        return NULL;
+    }
+    result = parse_value((const char**)&string_mutable_copy_ptr, 0);
+    PARSON_FREE(string_mutable_copy);
+    return result;
+}
+
+
+/* JSON Object API */
+
+JSON_Value * json_object_get_value(const JSON_Object *object, const char *name) {
+    if (object == NULL || name == NULL)
+        return NULL;
+    return json_object_nget_value(object, name, strlen(name));
+}
+
+const char * json_object_get_string(const JSON_Object *object, const char *name) {
+    return json_value_get_string(json_object_get_value(object, name));
+}
+
+jint json_object_get_integer(const JSON_Object *object, const char *name) {
+    return json_value_get_integer(json_object_get_value(object, name));
+}
+
+double json_object_get_number(const JSON_Object *object, const char *name) {
+    return json_value_get_number(json_object_get_value(object, name));
+}
+
+JSON_Object * json_object_get_object(const JSON_Object *object, const char *name) {
+    return json_value_get_object(json_object_get_value(object, name));
+}
+
+JSON_Array * json_object_get_array(const JSON_Object *object, const char *name) {
+    return json_value_get_array(json_object_get_value(object, name));
+}
+
+int json_object_get_boolean(const JSON_Object *object, const char *name) {
+    return json_value_get_boolean(json_object_get_value(object, name));
+}
+
+JSON_Value * json_object_dotget_value(const JSON_Object *object, const char *name) {
+    const char *dot_position = strchr(name, '.');
+    if (!dot_position)
+        return json_object_get_value(object, name);
+    object = json_value_get_object(json_object_nget_value(object, name, dot_position - name));
+    return json_object_dotget_value(object, dot_position + 1);
+}
+
+const char * json_object_dotget_string(const JSON_Object *object, const char *name) {
+    return json_value_get_string(json_object_dotget_value(object, name));
+}
+
+jint json_object_dotget_integer(const JSON_Object *object, const char *name) {
+    return json_value_get_integer(json_object_dotget_value(object, name));
+}
+
+double json_object_dotget_number(const JSON_Object *object, const char *name) {
+    return json_value_get_number(json_object_dotget_value(object, name));
+}
+
+JSON_Object * json_object_dotget_object(const JSON_Object *object, const char *name) {
+    return json_value_get_object(json_object_dotget_value(object, name));
+}
+
+JSON_Array * json_object_dotget_array(const JSON_Object *object, const char *name) {
+    return json_value_get_array(json_object_dotget_value(object, name));
+}
+
+int json_object_dotget_boolean(const JSON_Object *object, const char *name) {
+    return json_value_get_boolean(json_object_dotget_value(object, name));
+}
+
+size_t json_object_get_count(const JSON_Object *object) {
+    return object ? object->count : 0;
+}
+
+const char * json_object_get_name(const JSON_Object *object, size_t index) {
+    if (index >= json_object_get_count(object))
+        return NULL;
+    return object->names[index];
+}
+
+int json_object_get_tuple(const JSON_Object *object, size_t index,
+                          const char **key, const JSON_Value **value) {
+    if (index >= json_object_get_count(object))
+        return 0;
+    *key = object->names[index];
+    *value = object->values[index];
+    return 1;
+}
+
+/* JSON Array API */
+JSON_Value * json_array_get_value(const JSON_Array *array, size_t index) {
+    if (index >= json_array_get_count(array))
+        return NULL;
+    return array->items[index];
+}
+
+const char * json_array_get_string(const JSON_Array *array, size_t index) {
+    return json_value_get_string(json_array_get_value(array, index));
+}
+
+jint json_array_get_integer(const JSON_Array *array, size_t index) {
+    return json_value_get_integer(json_array_get_value(array, index));
+}
+
+double json_array_get_number(const JSON_Array *array, size_t index) {
+    return json_value_get_number(json_array_get_value(array, index));
+}
+
+JSON_Object * json_array_get_object(const JSON_Array *array, size_t index) {
+    return json_value_get_object(json_array_get_value(array, index));
+}
+
+JSON_Array * json_array_get_array(const JSON_Array *array, size_t index) {
+    return json_value_get_array(json_array_get_value(array, index));
+}
+
+int json_array_get_boolean(const JSON_Array *array, size_t index) {
+    return json_value_get_boolean(json_array_get_value(array, index));
+}
+
+size_t json_array_get_count(const JSON_Array *array) {
+    return array ? array->count : 0;
+}
+
+/* JSON Value API */
+JSON_Value_Type json_value_get_type(const JSON_Value *value) {
+    return value ? value->type : JSONError;
+}
+
+JSON_Object * json_value_get_object(const JSON_Value *value) {
+    return json_value_get_type(value) == JSONObject ? value->value.object : NULL;
+}
+
+JSON_Array * json_value_get_array(const JSON_Value *value) {
+    return json_value_get_type(value) == JSONArray ? value->value.array : NULL;
+}
+
+const char * json_value_get_string(const JSON_Value *value) {
+    return json_value_get_type(value) == JSONString ? value->value.string : NULL;
+}
+
+jint json_value_get_integer(const JSON_Value *value) {
+    if (json_value_get_type(value) == JSONNumber) {
+        return value->value.number;
+    } else if (json_value_get_type(value) == JSONInteger) {
+        return value->value.integer;
+    } else {
+        return 0;
+    }
+}
+
+double json_value_get_number(const JSON_Value *value) {
+    if (json_value_get_type(value) == JSONNumber) {
+        return value->value.number;
+    } else if (json_value_get_type(value) == JSONInteger) {
+        return value->value.integer;
+    } else {
+        return 0;
+    }
+}
+
+int json_value_get_boolean(const JSON_Value *value) {
+    return json_value_get_type(value) == JSONBoolean ? value->value.boolean : -1;
+}
+
+void json_value_free(JSON_Value *value) {
+    switch (json_value_get_type(value)) {
+        case JSONObject:
+            json_object_free(value->value.object);
+            break;
+        case JSONString:
+            if (value->value.string) { PARSON_FREE(value->value.string); }
+            break;
+        case JSONArray:
+            json_array_free(value->value.array);
+            break;
+        default:
+            break;
+    }
+    PARSON_FREE(value);
+}
+
+JSON_Value * json_value_init_object(void) {
+    JSON_Value *new_value = (JSON_Value*)PARSON_MALLOC(sizeof(JSON_Value));
+    if (!new_value)
+        return NULL;
+    new_value->type = JSONObject;
+    new_value->value.object = json_object_init();
+    if (!new_value->value.object) {
+        PARSON_FREE(new_value);
+        return NULL;
+    }
+    return new_value;
+}
+
+JSON_Value * json_value_init_array(void) {
+    JSON_Value *new_value = (JSON_Value*)PARSON_MALLOC(sizeof(JSON_Value));
+    if (!new_value)
+        return NULL;
+    new_value->type = JSONArray;
+    new_value->value.array = json_array_init();
+    if (!new_value->value.array) {
+        PARSON_FREE(new_value);
+        return NULL;
+    }
+    return new_value;
+}
+
+JSON_Value * json_value_init_string(const char *string) {
+    char *copy = NULL;
+    JSON_Value *value;
+    size_t string_len = 0;
+    if (string == NULL)
+        return NULL;
+    string_len = strlen(string);
+    if (!is_valid_utf8(string, string_len))
+        return NULL;
+    copy = parson_strndup(string, string_len);
+    if (copy == NULL)
+        return NULL;
+    value = json_value_init_string_no_copy(copy);
+    if (value == NULL)
+        PARSON_FREE(copy);
+    return value;
+}
+
+JSON_Value * json_value_init_integer(jint number) {
+    JSON_Value *new_value = (JSON_Value*)PARSON_MALLOC(sizeof(JSON_Value));
+    if (!new_value)
+        return NULL;
+    new_value->type = JSONInteger;
+    new_value->value.integer = number;
+    return new_value;
+}
+
+JSON_Value * json_value_init_number(double number) {
+    JSON_Value *new_value = (JSON_Value*)PARSON_MALLOC(sizeof(JSON_Value));
+    if (!new_value)
+        return NULL;
+    new_value->type = JSONNumber;
+    new_value->value.number = number;
+    return new_value;
+}
+
+JSON_Value * json_value_init_boolean(int boolean) {
+    JSON_Value *new_value = (JSON_Value*)PARSON_MALLOC(sizeof(JSON_Value));
+    if (!new_value)
+        return NULL;
+    new_value->type = JSONBoolean;
+    new_value->value.boolean = boolean ? 1 : 0;
+    return new_value;
+}
+
+JSON_Value * json_value_init_null(void) {
+    JSON_Value *new_value = (JSON_Value*)PARSON_MALLOC(sizeof(JSON_Value));
+    if (!new_value)
+        return NULL;
+    new_value->type = JSONNull;
+    return new_value;
+}
+
+JSON_Value * json_value_deep_copy(const JSON_Value *value) {
+    size_t i = 0;
+    JSON_Value *return_value = NULL, *temp_value_copy = NULL, *temp_value = NULL;
+    const char *temp_string = NULL, *temp_string_copy = NULL, *temp_key = NULL;
+    JSON_Array *temp_array = NULL, *temp_array_copy = NULL;
+    JSON_Object *temp_object = NULL, *temp_object_copy = NULL;
+    
+    switch (json_value_get_type(value)) {
+        case JSONArray:
+            temp_array = json_value_get_array(value);
+            return_value = json_value_init_array();
+            if (return_value == NULL)
+                return NULL;
+            temp_array_copy = json_value_get_array(return_value);
+            for (i = 0; i < json_array_get_count(temp_array); i++) {
+                temp_value = json_array_get_value(temp_array, i);
+                temp_value_copy = json_value_deep_copy(temp_value);
+                if (temp_value_copy == NULL) {
+                    json_value_free(return_value);
+                    return NULL;
+                }
+                if (json_array_add(temp_array_copy, temp_value_copy) == JSONFailure) {
+                    json_value_free(return_value);
+                    json_value_free(temp_value_copy);
+                    return NULL;
+                }
+            }
+            return return_value;
+        case JSONObject:
+            temp_object = json_value_get_object(value);
+            return_value = json_value_init_object();
+            if (return_value == NULL)
+                return NULL;
+            temp_object_copy = json_value_get_object(return_value);
+            for (i = 0; i < json_object_get_count(temp_object); i++) {
+                temp_key = json_object_get_name(temp_object, i);
+                temp_value = json_object_get_value(temp_object, temp_key);
+                temp_value_copy = json_value_deep_copy(temp_value);
+                if (temp_value_copy == NULL) {
+                    json_value_free(return_value);
+                    return NULL;
+                }
+                if (json_object_add(temp_object_copy, temp_key, temp_value_copy) == JSONFailure) {
+                    json_value_free(return_value);
+                    json_value_free(temp_value_copy);
+                    return NULL;
+                }
+            }
+            return return_value;
+        case JSONBoolean:
+            return json_value_init_boolean(json_value_get_boolean(value));
+        case JSONInteger:
+            return json_value_init_integer(json_value_get_integer(value));
+        case JSONNumber:
+            return json_value_init_number(json_value_get_number(value));
+        case JSONString:
+            temp_string = json_value_get_string(value);
+            temp_string_copy = parson_strdup(temp_string);
+            if (temp_string_copy == NULL)
+                return NULL;
+            return_value = json_value_init_string_no_copy(temp_string_copy);
+            if (return_value == NULL)
+                PARSON_FREE(temp_string_copy);
+            return return_value;
+        case JSONNull:
+            return json_value_init_null();
+        case JSONError:
+            return NULL;
+        default:
+            return NULL;
+    }
+}
+
+size_t json_serialization_size(const JSON_Value *value) {
+    char buf[1100]; /* recursively allocating buffer on stack is a bad idea, so let's do it only once */
+    return json_serialization_size_r(value, buf) + 1;
+}
+
+JSON_Status json_serialize_to_buffer(const JSON_Value *value, char *buf, size_t buf_size_in_bytes) {
+    char *serialization_result = NULL;
+    size_t needed_size_in_bytes = json_serialization_size(value);
+    if (buf_size_in_bytes < needed_size_in_bytes) {
+        return JSONFailure;
+    }
+    serialization_result = json_serialize_to_buffer_r(value, buf);
+    if(serialization_result == NULL)
+        return JSONFailure;
+    return JSONSuccess;
+}
+
+JSON_Status json_serialize_to_file(const JSON_Value *value, const char *filename) {
+    JSON_Status return_code = JSONSuccess;
+    FILE *fp = NULL;
+    char *serialized_string = json_serialize_to_string(value);
+    if (serialized_string == NULL) {
+        return JSONFailure;
+    }
+    fp = fopen (filename, "w");
+    if (fp != NULL) {
+        if (fputs (serialized_string, fp) == EOF) {
+            return_code = JSONFailure;
+        }
+        if (fclose (fp) == EOF) {
+            return_code = JSONFailure;
+        }
+    }
+    json_free_serialized_string(serialized_string);
+    return return_code;
+}
+
+char * json_serialize_to_string(const JSON_Value *value) {
+    JSON_Status serialization_result = JSONFailure;
+    size_t buf_size_bytes = json_serialization_size(value);
+    char *buf = (char*)PARSON_MALLOC(buf_size_bytes);
+    if (buf == NULL)
+        return NULL;
+    serialization_result = json_serialize_to_buffer(value, buf, buf_size_bytes);
+    if (serialization_result == JSONFailure) {
+        json_free_serialized_string(buf);
+        return NULL;
+    }
+    return buf;
+}
+
+void json_free_serialized_string(char *string) {
+    PARSON_FREE(string);
+}
+
+JSON_Status json_array_remove(JSON_Array *array, size_t ix) {
+    size_t last_element_ix = 0;
+    if (array == NULL || ix >= json_array_get_count(array)) {
+        return JSONFailure;
+    }
+    last_element_ix = json_array_get_count(array) - 1;
+    json_value_free(json_array_get_value(array, ix));
+    array->count -= 1;
+    if (ix != last_element_ix) /* Replace value with one from the end of array */
+        array->items[ix] = json_array_get_value(array, last_element_ix);
+    return JSONSuccess;
+}
+
+JSON_Status json_array_replace_value(JSON_Array *array, size_t ix, JSON_Value *value) {
+    if (array == NULL || value == NULL || ix >= json_array_get_count(array)) {
+        return JSONFailure;
+    }
+    json_value_free(json_array_get_value(array, ix));
+    array->items[ix] = value;
+    return JSONSuccess;
+}
+
+JSON_Status json_array_replace_string(JSON_Array *array, size_t i, const char* string) {
+    JSON_Value *value = json_value_init_string(string);
+    if (value == NULL)
+        return JSONFailure;
+    if (json_array_replace_value(array, i, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_array_replace_integer(JSON_Array *array, size_t i, jint integer) {
+    JSON_Value *value = json_value_init_integer(integer);
+    if (value == NULL)
+        return JSONFailure;
+    if (json_array_replace_value(array, i, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_array_replace_number(JSON_Array *array, size_t i, double number) {
+    JSON_Value *value = json_value_init_number(number);
+    if (value == NULL)
+        return JSONFailure;
+    if (json_array_replace_value(array, i, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_array_replace_boolean(JSON_Array *array, size_t i, int boolean) {
+    JSON_Value *value = json_value_init_boolean(boolean);
+    if (value == NULL)
+        return JSONFailure;
+    if (json_array_replace_value(array, i, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_array_replace_null(JSON_Array *array, size_t i) {
+    JSON_Value *value = json_value_init_null();
+    if (value == NULL)
+        return JSONFailure;
+    if (json_array_replace_value(array, i, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_array_clear(JSON_Array *array) {
+    size_t i = 0;
+    if (array == NULL)
+        return JSONFailure;
+    for (i = 0; i < json_array_get_count(array); i++) {
+        json_value_free(json_array_get_value(array, i));
+    }
+    array->count = 0;
+    return JSONSuccess;
+}
+
+JSON_Status json_array_append_value(JSON_Array *array, JSON_Value *value) {
+    if (array == NULL || value == NULL)
+        return JSONFailure;
+    return json_array_add(array, value);
+}
+
+JSON_Status json_array_append_string(JSON_Array *array, const char *string) {
+    JSON_Value *value = json_value_init_string(string);
+    if (value == NULL)
+        return JSONFailure;
+    if (json_array_append_value(array, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_array_append_integer(JSON_Array *array, jint integer) {
+    JSON_Value *value = json_value_init_integer(integer);
+    if (value == NULL)
+        return JSONFailure;
+    if (json_array_append_value(array, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_array_append_number(JSON_Array *array, double number) {
+    JSON_Value *value = json_value_init_number(number);
+    if (value == NULL)
+        return JSONFailure;
+    if (json_array_append_value(array, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_array_append_boolean(JSON_Array *array, int boolean) {
+    JSON_Value *value = json_value_init_boolean(boolean);
+    if (value == NULL)
+        return JSONFailure;
+    if (json_array_append_value(array, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_array_append_null(JSON_Array *array) {
+    JSON_Value *value = json_value_init_null();
+    if (value == NULL)
+        return JSONFailure;
+    if (json_array_append_value(array, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_object_set_value(JSON_Object *object, const char *name, JSON_Value *value) {
+    size_t i = 0;
+    JSON_Value *old_value;
+    if (object == NULL || name == NULL || value == NULL)
+        return JSONFailure;
+    old_value = json_object_get_value(object, name);
+    if (old_value != NULL) { /* free and overwrite old value */
+        json_value_free(old_value);
+        for (i = 0; i < json_object_get_count(object); i++) {
+            if (strcmp(object->names[i], name) == 0) {
+                object->values[i] = value;
+                return JSONSuccess;
+            }
+        }
+    }
+    /* add new key value pair */
+    return json_object_add(object, name, value);
+}
+
+JSON_Status json_object_set_string(JSON_Object *object, const char *name, const char *string) {
+    return json_object_set_value(object, name, json_value_init_string(string));
+}
+
+JSON_Status json_object_set_integer(JSON_Object *object, const char *name, jint integer) {
+    return json_object_set_value(object, name, json_value_init_integer(integer));
+}
+
+JSON_Status json_object_set_number(JSON_Object *object, const char *name, double number) {
+    return json_object_set_value(object, name, json_value_init_number(number));
+}
+
+JSON_Status json_object_set_boolean(JSON_Object *object, const char *name, int boolean) {
+    return json_object_set_value(object, name, json_value_init_boolean(boolean));
+}
+
+JSON_Status json_object_set_null(JSON_Object *object, const char *name) {
+    return json_object_set_value(object, name, json_value_init_null());
+}
+
+JSON_Status json_object_dotset_value(JSON_Object *object, const char *name, JSON_Value *value) {
+    const char *dot_pos = NULL;
+    const char *current_name = NULL;
+    JSON_Object *temp_obj = NULL;
+    JSON_Value *new_value = NULL;
+    if (value == NULL || name == NULL || value == NULL)
+        return JSONFailure;
+    dot_pos = strchr(name, '.');
+    if (dot_pos == NULL) {
+        return json_object_set_value(object, name, value);
+    } else {
+        current_name = parson_strndup(name, dot_pos - name);
+        temp_obj = json_object_get_object(object, current_name);
+        if (temp_obj == NULL) {
+            new_value = json_value_init_object();
+            if (new_value == NULL) {
+                PARSON_FREE(current_name);
+                return JSONFailure;
+            }
+            if (json_object_add(object, current_name, new_value) == JSONFailure) {
+                json_value_free(new_value);
+                PARSON_FREE(current_name);
+                return JSONFailure;
+            }
+            temp_obj = json_object_get_object(object, current_name);
+        }
+        PARSON_FREE(current_name);
+        return json_object_dotset_value(temp_obj, dot_pos + 1, value);
+    }
+}
+
+JSON_Status json_object_dotset_string(JSON_Object *object, const char *name, const char *string) {
+    JSON_Value *value = json_value_init_string(string);
+    if (value == NULL)
+        return JSONFailure;
+    if (json_object_dotset_value(object, name, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_object_dotset_integer(JSON_Object *object, const char *name, jint integer) {
+    JSON_Value *value = json_value_init_integer(integer);
+    if (value == NULL)
+        return JSONFailure;
+    if (json_object_dotset_value(object, name, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_object_dotset_number(JSON_Object *object, const char *name, double number) {
+    JSON_Value *value = json_value_init_number(number);
+    if (value == NULL)
+        return JSONFailure;
+    if (json_object_dotset_value(object, name, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_object_dotset_boolean(JSON_Object *object, const char *name, int boolean) {
+    JSON_Value *value = json_value_init_boolean(boolean);
+    if (value == NULL)
+        return JSONFailure;
+    if (json_object_dotset_value(object, name, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_object_dotset_null(JSON_Object *object, const char *name) {
+    JSON_Value *value = json_value_init_null();
+    if (value == NULL)
+        return JSONFailure;
+    if (json_object_dotset_value(object, name, value) == JSONFailure) {
+        json_value_free(value);
+        return JSONFailure;
+    }
+    return JSONSuccess;
+}
+
+JSON_Status json_object_remove(JSON_Object *object, const char *name) {
+    size_t i = 0, last_item_index = 0;
+    if (object == NULL || json_object_get_value(object, name) == NULL)
+        return JSONFailure;
+    last_item_index = json_object_get_count(object) - 1;
+    for (i = 0; i < json_object_get_count(object); i++) {
+        if (strcmp(object->names[i], name) == 0) {
+            PARSON_FREE(object->names[i]);
+            json_value_free(object->values[i]);
+            if (i != last_item_index) { /* Replace key value pair with one from the end */
+                object->names[i] = object->names[last_item_index];
+                object->values[i] = object->values[last_item_index];
+            }
+            object->count -= 1;
+            return JSONSuccess;
+        }
+    }
+    return JSONFailure; /* No execution path should end here */
+}
+
+JSON_Status json_object_dotremove(JSON_Object *object, const char *name) {
+    const char *dot_pos = strchr(name, '.');
+    const char *current_name = NULL;
+    JSON_Object *temp_obj = NULL;
+    if (dot_pos == NULL) {
+        return json_object_remove(object, name);
+    } else {
+        current_name = parson_strndup(name, dot_pos - name);
+        temp_obj = json_object_get_object(object, current_name);
+        if (temp_obj == NULL) {
+            PARSON_FREE(current_name);
+            return JSONFailure;
+        }
+        PARSON_FREE(current_name);
+        return json_object_dotremove(temp_obj, dot_pos + 1);
+    }
+}
+
+JSON_Status json_object_clear(JSON_Object *object) {
+    size_t i = 0;
+    if (object == NULL) {
+        return JSONFailure;
+    }
+    for (i = 0; i < json_object_get_count(object); i++) {        
+        PARSON_FREE(object->names[i]);
+        json_value_free(object->values[i]);
+    }
+    object->count = 0;
+    return JSONSuccess;
+}
+
+JSON_Status json_validate(const JSON_Value *schema, const JSON_Value *value) {
+    JSON_Value *temp_schema_value = NULL, *temp_value = NULL;
+    JSON_Array *schema_array = NULL, *value_array = NULL;
+    JSON_Object *schema_object = NULL, *value_object = NULL;
+    JSON_Value_Type schema_type = JSONError, value_type = JSONError;
+    const char *key = NULL;
+    size_t i = 0, count = 0;
+    if (schema == NULL || value == NULL)
+        return JSONFailure;
+    schema_type = json_value_get_type(schema);
+    value_type = json_value_get_type(value);
+    if (schema_type != value_type && schema_type != JSONNull) /* null represents all values */
+        return JSONFailure;
+    switch (schema_type) {
+        case JSONArray:
+            schema_array = json_value_get_array(schema);
+            value_array = json_value_get_array(value);
+            count = json_array_get_count(schema_array);
+            if (count == 0)
+                return JSONSuccess; /* Empty array allows all types */
+            /* Get first value from array, rest is ignored */
+            temp_schema_value = json_array_get_value(schema_array, 0);
+            for (i = 0; i < json_array_get_count(value_array); i++) {
+                temp_value = json_array_get_value(value_array, i);
+                if (json_validate(temp_schema_value, temp_value) == 0) {
+                    return JSONFailure;
+                }
+            }
+            return JSONSuccess;
+        case JSONObject:
+            schema_object = json_value_get_object(schema);
+            value_object = json_value_get_object(value);
+            count = json_object_get_count(schema_object);
+            if (count == 0)
+                return JSONSuccess; /* Empty object allows all objects */
+            else if (json_object_get_count(value_object) < count)
+                return JSONFailure; /* Tested object mustn't have less name-value pairs than schema */
+            for (i = 0; i < count; i++) {
+                key = json_object_get_name(schema_object, i);
+                temp_schema_value = json_object_get_value(schema_object, key);
+                temp_value = json_object_get_value(value_object, key);
+                if (temp_value == NULL)
+                    return JSONFailure;
+                if (json_validate(temp_schema_value, temp_value) == JSONFailure)
+                    return JSONFailure;
+            }
+            return JSONSuccess;
+        case JSONString: case JSONInteger: case JSONNumber: case JSONBoolean: case JSONNull:
+            return JSONSuccess; /* equality already tested before switch */
+        case JSONError: default:
+            return JSONFailure;
+    }
+}
+
+JSON_Status json_value_equals(const JSON_Value *a, const JSON_Value *b) {
+    JSON_Object *a_object = NULL, *b_object = NULL;
+    JSON_Array *a_array = NULL, *b_array = NULL;
+    const char *a_string = NULL, *b_string = NULL;
+    const char *key = NULL;
+    size_t a_count = 0, b_count = 0, i = 0;
+    JSON_Value_Type a_type, b_type;
+    a_type = json_value_get_type(a);
+    b_type = json_value_get_type(b);
+    if (a_type != b_type) {
+        return 0;
+    }
+    switch (a_type) {
+        case JSONArray:
+            a_array = json_value_get_array(a);
+            b_array = json_value_get_array(b);
+            a_count = json_array_get_count(a_array);
+            b_count = json_array_get_count(b_array);
+            if (a_count != b_count) {
+                return 0;
+            }
+            for (i = 0; i < a_count; i++) {
+                if (!json_value_equals(json_array_get_value(a_array, i),
+                                       json_array_get_value(b_array, i))) {
+                    return 0;
+                }
+            }
+            return 1;
+        case JSONObject:
+            a_object = json_value_get_object(a);
+            b_object = json_value_get_object(b);
+            a_count = json_object_get_count(a_object);
+            b_count = json_object_get_count(b_object);
+            if (a_count != b_count) {
+                return 0;
+            }
+            for (i = 0; i < a_count; i++) {
+                key = json_object_get_name(a_object, i);
+                if (!json_value_equals(json_object_get_value(a_object, key),
+                                       json_object_get_value(b_object, key))) {
+                    return 0;
+                }
+            }
+            return 1;
+        case JSONString:
+            a_string = json_value_get_string(a);
+            b_string = json_value_get_string(b);
+            return strcmp(a_string, b_string) == 0;
+        case JSONBoolean:
+            return json_value_get_boolean(a) == json_value_get_boolean(b);
+        case JSONInteger:
+            return json_value_get_integer(a) == json_value_get_integer(b);
+        case JSONNumber:
+            return fabs(json_value_get_number(a) - json_value_get_number(b)) < 0.000001; /* EPSILON */
+        case JSONError:
+            return 1;
+        case JSONNull:
+            return 1;
+        default:
+            return 1;
+    }
+}
+
+JSON_Value_Type json_type(const JSON_Value *value) {
+    return json_value_get_type(value);
+}
+
+JSON_Object * json_object (const JSON_Value *value) {
+    return json_value_get_object(value);
+}
+
+JSON_Array * json_array  (const JSON_Value *value) {
+    return json_value_get_array(value);
+}
+
+const char * json_string (const JSON_Value *value) {
+    return json_value_get_string(value);
+}
+
+jint json_integer (const JSON_Value *value) {
+    return json_value_get_integer(value);
+}
+
+double json_number (const JSON_Value *value) {
+    return json_value_get_number(value);
+}
+
+int json_boolean(const JSON_Value *value) {
+    return json_value_get_boolean(value);
+}
Index: lib/parson.h
===================================================================
--- lib/parson.h	(revision b75671d9ac15f883ddb0103e5fa33c6186c32f37)
+++ lib/parson.h	(revision b75671d9ac15f883ddb0103e5fa33c6186c32f37)
@@ -0,0 +1,222 @@
+/*
+ Parson ( http://kgabis.github.com/parson/ )
+ Copyright (c) 2012 - 2014 Krzysztof Gabis
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+*/
+
+#ifndef parson_parson_h
+#define parson_parson_h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif    
+    
+#include <stddef.h>   /* size_t */    
+    
+/* Types and enums */
+typedef struct json_object_t JSON_Object;
+typedef struct json_array_t  JSON_Array;
+typedef struct json_value_t  JSON_Value;
+
+typedef long long jint;
+
+enum json_value_type {
+    JSONError   = -1,
+    JSONNull    = 1,
+    JSONString  = 2,
+    JSONInteger = 7,
+    JSONNumber  = 3,
+    JSONObject  = 4,
+    JSONArray   = 5,
+    JSONBoolean = 6
+};
+typedef int JSON_Value_Type;
+    
+enum json_result_t {
+    JSONSuccess = 0,
+    JSONFailure = -1
+};
+typedef int JSON_Status;
+   
+/* Parses first JSON value in a file, returns NULL in case of error */
+JSON_Value * json_parse_file(const char *filename);
+
+/* Parses first JSON value in a file and ignores comments (/ * * / and //),
+   returns NULL in case of error */
+JSON_Value * json_parse_file_with_comments(const char *filename);
+   
+/*  Like json_parse_string, but *end is set to wherever it stopped parsing. */
+JSON_Value * json_parse_first(const char *string, const char **end);
+ 
+/*  Parses first JSON value in a string, returns NULL in case of error */
+JSON_Value * json_parse_string(const char *string);
+
+/*  Parses first JSON value in a string and ignores comments (/ * * / and //),
+    returns NULL in case of error */
+JSON_Value * json_parse_string_with_comments(const char *string);
+    
+/* Serialization */
+size_t      json_serialization_size(const JSON_Value *value);
+JSON_Status json_serialize_to_buffer(const JSON_Value *value, char *buf, size_t buf_size_in_bytes);
+JSON_Status json_serialize_to_file(const JSON_Value *value, const char *filename);
+char *      json_serialize_to_string(const JSON_Value *value);
+void        json_free_serialized_string(char *string); /* frees string from json_serialize_to_string */
+
+/* Comparing */
+int  json_value_equals(const JSON_Value *a, const JSON_Value *b);
+    
+/* Validation
+   This is *NOT* JSON Schema. It validates json by checking if object have identically 
+   named fields with matching types.
+   For example schema {"name":"", "age":0} will validate 
+   {"name":"Joe", "age":25} and {"name":"Joe", "age":25, "gender":"m"},
+   but not {"name":"Joe"} or {"name":"Joe", "age":"Cucumber"}.
+   In case of arrays, only first value in schema is checked against all values in tested array.
+   Empty objects ({}) validate all objects, empty arrays ([]) validate all arrays,
+   null validates values of every type.
+ */
+JSON_Status json_validate(const JSON_Value *schema, const JSON_Value *value);
+    
+/*
+ * JSON Object
+ */
+JSON_Value  * json_object_get_value  (const JSON_Object *object, const char *name);
+const char  * json_object_get_string (const JSON_Object *object, const char *name);
+JSON_Object * json_object_get_object (const JSON_Object *object, const char *name);
+JSON_Array  * json_object_get_array  (const JSON_Object *object, const char *name);
+jint          json_object_get_integer(const JSON_Object *object, const char *name); /* returns 0 on fail */
+double        json_object_get_number (const JSON_Object *object, const char *name); /* returns 0 on fail */
+int           json_object_get_boolean(const JSON_Object *object, const char *name); /* returns -1 on fail */
+
+/* dotget functions enable addressing values with dot notation in nested objects,
+ just like in structs or c++/java/c# objects (e.g. objectA.objectB.value).
+ Because valid names in JSON can contain dots, some values may be inaccessible
+ this way. */
+JSON_Value  * json_object_dotget_value  (const JSON_Object *object, const char *name);
+const char  * json_object_dotget_string (const JSON_Object *object, const char *name);
+JSON_Object * json_object_dotget_object (const JSON_Object *object, const char *name);
+JSON_Array  * json_object_dotget_array  (const JSON_Object *object, const char *name);
+jint          json_object_dotget_integer(const JSON_Object *object, const char *name); /* returns 0 on fail */
+double        json_object_dotget_number (const JSON_Object *object, const char *name); /* returns 0 on fail */
+int           json_object_dotget_boolean(const JSON_Object *object, const char *name); /* returns -1 on fail */
+
+/* Functions to get available names */
+size_t        json_object_get_count(const JSON_Object *object);
+const char  * json_object_get_name (const JSON_Object *object, size_t index);
+int           json_object_get_tuple(const JSON_Object *object, size_t index,
+                                    const char **key, const JSON_Value **value); /* 0 == fail */
+
+/* Creates new name-value pair or frees and replaces old value with new one. */
+JSON_Status json_object_set_value(JSON_Object *object, const char *name, JSON_Value *value);
+JSON_Status json_object_set_string(JSON_Object *object, const char *name, const char *string);
+JSON_Status json_object_set_integer(JSON_Object *object, const char *name, jint number);
+JSON_Status json_object_set_number(JSON_Object *object, const char *name, double number);
+JSON_Status json_object_set_boolean(JSON_Object *object, const char *name, int boolean);
+JSON_Status json_object_set_null(JSON_Object *object, const char *name);
+
+/* Works like dotget functions, but creates whole hierarchy if necessary. */
+JSON_Status json_object_dotset_value(JSON_Object *object, const char *name, JSON_Value *value);
+JSON_Status json_object_dotset_string(JSON_Object *object, const char *name, const char *string);
+JSON_Status json_object_dotset_integer(JSON_Object *object, const char *name, jint number);
+JSON_Status json_object_dotset_number(JSON_Object *object, const char *name, double number);
+JSON_Status json_object_dotset_boolean(JSON_Object *object, const char *name, int boolean);
+JSON_Status json_object_dotset_null(JSON_Object *object, const char *name);
+
+/* Frees and removes name-value pair */
+JSON_Status json_object_remove(JSON_Object *object, const char *name);
+
+/* Works like dotget function, but removes name-value pair only on exact match. */
+JSON_Status json_object_dotremove(JSON_Object *object, const char *key);
+
+/* Removes all name-value pairs in object */
+JSON_Status json_object_clear(JSON_Object *object);
+    
+/* 
+ *JSON Array 
+ */
+JSON_Value  * json_array_get_value  (const JSON_Array *array, size_t index);
+const char  * json_array_get_string (const JSON_Array *array, size_t index);
+JSON_Object * json_array_get_object (const JSON_Array *array, size_t index);
+JSON_Array  * json_array_get_array  (const JSON_Array *array, size_t index);
+jint          json_array_get_integer(const JSON_Array *array, size_t index); /* returns 0 on fail */
+double        json_array_get_number (const JSON_Array *array, size_t index); /* returns 0 on fail */
+int           json_array_get_boolean(const JSON_Array *array, size_t index); /* returns -1 on fail */
+size_t        json_array_get_count  (const JSON_Array *array);
+    
+/* Frees and removes value at given index, does nothing and returns JSONFailure if index doesn't exist.
+ * Order of values in array may change during execution.  */
+JSON_Status json_array_remove(JSON_Array *array, size_t i);
+
+/* Frees and removes from array value at given index and replaces it with given one.
+ * Does nothing and returns JSONFailure if index doesn't exist. */
+JSON_Status json_array_replace_value(JSON_Array *array, size_t i, JSON_Value *value);
+JSON_Status json_array_replace_string(JSON_Array *array, size_t i, const char* string);
+JSON_Status json_array_replace_integer(JSON_Array *array, size_t i, jint number);
+JSON_Status json_array_replace_number(JSON_Array *array, size_t i, double number);
+JSON_Status json_array_replace_boolean(JSON_Array *array, size_t i, int boolean);
+JSON_Status json_array_replace_null(JSON_Array *array, size_t i);
+
+/* Frees and removes all values from array */
+JSON_Status json_array_clear(JSON_Array *array);
+
+/* Appends new value at the end of array. */
+JSON_Status json_array_append_value(JSON_Array *array, JSON_Value *value);
+JSON_Status json_array_append_string(JSON_Array *array, const char *string);
+JSON_Status json_array_append_integer(JSON_Array *array, jint number);
+JSON_Status json_array_append_number(JSON_Array *array, double number);
+JSON_Status json_array_append_boolean(JSON_Array *array, int boolean);
+JSON_Status json_array_append_null(JSON_Array *array);
+    
+/*
+ *JSON Value
+ */
+JSON_Value * json_value_init_object (void);
+JSON_Value * json_value_init_array  (void);
+JSON_Value * json_value_init_string (const char *string); /* copies passed string */
+JSON_Value * json_value_init_integer(jint number);
+JSON_Value * json_value_init_number (double number);
+JSON_Value * json_value_init_boolean(int boolean);
+JSON_Value * json_value_init_null   (void);
+JSON_Value * json_value_deep_copy   (const JSON_Value *value);
+void         json_value_free        (JSON_Value *value);
+
+JSON_Value_Type json_value_get_type   (const JSON_Value *value);
+JSON_Object *   json_value_get_object (const JSON_Value *value);
+JSON_Array  *   json_value_get_array  (const JSON_Value *value);
+const char  *   json_value_get_string (const JSON_Value *value);
+jint            json_value_get_integer(const JSON_Value *value);
+double          json_value_get_number (const JSON_Value *value);
+int             json_value_get_boolean(const JSON_Value *value);
+
+/* Same as above, but shorter */
+JSON_Value_Type json_type   (const JSON_Value *value);
+JSON_Object *   json_object (const JSON_Value *value);
+JSON_Array  *   json_array  (const JSON_Value *value);
+const char  *   json_string (const JSON_Value *value);
+jint            json_integer(const JSON_Value *value);
+double          json_number (const JSON_Value *value);
+int             json_boolean(const JSON_Value *value);
+    
+#ifdef __cplusplus
+}
+#endif
+
+#endif
