xref: /freebsd/contrib/libucl/src/ucl_emitter.c (revision 8ef24a0d4b28fe230e20637f56869cc4148cd2ca) 
1 /* Copyright (c) 2013, Vsevolod Stakhov
2  * All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are met:
6  *       * Redistributions of source code must retain the above copyright
7  *         notice, this list of conditions and the following disclaimer.
8  *       * Redistributions in binary form must reproduce the above copyright
9  *         notice, this list of conditions and the following disclaimer in the
10  *         documentation and/or other materials provided with the distribution.
11  *
12  * THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY
13  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
14  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
15  * DISCLAIMED. IN NO EVENT SHALL AUTHOR BE LIABLE FOR ANY
16  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
17  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
18  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
19  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
20  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
21  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22  */
23 
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27 
28 #include "ucl.h"
29 #include "ucl_internal.h"
30 #include "ucl_chartable.h"
31 #ifdef HAVE_FLOAT_H
32 #include <float.h>
33 #endif
34 #ifdef HAVE_MATH_H
35 #include <math.h>
36 #endif
37 
38 /**
39  * @file ucl_emitter.c
40  * Serialise UCL object to various of output formats
41  */
42 
43 static void ucl_emitter_common_elt (struct ucl_emitter_context *ctx,
44 		const ucl_object_t *obj, bool first, bool print_key, bool compact);
45 
46 #define UCL_EMIT_TYPE_OPS(type)		\
47 	static void ucl_emit_ ## type ## _elt (struct ucl_emitter_context *ctx,	\
48 		const ucl_object_t *obj, bool first, bool print_key);	\
49 	static void ucl_emit_ ## type ## _start_obj (struct ucl_emitter_context *ctx,	\
50 		const ucl_object_t *obj, bool print_key);	\
51 	static void ucl_emit_ ## type## _start_array (struct ucl_emitter_context *ctx,	\
52 		const ucl_object_t *obj, bool print_key);	\
53 	static void ucl_emit_ ##type## _end_object (struct ucl_emitter_context *ctx,	\
54 		const ucl_object_t *obj);	\
55 	static void ucl_emit_ ##type## _end_array (struct ucl_emitter_context *ctx,	\
56 		const ucl_object_t *obj)
57 
58 /*
59  * JSON format operations
60  */
61 UCL_EMIT_TYPE_OPS(json);
62 UCL_EMIT_TYPE_OPS(json_compact);
63 UCL_EMIT_TYPE_OPS(config);
64 UCL_EMIT_TYPE_OPS(yaml);
65 UCL_EMIT_TYPE_OPS(msgpack);
66 
67 #define UCL_EMIT_TYPE_CONTENT(type) {	\
68 	.ucl_emitter_write_elt = ucl_emit_ ## type ## _elt,	\
69 	.ucl_emitter_start_object = ucl_emit_ ## type ##_start_obj,	\
70 	.ucl_emitter_start_array = ucl_emit_ ## type ##_start_array,	\
71 	.ucl_emitter_end_object = ucl_emit_ ## type ##_end_object,	\
72 	.ucl_emitter_end_array = ucl_emit_ ## type ##_end_array	\
73 }
74 
75 const struct ucl_emitter_operations ucl_standartd_emitter_ops[] = {
76 	[UCL_EMIT_JSON] = UCL_EMIT_TYPE_CONTENT(json),
77 	[UCL_EMIT_JSON_COMPACT] = UCL_EMIT_TYPE_CONTENT(json_compact),
78 	[UCL_EMIT_CONFIG] = UCL_EMIT_TYPE_CONTENT(config),
79 	[UCL_EMIT_YAML] = UCL_EMIT_TYPE_CONTENT(yaml),
80 	[UCL_EMIT_MSGPACK] = UCL_EMIT_TYPE_CONTENT(msgpack)
81 };
82 
83 /*
84  * Utility to check whether we need a top object
85  */
86 #define UCL_EMIT_IDENT_TOP_OBJ(ctx, obj) ((ctx)->top != (obj) || \
87 		((ctx)->id == UCL_EMIT_JSON_COMPACT || (ctx)->id == UCL_EMIT_JSON))
88 
89 
90 /**
91  * Add tabulation to the output buffer
92  * @param buf target buffer
93  * @param tabs number of tabs to add
94  */
95 static inline void
96 ucl_add_tabs (const struct ucl_emitter_functions *func, unsigned int tabs,
97 		bool compact)
98 {
99 	if (!compact && tabs > 0) {
100 		func->ucl_emitter_append_character (' ', tabs * 4, func->ud);
101 	}
102 }
103 
104 /**
105  * Print key for the element
106  * @param ctx
107  * @param obj
108  */
109 static void
110 ucl_emitter_print_key (bool print_key, struct ucl_emitter_context *ctx,
111 		const ucl_object_t *obj, bool compact)
112 {
113 	const struct ucl_emitter_functions *func = ctx->func;
114 
115 	if (!print_key) {
116 		return;
117 	}
118 
119 	if (ctx->id == UCL_EMIT_CONFIG) {
120 		if (obj->flags & UCL_OBJECT_NEED_KEY_ESCAPE) {
121 			ucl_elt_string_write_json (obj->key, obj->keylen, ctx);
122 		}
123 		else {
124 			func->ucl_emitter_append_len (obj->key, obj->keylen, func->ud);
125 		}
126 
127 		if (obj->type != UCL_OBJECT && obj->type != UCL_ARRAY) {
128 			func->ucl_emitter_append_len (" = ", 3, func->ud);
129 		}
130 		else {
131 			func->ucl_emitter_append_character (' ', 1, func->ud);
132 		}
133 	}
134 	else if (ctx->id == UCL_EMIT_YAML) {
135 		if (obj->keylen > 0 && (obj->flags & UCL_OBJECT_NEED_KEY_ESCAPE)) {
136 			ucl_elt_string_write_json (obj->key, obj->keylen, ctx);
137 		}
138 		else if (obj->keylen > 0) {
139 			func->ucl_emitter_append_len (obj->key, obj->keylen, func->ud);
140 		}
141 		else {
142 			func->ucl_emitter_append_len ("null", 4, func->ud);
143 		}
144 
145 		func->ucl_emitter_append_len (": ", 2, func->ud);
146 	}
147 	else {
148 		if (obj->keylen > 0) {
149 			ucl_elt_string_write_json (obj->key, obj->keylen, ctx);
150 		}
151 		else {
152 			func->ucl_emitter_append_len ("null", 4, func->ud);
153 		}
154 
155 		if (compact) {
156 			func->ucl_emitter_append_character (':', 1, func->ud);
157 		}
158 		else {
159 			func->ucl_emitter_append_len (": ", 2, func->ud);
160 		}
161 	}
162 }
163 
164 static void
165 ucl_emitter_finish_object (struct ucl_emitter_context *ctx,
166 		const ucl_object_t *obj, bool compact, bool is_array)
167 {
168 	const struct ucl_emitter_functions *func = ctx->func;
169 
170 	if (ctx->id == UCL_EMIT_CONFIG && obj != ctx->top) {
171 		if (obj->type != UCL_OBJECT && obj->type != UCL_ARRAY) {
172 			if (!is_array) {
173 				/* Objects are split by ';' */
174 				func->ucl_emitter_append_len (";\n", 2, func->ud);
175 			}
176 			else {
177 				/* Use commas for arrays */
178 				func->ucl_emitter_append_len (",\n", 2, func->ud);
179 			}
180 		}
181 		else {
182 			func->ucl_emitter_append_character ('\n', 1, func->ud);
183 		}
184 	}
185 }
186 
187 /**
188  * End standard ucl object
189  * @param ctx emitter context
190  * @param compact compact flag
191  */
192 static void
193 ucl_emitter_common_end_object (struct ucl_emitter_context *ctx,
194 		const ucl_object_t *obj, bool compact)
195 {
196 	const struct ucl_emitter_functions *func = ctx->func;
197 
198 	if (UCL_EMIT_IDENT_TOP_OBJ(ctx, obj)) {
199 		ctx->indent --;
200 		if (compact) {
201 			func->ucl_emitter_append_character ('}', 1, func->ud);
202 		}
203 		else {
204 			if (ctx->id != UCL_EMIT_CONFIG) {
205 				/* newline is already added for this format */
206 				func->ucl_emitter_append_character ('\n', 1, func->ud);
207 			}
208 			ucl_add_tabs (func, ctx->indent, compact);
209 			func->ucl_emitter_append_character ('}', 1, func->ud);
210 		}
211 	}
212 
213 	ucl_emitter_finish_object (ctx, obj, compact, false);
214 }
215 
216 /**
217  * End standard ucl array
218  * @param ctx emitter context
219  * @param compact compact flag
220  */
221 static void
222 ucl_emitter_common_end_array (struct ucl_emitter_context *ctx,
223 		const ucl_object_t *obj, bool compact)
224 {
225 	const struct ucl_emitter_functions *func = ctx->func;
226 
227 	ctx->indent --;
228 	if (compact) {
229 		func->ucl_emitter_append_character (']', 1, func->ud);
230 	}
231 	else {
232 		if (ctx->id != UCL_EMIT_CONFIG) {
233 			/* newline is already added for this format */
234 			func->ucl_emitter_append_character ('\n', 1, func->ud);
235 		}
236 		ucl_add_tabs (func, ctx->indent, compact);
237 		func->ucl_emitter_append_character (']', 1, func->ud);
238 	}
239 
240 	ucl_emitter_finish_object (ctx, obj, compact, true);
241 }
242 
243 /**
244  * Start emit standard UCL array
245  * @param ctx emitter context
246  * @param obj object to write
247  * @param compact compact flag
248  */
249 static void
250 ucl_emitter_common_start_array (struct ucl_emitter_context *ctx,
251 		const ucl_object_t *obj, bool print_key, bool compact)
252 {
253 	const ucl_object_t *cur;
254 	ucl_object_iter_t iter = NULL;
255 	const struct ucl_emitter_functions *func = ctx->func;
256 	bool first = true;
257 
258 	ucl_emitter_print_key (print_key, ctx, obj, compact);
259 
260 	if (compact) {
261 		func->ucl_emitter_append_character ('[', 1, func->ud);
262 	}
263 	else {
264 		func->ucl_emitter_append_len ("[\n", 2, func->ud);
265 	}
266 
267 	ctx->indent ++;
268 
269 	if (obj->type == UCL_ARRAY) {
270 		/* explicit array */
271 		while ((cur = ucl_object_iterate (obj, &iter, true)) != NULL) {
272 			ucl_emitter_common_elt (ctx, cur, first, false, compact);
273 			first = false;
274 		}
275 	}
276 	else {
277 		/* implicit array */
278 		cur = obj;
279 		while (cur) {
280 			ucl_emitter_common_elt (ctx, cur, first, false, compact);
281 			first = false;
282 			cur = cur->next;
283 		}
284 	}
285 
286 
287 }
288 
289 /**
290  * Start emit standard UCL object
291  * @param ctx emitter context
292  * @param obj object to write
293  * @param compact compact flag
294  */
295 static void
296 ucl_emitter_common_start_object (struct ucl_emitter_context *ctx,
297 		const ucl_object_t *obj, bool print_key, bool compact)
298 {
299 	ucl_hash_iter_t it = NULL;
300 	const ucl_object_t *cur, *elt;
301 	const struct ucl_emitter_functions *func = ctx->func;
302 	bool first = true;
303 
304 	ucl_emitter_print_key (print_key, ctx, obj, compact);
305 	/*
306 	 * Print <ident_level>{
307 	 * <ident_level + 1><object content>
308 	 */
309 	if (UCL_EMIT_IDENT_TOP_OBJ(ctx, obj)) {
310 		if (compact) {
311 			func->ucl_emitter_append_character ('{', 1, func->ud);
312 		}
313 		else {
314 			func->ucl_emitter_append_len ("{\n", 2, func->ud);
315 		}
316 		ctx->indent ++;
317 	}
318 
319 	while ((cur = ucl_hash_iterate (obj->value.ov, &it))) {
320 
321 		if (ctx->id == UCL_EMIT_CONFIG) {
322 			LL_FOREACH (cur, elt) {
323 				ucl_emitter_common_elt (ctx, elt, first, true, compact);
324 			}
325 		}
326 		else {
327 			/* Expand implicit arrays */
328 			if (cur->next != NULL) {
329 				if (!first) {
330 					if (compact) {
331 						func->ucl_emitter_append_character (',', 1, func->ud);
332 					}
333 					else {
334 						func->ucl_emitter_append_len (",\n", 2, func->ud);
335 					}
336 				}
337 				ucl_add_tabs (func, ctx->indent, compact);
338 				ucl_emitter_common_start_array (ctx, cur, true, compact);
339 				ucl_emitter_common_end_array (ctx, cur, compact);
340 			}
341 			else {
342 				ucl_emitter_common_elt (ctx, cur, first, true, compact);
343 			}
344 		}
345 
346 		first = false;
347 	}
348 }
349 
350 /**
351  * Common choice of object emitting
352  * @param ctx emitter context
353  * @param obj object to print
354  * @param first flag to mark the first element
355  * @param print_key print key of an object
356  * @param compact compact output
357  */
358 static void
359 ucl_emitter_common_elt (struct ucl_emitter_context *ctx,
360 		const ucl_object_t *obj, bool first, bool print_key, bool compact)
361 {
362 	const struct ucl_emitter_functions *func = ctx->func;
363 	bool flag;
364 	struct ucl_object_userdata *ud;
365 	const ucl_object_t *comment = NULL, *cur_comment;
366 	const char *ud_out = "";
367 
368 	if (ctx->id != UCL_EMIT_CONFIG && !first) {
369 		if (compact) {
370 			func->ucl_emitter_append_character (',', 1, func->ud);
371 		}
372 		else {
373 			if (ctx->id == UCL_EMIT_YAML && ctx->indent == 0) {
374 				func->ucl_emitter_append_len ("\n", 1, func->ud);
375 			} else {
376 				func->ucl_emitter_append_len (",\n", 2, func->ud);
377 			}
378 		}
379 	}
380 
381 	ucl_add_tabs (func, ctx->indent, compact);
382 
383 	if (ctx->comments && ctx->id == UCL_EMIT_CONFIG) {
384 		comment = ucl_object_lookup_len (ctx->comments, (const char *)&obj,
385 				sizeof (void *));
386 
387 		if (comment) {
388 			if (!(comment->flags & UCL_OBJECT_INHERITED)) {
389 				DL_FOREACH (comment, cur_comment) {
390 					func->ucl_emitter_append_len (cur_comment->value.sv,
391 							cur_comment->len,
392 							func->ud);
393 					func->ucl_emitter_append_character ('\n', 1, func->ud);
394 					ucl_add_tabs (func, ctx->indent, compact);
395 				}
396 
397 				comment = NULL;
398 			}
399 		}
400 	}
401 
402 	switch (obj->type) {
403 	case UCL_INT:
404 		ucl_emitter_print_key (print_key, ctx, obj, compact);
405 		func->ucl_emitter_append_int (ucl_object_toint (obj), func->ud);
406 		ucl_emitter_finish_object (ctx, obj, compact, !print_key);
407 		break;
408 	case UCL_FLOAT:
409 	case UCL_TIME:
410 		ucl_emitter_print_key (print_key, ctx, obj, compact);
411 		func->ucl_emitter_append_double (ucl_object_todouble (obj), func->ud);
412 		ucl_emitter_finish_object (ctx, obj, compact, !print_key);
413 		break;
414 	case UCL_BOOLEAN:
415 		ucl_emitter_print_key (print_key, ctx, obj, compact);
416 		flag = ucl_object_toboolean (obj);
417 		if (flag) {
418 			func->ucl_emitter_append_len ("true", 4, func->ud);
419 		}
420 		else {
421 			func->ucl_emitter_append_len ("false", 5, func->ud);
422 		}
423 		ucl_emitter_finish_object (ctx, obj, compact, !print_key);
424 		break;
425 	case UCL_STRING:
426 		ucl_emitter_print_key (print_key, ctx, obj, compact);
427 		if (ctx->id == UCL_EMIT_CONFIG && ucl_maybe_long_string (obj)) {
428 			ucl_elt_string_write_multiline (obj->value.sv, obj->len, ctx);
429 		}
430 		else {
431 			ucl_elt_string_write_json (obj->value.sv, obj->len, ctx);
432 		}
433 		ucl_emitter_finish_object (ctx, obj, compact, !print_key);
434 		break;
435 	case UCL_NULL:
436 		ucl_emitter_print_key (print_key, ctx, obj, compact);
437 		func->ucl_emitter_append_len ("null", 4, func->ud);
438 		ucl_emitter_finish_object (ctx, obj, compact, !print_key);
439 		break;
440 	case UCL_OBJECT:
441 		ucl_emitter_common_start_object (ctx, obj, print_key, compact);
442 		ucl_emitter_common_end_object (ctx, obj, compact);
443 		break;
444 	case UCL_ARRAY:
445 		ucl_emitter_common_start_array (ctx, obj, print_key, compact);
446 		ucl_emitter_common_end_array (ctx, obj, compact);
447 		break;
448 	case UCL_USERDATA:
449 		ud = (struct ucl_object_userdata *)obj;
450 		ucl_emitter_print_key (print_key, ctx, obj, compact);
451 		if (ud->emitter) {
452 			ud_out = ud->emitter (obj->value.ud);
453 			if (ud_out == NULL) {
454 				ud_out = "null";
455 			}
456 		}
457 		ucl_elt_string_write_json (ud_out, strlen (ud_out), ctx);
458 		ucl_emitter_finish_object (ctx, obj, compact, !print_key);
459 		break;
460 	}
461 
462 	if (comment) {
463 		DL_FOREACH (comment, cur_comment) {
464 			func->ucl_emitter_append_len (cur_comment->value.sv,
465 					cur_comment->len,
466 					func->ud);
467 			func->ucl_emitter_append_character ('\n', 1, func->ud);
468 
469 			if (cur_comment->next) {
470 				ucl_add_tabs (func, ctx->indent, compact);
471 			}
472 		}
473 	}
474 }
475 
476 /*
477  * Specific standard implementations of the emitter functions
478  */
479 #define UCL_EMIT_TYPE_IMPL(type, compact)		\
480 	static void ucl_emit_ ## type ## _elt (struct ucl_emitter_context *ctx,	\
481 		const ucl_object_t *obj, bool first, bool print_key) {	\
482 		ucl_emitter_common_elt (ctx, obj, first, print_key, (compact));	\
483 	}	\
484 	static void ucl_emit_ ## type ## _start_obj (struct ucl_emitter_context *ctx,	\
485 		const ucl_object_t *obj, bool print_key) {	\
486 		ucl_emitter_common_start_object (ctx, obj, print_key, (compact));	\
487 	}	\
488 	static void ucl_emit_ ## type## _start_array (struct ucl_emitter_context *ctx,	\
489 		const ucl_object_t *obj, bool print_key) {	\
490 		ucl_emitter_common_start_array (ctx, obj, print_key, (compact));	\
491 	}	\
492 	static void ucl_emit_ ##type## _end_object (struct ucl_emitter_context *ctx,	\
493 		const ucl_object_t *obj) {	\
494 		ucl_emitter_common_end_object (ctx, obj, (compact));	\
495 	}	\
496 	static void ucl_emit_ ##type## _end_array (struct ucl_emitter_context *ctx,	\
497 		const ucl_object_t *obj) {	\
498 		ucl_emitter_common_end_array (ctx, obj, (compact));	\
499 	}
500 
501 UCL_EMIT_TYPE_IMPL(json, false)
502 UCL_EMIT_TYPE_IMPL(json_compact, true)
503 UCL_EMIT_TYPE_IMPL(config, false)
504 UCL_EMIT_TYPE_IMPL(yaml, false)
505 
506 static void
507 ucl_emit_msgpack_elt (struct ucl_emitter_context *ctx,
508 		const ucl_object_t *obj, bool first, bool print_key)
509 {
510 	ucl_object_iter_t it;
511 	struct ucl_object_userdata *ud;
512 	const char *ud_out;
513 	const ucl_object_t *cur, *celt;
514 
515 	switch (obj->type) {
516 	case UCL_INT:
517 		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
518 		ucl_emitter_print_int_msgpack (ctx, ucl_object_toint (obj));
519 		break;
520 
521 	case UCL_FLOAT:
522 	case UCL_TIME:
523 		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
524 		ucl_emitter_print_double_msgpack (ctx, ucl_object_todouble (obj));
525 		break;
526 
527 	case UCL_BOOLEAN:
528 		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
529 		ucl_emitter_print_bool_msgpack (ctx, ucl_object_toboolean (obj));
530 		break;
531 
532 	case UCL_STRING:
533 		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
534 
535 		if (obj->flags & UCL_OBJECT_BINARY) {
536 			ucl_emitter_print_binary_string_msgpack (ctx, obj->value.sv,
537 					obj->len);
538 		}
539 		else {
540 			ucl_emitter_print_string_msgpack (ctx, obj->value.sv, obj->len);
541 		}
542 		break;
543 
544 	case UCL_NULL:
545 		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
546 		ucl_emitter_print_null_msgpack (ctx);
547 		break;
548 
549 	case UCL_OBJECT:
550 		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
551 		ucl_emit_msgpack_start_obj (ctx, obj, print_key);
552 		it = NULL;
553 
554 		while ((cur = ucl_object_iterate (obj, &it, true)) != NULL) {
555 			LL_FOREACH (cur, celt) {
556 				ucl_emit_msgpack_elt (ctx, celt, false, true);
557 				/* XXX:
558 				 * in msgpack the length of objects is encoded within a single elt
559 				 * so in case of multi-value keys we are using merely the first
560 				 * element ignoring others
561 				 */
562 				break;
563 			}
564 		}
565 
566 		break;
567 
568 	case UCL_ARRAY:
569 		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
570 		ucl_emit_msgpack_start_array (ctx, obj, print_key);
571 		it = NULL;
572 
573 		while ((cur = ucl_object_iterate (obj, &it, true)) != NULL) {
574 			ucl_emit_msgpack_elt (ctx, cur, false, false);
575 		}
576 
577 		break;
578 
579 	case UCL_USERDATA:
580 		ud = (struct ucl_object_userdata *)obj;
581 		ucl_emitter_print_key_msgpack (print_key, ctx, obj);
582 
583 		if (ud->emitter) {
584 			ud_out = ud->emitter (obj->value.ud);
585 			if (ud_out == NULL) {
586 				ud_out = "null";
587 			}
588 		}
589 		ucl_emitter_print_string_msgpack (ctx, obj->value.sv, obj->len);
590 		break;
591 	}
592 }
593 
594 static void
595 ucl_emit_msgpack_start_obj (struct ucl_emitter_context *ctx,
596 		const ucl_object_t *obj, bool print_key)
597 {
598 	ucl_emitter_print_object_msgpack (ctx, obj->len);
599 }
600 
601 static void
602 ucl_emit_msgpack_start_array (struct ucl_emitter_context *ctx,
603 		const ucl_object_t *obj, bool print_key)
604 {
605 	ucl_emitter_print_array_msgpack (ctx, obj->len);
606 }
607 
608 static void
609 ucl_emit_msgpack_end_object (struct ucl_emitter_context *ctx,
610 		const ucl_object_t *obj)
611 {
612 
613 }
614 
615 static void
616 ucl_emit_msgpack_end_array (struct ucl_emitter_context *ctx,
617 		const ucl_object_t *obj)
618 {
619 
620 }
621 
622 unsigned char *
623 ucl_object_emit (const ucl_object_t *obj, enum ucl_emitter emit_type)
624 {
625 	return ucl_object_emit_len (obj, emit_type, NULL);
626 }
627 
628 unsigned char *
629 ucl_object_emit_len (const ucl_object_t *obj, enum ucl_emitter emit_type,
630 		size_t *outlen)
631 {
632 	unsigned char *res = NULL;
633 	struct ucl_emitter_functions *func;
634 	UT_string *s;
635 
636 	if (obj == NULL) {
637 		return NULL;
638 	}
639 
640 	func = ucl_object_emit_memory_funcs ((void **)&res);
641 
642 	if (func != NULL) {
643 		s = func->ud;
644 		ucl_object_emit_full (obj, emit_type, func, NULL);
645 
646 		if (outlen != NULL) {
647 			*outlen = s->i;
648 		}
649 
650 		ucl_object_emit_funcs_free (func);
651 	}
652 
653 	return res;
654 }
655 
656 bool
657 ucl_object_emit_full (const ucl_object_t *obj, enum ucl_emitter emit_type,
658 		struct ucl_emitter_functions *emitter,
659 		const ucl_object_t *comments)
660 {
661 	const struct ucl_emitter_context *ctx;
662 	struct ucl_emitter_context my_ctx;
663 	bool res = false;
664 
665 	ctx = ucl_emit_get_standard_context (emit_type);
666 	if (ctx != NULL) {
667 		memcpy (&my_ctx, ctx, sizeof (my_ctx));
668 		my_ctx.func = emitter;
669 		my_ctx.indent = 0;
670 		my_ctx.top = obj;
671 		my_ctx.comments = comments;
672 
673 		my_ctx.ops->ucl_emitter_write_elt (&my_ctx, obj, true, false);
674 		res = true;
675 	}
676 
677 	return res;
678 }
679