1 files changed, 230 insertions, 229 deletions

diff --git a/src/ucl_emitter.c b/src/ucl_emitter.c
index 97d8f618021f..84c1b13e1865 100644
--- a/src/ucl_emitter.c
+++ b/src/ucl_emitter.c
@@ -40,20 +40,20 @@
  * Serialise UCL object to various of output formats
  */
 
-static void ucl_emitter_common_elt (struct ucl_emitter_context *ctx,
-		const ucl_object_t *obj, bool first, bool print_key, bool compact);
-
-#define UCL_EMIT_TYPE_OPS(type)		\
-	static void ucl_emit_ ## type ## _elt (struct ucl_emitter_context *ctx,	\
-		const ucl_object_t *obj, bool first, bool print_key);	\
-	static void ucl_emit_ ## type ## _start_obj (struct ucl_emitter_context *ctx,	\
-		const ucl_object_t *obj, bool first, bool print_key);	\
-	static void ucl_emit_ ## type## _start_array (struct ucl_emitter_context *ctx,	\
-		const ucl_object_t *obj, bool first, bool print_key);	\
-	static void ucl_emit_ ##type## _end_object (struct ucl_emitter_context *ctx,	\
-		const ucl_object_t *obj);	\
-	static void ucl_emit_ ##type## _end_array (struct ucl_emitter_context *ctx,	\
-		const ucl_object_t *obj)
+static void ucl_emitter_common_elt(struct ucl_emitter_context *ctx,
+								   const ucl_object_t *obj, bool first, bool print_key, bool compact);
+
+#define UCL_EMIT_TYPE_OPS(type)                                                                     \
+	static void ucl_emit_##type##_elt(struct ucl_emitter_context *ctx,                              \
+									  const ucl_object_t *obj, bool first, bool print_key);         \
+	static void ucl_emit_##type##_start_obj(struct ucl_emitter_context *ctx,                        \
+											const ucl_object_t *obj, bool first, bool print_key);   \
+	static void ucl_emit_##type##_start_array(struct ucl_emitter_context *ctx,                      \
+											  const ucl_object_t *obj, bool first, bool print_key); \
+	static void ucl_emit_##type##_end_object(struct ucl_emitter_context *ctx,                       \
+											 const ucl_object_t *obj);                              \
+	static void ucl_emit_##type##_end_array(struct ucl_emitter_context *ctx,                        \
+											const ucl_object_t *obj)
 
 /*
  * JSON format operations
@@ -64,27 +64,25 @@ UCL_EMIT_TYPE_OPS(config);
 UCL_EMIT_TYPE_OPS(yaml);
 UCL_EMIT_TYPE_OPS(msgpack);
 
-#define UCL_EMIT_TYPE_CONTENT(type) {	\
-	.ucl_emitter_write_elt = ucl_emit_ ## type ## _elt,	\
-	.ucl_emitter_start_object = ucl_emit_ ## type ##_start_obj,	\
-	.ucl_emitter_start_array = ucl_emit_ ## type ##_start_array,	\
-	.ucl_emitter_end_object = ucl_emit_ ## type ##_end_object,	\
-	.ucl_emitter_end_array = ucl_emit_ ## type ##_end_array	\
-}
+#define UCL_EMIT_TYPE_CONTENT(type) {                         \
+	.ucl_emitter_write_elt = ucl_emit_##type##_elt,           \
+	.ucl_emitter_start_object = ucl_emit_##type##_start_obj,  \
+	.ucl_emitter_start_array = ucl_emit_##type##_start_array, \
+	.ucl_emitter_end_object = ucl_emit_##type##_end_object,   \
+	.ucl_emitter_end_array = ucl_emit_##type##_end_array}
 
 const struct ucl_emitter_operations ucl_standartd_emitter_ops[] = {
 	[UCL_EMIT_JSON] = UCL_EMIT_TYPE_CONTENT(json),
 	[UCL_EMIT_JSON_COMPACT] = UCL_EMIT_TYPE_CONTENT(json_compact),
 	[UCL_EMIT_CONFIG] = UCL_EMIT_TYPE_CONTENT(config),
 	[UCL_EMIT_YAML] = UCL_EMIT_TYPE_CONTENT(yaml),
-	[UCL_EMIT_MSGPACK] = UCL_EMIT_TYPE_CONTENT(msgpack)
-};
+	[UCL_EMIT_MSGPACK] = UCL_EMIT_TYPE_CONTENT(msgpack)};
 
 /*
  * Utility to check whether we need a top object
  */
 #define UCL_EMIT_IDENT_TOP_OBJ(ctx, obj) ((ctx)->top != (obj) || \
-		((ctx)->id == UCL_EMIT_JSON_COMPACT || (ctx)->id == UCL_EMIT_JSON))
+										  ((ctx)->id == UCL_EMIT_JSON_COMPACT || (ctx)->id == UCL_EMIT_JSON))
 
 
 /**
@@ -93,11 +91,11 @@ const struct ucl_emitter_operations ucl_standartd_emitter_ops[] = {
  * @param tabs number of tabs to add
  */
 static inline void
-ucl_add_tabs (const struct ucl_emitter_functions *func, unsigned int tabs,
-		bool compact)
+ucl_add_tabs(const struct ucl_emitter_functions *func, unsigned int tabs,
+			 bool compact)
 {
 	if (!compact && tabs > 0) {
-		func->ucl_emitter_append_character (' ', tabs * 4, func->ud);
+		func->ucl_emitter_append_character(' ', tabs * 4, func->ud);
 	}
 }
 
@@ -107,8 +105,8 @@ ucl_add_tabs (const struct ucl_emitter_functions *func, unsigned int tabs,
  * @param obj
  */
 static void
-ucl_emitter_print_key (bool print_key, struct ucl_emitter_context *ctx,
-		const ucl_object_t *obj, bool compact)
+ucl_emitter_print_key(bool print_key, struct ucl_emitter_context *ctx,
+					  const ucl_object_t *obj, bool compact)
 {
 	const struct ucl_emitter_functions *func = ctx->func;
 
@@ -118,52 +116,52 @@ ucl_emitter_print_key (bool print_key, struct ucl_emitter_context *ctx,
 
 	if (ctx->id == UCL_EMIT_CONFIG) {
 		if (obj->flags & UCL_OBJECT_NEED_KEY_ESCAPE) {
-			ucl_elt_string_write_json (obj->key, obj->keylen, ctx);
+			ucl_elt_string_write_json(obj->key, obj->keylen, ctx);
 		}
 		else {
-			func->ucl_emitter_append_len (obj->key, obj->keylen, func->ud);
+			func->ucl_emitter_append_len(obj->key, obj->keylen, func->ud);
 		}
 
 		if (obj->type != UCL_OBJECT && obj->type != UCL_ARRAY) {
-			func->ucl_emitter_append_len (" = ", 3, func->ud);
+			func->ucl_emitter_append_len(" = ", 3, func->ud);
 		}
 		else {
-			func->ucl_emitter_append_character (' ', 1, func->ud);
+			func->ucl_emitter_append_character(' ', 1, func->ud);
 		}
 	}
 	else if (ctx->id == UCL_EMIT_YAML) {
 		if (obj->keylen > 0 && (obj->flags & UCL_OBJECT_NEED_KEY_ESCAPE)) {
-			ucl_elt_string_write_json (obj->key, obj->keylen, ctx);
+			ucl_elt_string_write_json(obj->key, obj->keylen, ctx);
 		}
 		else if (obj->keylen > 0) {
-			func->ucl_emitter_append_len (obj->key, obj->keylen, func->ud);
+			func->ucl_emitter_append_len(obj->key, obj->keylen, func->ud);
 		}
 		else {
-			func->ucl_emitter_append_len ("null", 4, func->ud);
+			func->ucl_emitter_append_len("null", 4, func->ud);
 		}
 
-		func->ucl_emitter_append_len (": ", 2, func->ud);
+		func->ucl_emitter_append_len(": ", 2, func->ud);
 	}
 	else {
 		if (obj->keylen > 0) {
-			ucl_elt_string_write_json (obj->key, obj->keylen, ctx);
+			ucl_elt_string_write_json(obj->key, obj->keylen, ctx);
 		}
 		else {
-			func->ucl_emitter_append_len ("null", 4, func->ud);
+			func->ucl_emitter_append_len("null", 4, func->ud);
 		}
 
 		if (compact) {
-			func->ucl_emitter_append_character (':', 1, func->ud);
+			func->ucl_emitter_append_character(':', 1, func->ud);
 		}
 		else {
-			func->ucl_emitter_append_len (": ", 2, func->ud);
+			func->ucl_emitter_append_len(": ", 2, func->ud);
 		}
 	}
 }
 
 static void
-ucl_emitter_finish_object (struct ucl_emitter_context *ctx,
-		const ucl_object_t *obj, bool compact, bool is_array)
+ucl_emitter_finish_object(struct ucl_emitter_context *ctx,
+						  const ucl_object_t *obj, bool compact, bool is_array)
 {
 	const struct ucl_emitter_functions *func = ctx->func;
 
@@ -171,15 +169,15 @@ ucl_emitter_finish_object (struct ucl_emitter_context *ctx,
 		if (obj->type != UCL_OBJECT && obj->type != UCL_ARRAY) {
 			if (!is_array) {
 				/* Objects are split by ';' */
-				func->ucl_emitter_append_len (";\n", 2, func->ud);
+				func->ucl_emitter_append_len(";\n", 2, func->ud);
 			}
 			else {
 				/* Use commas for arrays */
-				func->ucl_emitter_append_len (",\n", 2, func->ud);
+				func->ucl_emitter_append_len(",\n", 2, func->ud);
 			}
 		}
 		else {
-			func->ucl_emitter_append_character ('\n', 1, func->ud);
+			func->ucl_emitter_append_character('\n', 1, func->ud);
 		}
 	}
 }
@@ -190,27 +188,27 @@ ucl_emitter_finish_object (struct ucl_emitter_context *ctx,
  * @param compact compact flag
  */
 static void
-ucl_emitter_common_end_object (struct ucl_emitter_context *ctx,
-		const ucl_object_t *obj, bool compact)
+ucl_emitter_common_end_object(struct ucl_emitter_context *ctx,
+							  const ucl_object_t *obj, bool compact)
 {
 	const struct ucl_emitter_functions *func = ctx->func;
 
 	if (UCL_EMIT_IDENT_TOP_OBJ(ctx, obj)) {
-		ctx->indent --;
+		ctx->indent--;
 		if (compact) {
-			func->ucl_emitter_append_character ('}', 1, func->ud);
+			func->ucl_emitter_append_character('}', 1, func->ud);
 		}
 		else {
 			if (ctx->id != UCL_EMIT_CONFIG) {
 				/* newline is already added for this format */
-				func->ucl_emitter_append_character ('\n', 1, func->ud);
+				func->ucl_emitter_append_character('\n', 1, func->ud);
 			}
-			ucl_add_tabs (func, ctx->indent, compact);
-			func->ucl_emitter_append_character ('}', 1, func->ud);
+			ucl_add_tabs(func, ctx->indent, compact);
+			func->ucl_emitter_append_character('}', 1, func->ud);
 		}
 	}
 
-	ucl_emitter_finish_object (ctx, obj, compact, false);
+	ucl_emitter_finish_object(ctx, obj, compact, false);
 }
 
 /**
@@ -219,25 +217,25 @@ ucl_emitter_common_end_object (struct ucl_emitter_context *ctx,
  * @param compact compact flag
  */
 static void
-ucl_emitter_common_end_array (struct ucl_emitter_context *ctx,
-		const ucl_object_t *obj, bool compact)
+ucl_emitter_common_end_array(struct ucl_emitter_context *ctx,
+							 const ucl_object_t *obj, bool compact)
 {
 	const struct ucl_emitter_functions *func = ctx->func;
 
-	ctx->indent --;
+	ctx->indent--;
 	if (compact) {
-		func->ucl_emitter_append_character (']', 1, func->ud);
+		func->ucl_emitter_append_character(']', 1, func->ud);
 	}
 	else {
 		if (ctx->id != UCL_EMIT_CONFIG) {
 			/* newline is already added for this format */
-			func->ucl_emitter_append_character ('\n', 1, func->ud);
+			func->ucl_emitter_append_character('\n', 1, func->ud);
 		}
-		ucl_add_tabs (func, ctx->indent, compact);
-		func->ucl_emitter_append_character (']', 1, func->ud);
+		ucl_add_tabs(func, ctx->indent, compact);
+		func->ucl_emitter_append_character(']', 1, func->ud);
 	}
 
-	ucl_emitter_finish_object (ctx, obj, compact, true);
+	ucl_emitter_finish_object(ctx, obj, compact, true);
 }
 
 /**
@@ -247,8 +245,8 @@ ucl_emitter_common_end_array (struct ucl_emitter_context *ctx,
  * @param compact compact flag
  */
 static void
-ucl_emitter_common_start_array (struct ucl_emitter_context *ctx,
-		const ucl_object_t *obj, bool first, bool print_key, bool compact)
+ucl_emitter_common_start_array(struct ucl_emitter_context *ctx,
+							   const ucl_object_t *obj, bool first, bool print_key, bool compact)
 {
 	const ucl_object_t *cur;
 	ucl_object_iter_t iter = NULL;
@@ -257,33 +255,34 @@ ucl_emitter_common_start_array (struct ucl_emitter_context *ctx,
 
 	if (ctx->id != UCL_EMIT_CONFIG && !first) {
 		if (compact) {
-			func->ucl_emitter_append_character (',', 1, func->ud);
+			func->ucl_emitter_append_character(',', 1, func->ud);
 		}
 		else {
 			if (ctx->id == UCL_EMIT_YAML && ctx->indent == 0) {
-				func->ucl_emitter_append_len ("\n", 1, func->ud);
-			} else {
-				func->ucl_emitter_append_len (",\n", 2, func->ud);
+				func->ucl_emitter_append_len("\n", 1, func->ud);
+			}
+			else {
+				func->ucl_emitter_append_len(",\n", 2, func->ud);
 			}
 		}
-		ucl_add_tabs (func, ctx->indent, compact);
+		ucl_add_tabs(func, ctx->indent, compact);
 	}
 
-	ucl_emitter_print_key (print_key, ctx, obj, compact);
+	ucl_emitter_print_key(print_key, ctx, obj, compact);
 
 	if (compact) {
-		func->ucl_emitter_append_character ('[', 1, func->ud);
+		func->ucl_emitter_append_character('[', 1, func->ud);
 	}
 	else {
-		func->ucl_emitter_append_len ("[\n", 2, func->ud);
+		func->ucl_emitter_append_len("[\n", 2, func->ud);
 	}
 
-	ctx->indent ++;
+	ctx->indent++;
 
 	if (obj->type == UCL_ARRAY) {
 		/* explicit array */
-		while ((cur = ucl_object_iterate (obj, &iter, true)) != NULL) {
-			ucl_emitter_common_elt (ctx, cur, first_key, false, compact);
+		while ((cur = ucl_object_iterate(obj, &iter, true)) != NULL) {
+			ucl_emitter_common_elt(ctx, cur, first_key, false, compact);
 			first_key = false;
 		}
 	}
@@ -291,13 +290,11 @@ ucl_emitter_common_start_array (struct ucl_emitter_context *ctx,
 		/* implicit array */
 		cur = obj;
 		while (cur) {
-			ucl_emitter_common_elt (ctx, cur, first_key, false, compact);
+			ucl_emitter_common_elt(ctx, cur, first_key, false, compact);
 			first_key = false;
 			cur = cur->next;
 		}
 	}
-
-
 }
 
 /**
@@ -307,8 +304,8 @@ ucl_emitter_common_start_array (struct ucl_emitter_context *ctx,
  * @param compact compact flag
  */
 static void
-ucl_emitter_common_start_object (struct ucl_emitter_context *ctx,
-		const ucl_object_t *obj, bool first, bool print_key, bool compact)
+ucl_emitter_common_start_object(struct ucl_emitter_context *ctx,
+								const ucl_object_t *obj, bool first, bool print_key, bool compact)
 {
 	ucl_hash_iter_t it = NULL;
 	const ucl_object_t *cur, *elt;
@@ -317,57 +314,53 @@ ucl_emitter_common_start_object (struct ucl_emitter_context *ctx,
 
 	if (ctx->id != UCL_EMIT_CONFIG && !first) {
 		if (compact) {
-			func->ucl_emitter_append_character (',', 1, func->ud);
+			func->ucl_emitter_append_character(',', 1, func->ud);
 		}
 		else {
 			if (ctx->id == UCL_EMIT_YAML && ctx->indent == 0) {
-				func->ucl_emitter_append_len ("\n", 1, func->ud);
-			} else {
-				func->ucl_emitter_append_len (",\n", 2, func->ud);
+				func->ucl_emitter_append_len("\n", 1, func->ud);
+			}
+			else {
+				func->ucl_emitter_append_len(",\n", 2, func->ud);
 			}
 		}
-		ucl_add_tabs (func, ctx->indent, compact);
+		ucl_add_tabs(func, ctx->indent, compact);
 	}
 
-	ucl_emitter_print_key (print_key, ctx, obj, compact);
+	ucl_emitter_print_key(print_key, ctx, obj, compact);
 	/*
 	 * Print <ident_level>{
 	 * <ident_level + 1><object content>
 	 */
 	if (UCL_EMIT_IDENT_TOP_OBJ(ctx, obj)) {
 		if (compact) {
-			func->ucl_emitter_append_character ('{', 1, func->ud);
+			func->ucl_emitter_append_character('{', 1, func->ud);
 		}
 		else {
-			func->ucl_emitter_append_len ("{\n", 2, func->ud);
+			func->ucl_emitter_append_len("{\n", 2, func->ud);
 		}
-		ctx->indent ++;
+		ctx->indent++;
 	}
 
-	while ((cur = ucl_hash_iterate (obj->value.ov, &it))) {
+	while ((cur = ucl_hash_iterate(obj->value.ov, &it))) {
 
 		if (ctx->id == UCL_EMIT_CONFIG) {
-			LL_FOREACH (cur, elt) {
-				ucl_emitter_common_elt (ctx, elt, first_key, true, compact);
+			LL_FOREACH(cur, elt)
+			{
+				ucl_emitter_common_elt(ctx, elt, first_key, true, compact);
 			}
 		}
 		else {
 			/* Expand implicit arrays */
 			if (cur->next != NULL) {
-				if (!first_key) {
-					if (compact) {
-						func->ucl_emitter_append_character (',', 1, func->ud);
-					}
-					else {
-						func->ucl_emitter_append_len (",\n", 2, func->ud);
-					}
+				if (first_key) {
+					ucl_add_tabs(func, ctx->indent, compact);
 				}
-				ucl_add_tabs (func, ctx->indent, compact);
-				ucl_emitter_common_start_array (ctx, cur, first_key, true, compact);
-				ucl_emitter_common_end_array (ctx, cur, compact);
+				ucl_emitter_common_start_array(ctx, cur, first_key, true, compact);
+				ucl_emitter_common_end_array(ctx, cur, compact);
 			}
 			else {
-				ucl_emitter_common_elt (ctx, cur, first_key, true, compact);
+				ucl_emitter_common_elt(ctx, cur, first_key, true, compact);
 			}
 		}
 
@@ -384,8 +377,8 @@ ucl_emitter_common_start_object (struct ucl_emitter_context *ctx,
  * @param compact compact output
  */
 static void
-ucl_emitter_common_elt (struct ucl_emitter_context *ctx,
-		const ucl_object_t *obj, bool first, bool print_key, bool compact)
+ucl_emitter_common_elt(struct ucl_emitter_context *ctx,
+					   const ucl_object_t *obj, bool first, bool print_key, bool compact)
 {
 	const struct ucl_emitter_functions *func = ctx->func;
 	bool flag;
@@ -395,31 +388,33 @@ ucl_emitter_common_elt (struct ucl_emitter_context *ctx,
 
 	if (ctx->id != UCL_EMIT_CONFIG && !first) {
 		if (compact) {
-			func->ucl_emitter_append_character (',', 1, func->ud);
+			func->ucl_emitter_append_character(',', 1, func->ud);
 		}
 		else {
 			if (ctx->id == UCL_EMIT_YAML && ctx->indent == 0) {
-				func->ucl_emitter_append_len ("\n", 1, func->ud);
-			} else {
-				func->ucl_emitter_append_len (",\n", 2, func->ud);
+				func->ucl_emitter_append_len("\n", 1, func->ud);
+			}
+			else {
+				func->ucl_emitter_append_len(",\n", 2, func->ud);
 			}
 		}
 	}
 
-	ucl_add_tabs (func, ctx->indent, compact);
+	ucl_add_tabs(func, ctx->indent, compact);
 
 	if (ctx->comments && ctx->id == UCL_EMIT_CONFIG) {
-		comment = ucl_object_lookup_len (ctx->comments, (const char *)&obj,
-				sizeof (void *));
+		comment = ucl_object_lookup_len(ctx->comments, (const char *) &obj,
+										sizeof(void *));
 
 		if (comment) {
 			if (!(comment->flags & UCL_OBJECT_INHERITED)) {
-				DL_FOREACH (comment, cur_comment) {
-					func->ucl_emitter_append_len (cur_comment->value.sv,
-							cur_comment->len,
-							func->ud);
-					func->ucl_emitter_append_character ('\n', 1, func->ud);
-					ucl_add_tabs (func, ctx->indent, compact);
+				DL_FOREACH(comment, cur_comment)
+				{
+					func->ucl_emitter_append_len(cur_comment->value.sv,
+												 cur_comment->len,
+												 func->ud);
+					func->ucl_emitter_append_character('\n', 1, func->ud);
+					ucl_add_tabs(func, ctx->indent, compact);
 				}
 
 				comment = NULL;
@@ -429,81 +424,84 @@ ucl_emitter_common_elt (struct ucl_emitter_context *ctx,
 
 	switch (obj->type) {
 	case UCL_INT:
-		ucl_emitter_print_key (print_key, ctx, obj, compact);
-		func->ucl_emitter_append_int (ucl_object_toint (obj), func->ud);
-		ucl_emitter_finish_object (ctx, obj, compact, !print_key);
+		ucl_emitter_print_key(print_key, ctx, obj, compact);
+		func->ucl_emitter_append_int(ucl_object_toint(obj), func->ud);
+		ucl_emitter_finish_object(ctx, obj, compact, !print_key);
 		break;
 	case UCL_FLOAT:
 	case UCL_TIME:
-		ucl_emitter_print_key (print_key, ctx, obj, compact);
-		func->ucl_emitter_append_double (ucl_object_todouble (obj), func->ud);
-		ucl_emitter_finish_object (ctx, obj, compact, !print_key);
+		ucl_emitter_print_key(print_key, ctx, obj, compact);
+		func->ucl_emitter_append_double(ucl_object_todouble(obj), func->ud);
+		ucl_emitter_finish_object(ctx, obj, compact, !print_key);
 		break;
 	case UCL_BOOLEAN:
-		ucl_emitter_print_key (print_key, ctx, obj, compact);
-		flag = ucl_object_toboolean (obj);
+		ucl_emitter_print_key(print_key, ctx, obj, compact);
+		flag = ucl_object_toboolean(obj);
 		if (flag) {
-			func->ucl_emitter_append_len ("true", 4, func->ud);
+			func->ucl_emitter_append_len("true", 4, func->ud);
 		}
 		else {
-			func->ucl_emitter_append_len ("false", 5, func->ud);
+			func->ucl_emitter_append_len("false", 5, func->ud);
 		}
-		ucl_emitter_finish_object (ctx, obj, compact, !print_key);
+		ucl_emitter_finish_object(ctx, obj, compact, !print_key);
 		break;
 	case UCL_STRING:
-		ucl_emitter_print_key (print_key, ctx, obj, compact);
+		ucl_emitter_print_key(print_key, ctx, obj, compact);
 		if (ctx->id == UCL_EMIT_CONFIG) {
-			if (ucl_maybe_long_string (obj)) {
-				ucl_elt_string_write_multiline (obj->value.sv, obj->len, ctx);
-			} else {
+			if (ucl_maybe_long_string(obj)) {
+				ucl_elt_string_write_multiline(obj->value.sv, obj->len, ctx);
+			}
+			else {
 				if (obj->flags & UCL_OBJECT_SQUOTED) {
-					ucl_elt_string_write_squoted (obj->value.sv, obj->len, ctx);
-				} else {
-					ucl_elt_string_write_json (obj->value.sv, obj->len, ctx);
+					ucl_elt_string_write_squoted(obj->value.sv, obj->len, ctx);
+				}
+				else {
+					ucl_elt_string_write_json(obj->value.sv, obj->len, ctx);
 				}
 			}
 		}
 		else {
-			ucl_elt_string_write_json (obj->value.sv, obj->len, ctx);
+			ucl_elt_string_write_json(obj->value.sv, obj->len, ctx);
 		}
-		ucl_emitter_finish_object (ctx, obj, compact, !print_key);
+		ucl_emitter_finish_object(ctx, obj, compact, !print_key);
 		break;
 	case UCL_NULL:
-		ucl_emitter_print_key (print_key, ctx, obj, compact);
-		func->ucl_emitter_append_len ("null", 4, func->ud);
-		ucl_emitter_finish_object (ctx, obj, compact, !print_key);
+		ucl_emitter_print_key(print_key, ctx, obj, compact);
+		func->ucl_emitter_append_len("null", 4, func->ud);
+		ucl_emitter_finish_object(ctx, obj, compact, !print_key);
 		break;
 	case UCL_OBJECT:
-		ucl_emitter_common_start_object (ctx, obj, true, print_key, compact);
-		ucl_emitter_common_end_object (ctx, obj, compact);
+		ucl_emitter_common_start_object(ctx, obj, true, print_key, compact);
+		ucl_emitter_common_end_object(ctx, obj, compact);
 		break;
 	case UCL_ARRAY:
-		ucl_emitter_common_start_array (ctx, obj, true, print_key, compact);
-		ucl_emitter_common_end_array (ctx, obj, compact);
+		ucl_emitter_common_start_array(ctx, obj, true, print_key, compact);
+		ucl_emitter_common_end_array(ctx, obj, compact);
 		break;
 	case UCL_USERDATA:
-		ud = (struct ucl_object_userdata *)obj;
-		ucl_emitter_print_key (print_key, ctx, obj, compact);
+		ud = (struct ucl_object_userdata *) obj;
+		ucl_emitter_print_key(print_key, ctx, obj, compact);
 		if (ud->emitter) {
-			ud_out = ud->emitter (obj->value.ud);
+			ud_out = ud->emitter(obj->value.ud);
 			if (ud_out == NULL) {
 				ud_out = "null";
 			}
 		}
-		ucl_elt_string_write_json (ud_out, strlen (ud_out), ctx);
-		ucl_emitter_finish_object (ctx, obj, compact, !print_key);
+		ucl_elt_string_write_json(ud_out, strlen(ud_out), ctx);
+		ucl_emitter_finish_object(ctx, obj, compact, !print_key);
 		break;
 	}
 
 	if (comment) {
-		DL_FOREACH (comment, cur_comment) {
-			func->ucl_emitter_append_len (cur_comment->value.sv,
-					cur_comment->len,
-					func->ud);
-			func->ucl_emitter_append_character ('\n', 1, func->ud);
+		DL_FOREACH(comment, cur_comment)
+		{
+			func->ucl_emitter_append_len(cur_comment->value.sv,
+										 cur_comment->len,
+										 func->ud);
+			func->ucl_emitter_append_character('\n', 1, func->ud);
 
 			if (cur_comment->next) {
-				ucl_add_tabs (func, ctx->indent, compact);
+				ucl_add_tabs(func, ctx->indent, compact);
 			}
 		}
 	}
@@ -512,26 +510,31 @@ ucl_emitter_common_elt (struct ucl_emitter_context *ctx,
 /*
  * Specific standard implementations of the emitter functions
  */
-#define UCL_EMIT_TYPE_IMPL(type, compact)		\
-	static void ucl_emit_ ## type ## _elt (struct ucl_emitter_context *ctx,	\
-		const ucl_object_t *obj, bool first, bool print_key) {	\
-		ucl_emitter_common_elt (ctx, obj, first, print_key, (compact));	\
-	}	\
-	static void ucl_emit_ ## type ## _start_obj (struct ucl_emitter_context *ctx,	\
-		const ucl_object_t *obj, bool first, bool print_key) {	\
-		ucl_emitter_common_start_object (ctx, obj, first, print_key, (compact));	\
-	}	\
-	static void ucl_emit_ ## type## _start_array (struct ucl_emitter_context *ctx,	\
-		const ucl_object_t *obj, bool first, bool print_key) {	\
-		ucl_emitter_common_start_array (ctx, obj, first, print_key, (compact));	\
-	}	\
-	static void ucl_emit_ ##type## _end_object (struct ucl_emitter_context *ctx,	\
-		const ucl_object_t *obj) {	\
-		ucl_emitter_common_end_object (ctx, obj, (compact));	\
-	}	\
-	static void ucl_emit_ ##type## _end_array (struct ucl_emitter_context *ctx,	\
-		const ucl_object_t *obj) {	\
-		ucl_emitter_common_end_array (ctx, obj, (compact));	\
+#define UCL_EMIT_TYPE_IMPL(type, compact)                                                          \
+	static void ucl_emit_##type##_elt(struct ucl_emitter_context *ctx,                             \
+									  const ucl_object_t *obj, bool first, bool print_key)         \
+	{                                                                                              \
+		ucl_emitter_common_elt(ctx, obj, first, print_key, (compact));                             \
+	}                                                                                              \
+	static void ucl_emit_##type##_start_obj(struct ucl_emitter_context *ctx,                       \
+											const ucl_object_t *obj, bool first, bool print_key)   \
+	{                                                                                              \
+		ucl_emitter_common_start_object(ctx, obj, first, print_key, (compact));                    \
+	}                                                                                              \
+	static void ucl_emit_##type##_start_array(struct ucl_emitter_context *ctx,                     \
+											  const ucl_object_t *obj, bool first, bool print_key) \
+	{                                                                                              \
+		ucl_emitter_common_start_array(ctx, obj, first, print_key, (compact));                     \
+	}                                                                                              \
+	static void ucl_emit_##type##_end_object(struct ucl_emitter_context *ctx,                      \
+											 const ucl_object_t *obj)                              \
+	{                                                                                              \
+		ucl_emitter_common_end_object(ctx, obj, (compact));                                        \
+	}                                                                                              \
+	static void ucl_emit_##type##_end_array(struct ucl_emitter_context *ctx,                       \
+											const ucl_object_t *obj)                               \
+	{                                                                                              \
+		ucl_emitter_common_end_array(ctx, obj, (compact));                                         \
 	}
 
 UCL_EMIT_TYPE_IMPL(json, false)
@@ -540,8 +543,8 @@ UCL_EMIT_TYPE_IMPL(config, false)
 UCL_EMIT_TYPE_IMPL(yaml, false)
 
 static void
-ucl_emit_msgpack_elt (struct ucl_emitter_context *ctx,
-		const ucl_object_t *obj, bool _first, bool print_key)
+ucl_emit_msgpack_elt(struct ucl_emitter_context *ctx,
+					 const ucl_object_t *obj, bool _first, bool print_key)
 {
 	ucl_object_iter_t it;
 	struct ucl_object_userdata *ud;
@@ -550,46 +553,47 @@ ucl_emit_msgpack_elt (struct ucl_emitter_context *ctx,
 
 	switch (obj->type) {
 	case UCL_INT:
-		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
-		ucl_emitter_print_int_msgpack (ctx, ucl_object_toint (obj));
+		ucl_emitter_print_key_msgpack(print_key, ctx, obj);
+		ucl_emitter_print_int_msgpack(ctx, ucl_object_toint(obj));
 		break;
 
 	case UCL_FLOAT:
 	case UCL_TIME:
-		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
-		ucl_emitter_print_double_msgpack (ctx, ucl_object_todouble (obj));
+		ucl_emitter_print_key_msgpack(print_key, ctx, obj);
+		ucl_emitter_print_double_msgpack(ctx, ucl_object_todouble(obj));
 		break;
 
 	case UCL_BOOLEAN:
-		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
-		ucl_emitter_print_bool_msgpack (ctx, ucl_object_toboolean (obj));
+		ucl_emitter_print_key_msgpack(print_key, ctx, obj);
+		ucl_emitter_print_bool_msgpack(ctx, ucl_object_toboolean(obj));
 		break;
 
 	case UCL_STRING:
-		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
+		ucl_emitter_print_key_msgpack(print_key, ctx, obj);
 
 		if (obj->flags & UCL_OBJECT_BINARY) {
-			ucl_emitter_print_binary_string_msgpack (ctx, obj->value.sv,
-					obj->len);
+			ucl_emitter_print_binary_string_msgpack(ctx, obj->value.sv,
+													obj->len);
 		}
 		else {
-			ucl_emitter_print_string_msgpack (ctx, obj->value.sv, obj->len);
+			ucl_emitter_print_string_msgpack(ctx, obj->value.sv, obj->len);
 		}
 		break;
 
 	case UCL_NULL:
-		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
-		ucl_emitter_print_null_msgpack (ctx);
+		ucl_emitter_print_key_msgpack(print_key, ctx, obj);
+		ucl_emitter_print_null_msgpack(ctx);
 		break;
 
 	case UCL_OBJECT:
-		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
-		ucl_emit_msgpack_start_obj (ctx, obj, false, print_key);
+		ucl_emitter_print_key_msgpack(print_key, ctx, obj);
+		ucl_emit_msgpack_start_obj(ctx, obj, false, print_key);
 		it = NULL;
 
-		while ((cur = ucl_object_iterate (obj, &it, true)) != NULL) {
-			LL_FOREACH (cur, celt) {
-				ucl_emit_msgpack_elt (ctx, celt, false, true);
+		while ((cur = ucl_object_iterate(obj, &it, true)) != NULL) {
+			LL_FOREACH(cur, celt)
+			{
+				ucl_emit_msgpack_elt(ctx, celt, false, true);
 				/* XXX:
 				 * in msgpack the length of objects is encoded within a single elt
 				 * so in case of multi-value keys we are using merely the first
@@ -602,68 +606,66 @@ ucl_emit_msgpack_elt (struct ucl_emitter_context *ctx,
 		break;
 
 	case UCL_ARRAY:
-		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
-		ucl_emit_msgpack_start_array (ctx, obj, false, print_key);
+		ucl_emitter_print_key_msgpack(print_key, ctx, obj);
+		ucl_emit_msgpack_start_array(ctx, obj, false, print_key);
 		it = NULL;
 
-		while ((cur = ucl_object_iterate (obj, &it, true)) != NULL) {
-			ucl_emit_msgpack_elt (ctx, cur, false, false);
+		while ((cur = ucl_object_iterate(obj, &it, true)) != NULL) {
+			ucl_emit_msgpack_elt(ctx, cur, false, false);
 		}
 
 		break;
 
 	case UCL_USERDATA:
-		ud = (struct ucl_object_userdata *)obj;
-		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
+		ud = (struct ucl_object_userdata *) obj;
+		ucl_emitter_print_key_msgpack(print_key, ctx, obj);
 
 		if (ud->emitter) {
-			ud_out = ud->emitter (obj->value.ud);
+			ud_out = ud->emitter(obj->value.ud);
 			if (ud_out == NULL) {
 				ud_out = "null";
 			}
 		}
-		ucl_emitter_print_string_msgpack (ctx, obj->value.sv, obj->len);
+		ucl_emitter_print_string_msgpack(ctx, obj->value.sv, obj->len);
 		break;
 	}
 }
 
 static void
-ucl_emit_msgpack_start_obj (struct ucl_emitter_context *ctx,
-		const ucl_object_t *obj, bool _first, bool _print_key)
+ucl_emit_msgpack_start_obj(struct ucl_emitter_context *ctx,
+						   const ucl_object_t *obj, bool _first, bool _print_key)
 {
-	ucl_emitter_print_object_msgpack (ctx, obj->len);
+	ucl_emitter_print_object_msgpack(ctx, obj->len);
 }
 
 static void
-ucl_emit_msgpack_start_array (struct ucl_emitter_context *ctx,
-		const ucl_object_t *obj, bool _first, bool _print_key)
+ucl_emit_msgpack_start_array(struct ucl_emitter_context *ctx,
+							 const ucl_object_t *obj, bool _first, bool _print_key)
 {
-	ucl_emitter_print_array_msgpack (ctx, obj->len);
+	ucl_emitter_print_array_msgpack(ctx, obj->len);
 }
 
 static void
-ucl_emit_msgpack_end_object (struct ucl_emitter_context *ctx,
-		const ucl_object_t *obj)
+ucl_emit_msgpack_end_object(struct ucl_emitter_context *ctx,
+							const ucl_object_t *obj)
 {
-
 }
 
 static void
-ucl_emit_msgpack_end_array (struct ucl_emitter_context *ctx,
-		const ucl_object_t *obj)
+ucl_emit_msgpack_end_array(struct ucl_emitter_context *ctx,
+						   const ucl_object_t *obj)
 {
-
 }
 
 unsigned char *
-ucl_object_emit (const ucl_object_t *obj, enum ucl_emitter emit_type)
+ucl_object_emit(const ucl_object_t *obj, enum ucl_emitter emit_type)
 {
-	return ucl_object_emit_len (obj, emit_type, NULL);
+	return ucl_object_emit_len(obj, emit_type, NULL);
 }
 
 unsigned char *
-ucl_object_emit_len (const ucl_object_t *obj, enum ucl_emitter emit_type,
-		size_t *outlen)
+ucl_object_emit_len(const ucl_object_t *obj, enum ucl_emitter emit_type,
+					size_t *outlen)
 {
 	unsigned char *res = NULL;
 	struct ucl_emitter_functions *func;
@@ -673,40 +675,39 @@ ucl_object_emit_len (const ucl_object_t *obj, enum ucl_emitter emit_type,
 		return NULL;
 	}
 
-	func = ucl_object_emit_memory_funcs ((void **)&res);
+	func = ucl_object_emit_memory_funcs((void **) &res);
 
 	if (func != NULL) {
 		s = func->ud;
-		ucl_object_emit_full (obj, emit_type, func, NULL);
+		ucl_object_emit_full(obj, emit_type, func, NULL);
 
 		if (outlen != NULL) {
 			*outlen = s->i;
 		}
 
-		ucl_object_emit_funcs_free (func);
+		ucl_object_emit_funcs_free(func);
 	}
 
 	return res;
 }
 
-bool
-ucl_object_emit_full (const ucl_object_t *obj, enum ucl_emitter emit_type,
-		struct ucl_emitter_functions *emitter,
-		const ucl_object_t *comments)
+bool ucl_object_emit_full(const ucl_object_t *obj, enum ucl_emitter emit_type,
+						  struct ucl_emitter_functions *emitter,
+						  const ucl_object_t *comments)
 {
 	const struct ucl_emitter_context *ctx;
 	struct ucl_emitter_context my_ctx;
 	bool res = false;
 
-	ctx = ucl_emit_get_standard_context (emit_type);
+	ctx = ucl_emit_get_standard_context(emit_type);
 	if (ctx != NULL) {
-		memcpy (&my_ctx, ctx, sizeof (my_ctx));
+		memcpy(&my_ctx, ctx, sizeof(my_ctx));
 		my_ctx.func = emitter;
 		my_ctx.indent = 0;
 		my_ctx.top = obj;
 		my_ctx.comments = comments;
 
-		my_ctx.ops->ucl_emitter_write_elt (&my_ctx, obj, true, false);
+		my_ctx.ops->ucl_emitter_write_elt(&my_ctx, obj, true, false);
 		res = true;
 	}