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
ucl_add_tabs(const struct ucl_emitter_functions * func,unsigned int tabs,bool compact)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
ucl_emitter_print_key(bool print_key,struct ucl_emitter_context * ctx,const ucl_object_t * obj,bool compact)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
ucl_emitter_finish_object(struct ucl_emitter_context * ctx,const ucl_object_t * obj,bool compact,bool is_array)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
ucl_emitter_common_end_object(struct ucl_emitter_context * ctx,const ucl_object_t * obj,bool compact)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
ucl_emitter_common_end_array(struct ucl_emitter_context * ctx,const ucl_object_t * obj,bool compact)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
ucl_emitter_common_start_array(struct ucl_emitter_context * ctx,const ucl_object_t * obj,bool print_key,bool compact)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_iterate_object (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
ucl_emitter_common_start_object(struct ucl_emitter_context * ctx,const ucl_object_t * obj,bool print_key,bool compact)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
ucl_emitter_common_elt(struct ucl_emitter_context * ctx,const ucl_object_t * obj,bool first,bool print_key,bool compact)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 char *ud_out = "";
366
367 if (ctx->id != UCL_EMIT_CONFIG && !first) {
368 if (compact) {
369 func->ucl_emitter_append_character (',', 1, func->ud);
370 }
371 else {
372 if (ctx->id == UCL_EMIT_YAML && ctx->indent == 0) {
373 func->ucl_emitter_append_len ("\n", 1, func->ud);
374 } else {
375 func->ucl_emitter_append_len (",\n", 2, func->ud);
376 }
377 }
378 }
379
380 ucl_add_tabs (func, ctx->indent, compact);
381
382 switch (obj->type) {
383 case UCL_INT:
384 ucl_emitter_print_key (print_key, ctx, obj, compact);
385 func->ucl_emitter_append_int (ucl_object_toint (obj), func->ud);
386 ucl_emitter_finish_object (ctx, obj, compact, !print_key);
387 break;
388 case UCL_FLOAT:
389 case UCL_TIME:
390 ucl_emitter_print_key (print_key, ctx, obj, compact);
391 func->ucl_emitter_append_double (ucl_object_todouble (obj), func->ud);
392 ucl_emitter_finish_object (ctx, obj, compact, !print_key);
393 break;
394 case UCL_BOOLEAN:
395 ucl_emitter_print_key (print_key, ctx, obj, compact);
396 flag = ucl_object_toboolean (obj);
397 if (flag) {
398 func->ucl_emitter_append_len ("true", 4, func->ud);
399 }
400 else {
401 func->ucl_emitter_append_len ("false", 5, func->ud);
402 }
403 ucl_emitter_finish_object (ctx, obj, compact, !print_key);
404 break;
405 case UCL_STRING:
406 ucl_emitter_print_key (print_key, ctx, obj, compact);
407 if (ctx->id == UCL_EMIT_CONFIG && ucl_maybe_long_string (obj)) {
408 ucl_elt_string_write_multiline (obj->value.sv, obj->len, ctx);
409 }
410 else {
411 ucl_elt_string_write_json (obj->value.sv, obj->len, ctx);
412 }
413 ucl_emitter_finish_object (ctx, obj, compact, !print_key);
414 break;
415 case UCL_NULL:
416 ucl_emitter_print_key (print_key, ctx, obj, compact);
417 func->ucl_emitter_append_len ("null", 4, func->ud);
418 ucl_emitter_finish_object (ctx, obj, compact, !print_key);
419 break;
420 case UCL_OBJECT:
421 ucl_emitter_common_start_object (ctx, obj, print_key, compact);
422 ucl_emitter_common_end_object (ctx, obj, compact);
423 break;
424 case UCL_ARRAY:
425 ucl_emitter_common_start_array (ctx, obj, print_key, compact);
426 ucl_emitter_common_end_array (ctx, obj, compact);
427 break;
428 case UCL_USERDATA:
429 ud = (struct ucl_object_userdata *)obj;
430 ucl_emitter_print_key (print_key, ctx, obj, compact);
431 if (ud->emitter) {
432 ud_out = ud->emitter (obj->value.ud);
433 if (ud_out == NULL) {
434 ud_out = "null";
435 }
436 }
437 ucl_elt_string_write_json (ud_out, strlen (ud_out), ctx);
438 ucl_emitter_finish_object (ctx, obj, compact, !print_key);
439 break;
440 }
441 }
442
443 /*
444 * Specific standard implementations of the emitter functions
445 */
446 #define UCL_EMIT_TYPE_IMPL(type, compact) \
447 static void ucl_emit_ ## type ## _elt (struct ucl_emitter_context *ctx, \
448 const ucl_object_t *obj, bool first, bool print_key) { \
449 ucl_emitter_common_elt (ctx, obj, first, print_key, (compact)); \
450 } \
451 static void ucl_emit_ ## type ## _start_obj (struct ucl_emitter_context *ctx, \
452 const ucl_object_t *obj, bool print_key) { \
453 ucl_emitter_common_start_object (ctx, obj, print_key, (compact)); \
454 } \
455 static void ucl_emit_ ## type## _start_array (struct ucl_emitter_context *ctx, \
456 const ucl_object_t *obj, bool print_key) { \
457 ucl_emitter_common_start_array (ctx, obj, print_key, (compact)); \
458 } \
459 static void ucl_emit_ ##type## _end_object (struct ucl_emitter_context *ctx, \
460 const ucl_object_t *obj) { \
461 ucl_emitter_common_end_object (ctx, obj, (compact)); \
462 } \
463 static void ucl_emit_ ##type## _end_array (struct ucl_emitter_context *ctx, \
464 const ucl_object_t *obj) { \
465 ucl_emitter_common_end_array (ctx, obj, (compact)); \
466 }
467
UCL_EMIT_TYPE_IMPL(json,false)468 UCL_EMIT_TYPE_IMPL(json, false)
469 UCL_EMIT_TYPE_IMPL(json_compact, true)
470 UCL_EMIT_TYPE_IMPL(config, false)
471 UCL_EMIT_TYPE_IMPL(yaml, false)
472
473 static void
474 ucl_emit_msgpack_elt (struct ucl_emitter_context *ctx,
475 const ucl_object_t *obj, bool first, bool print_key)
476 {
477 ucl_object_iter_t it;
478 struct ucl_object_userdata *ud;
479 const char *ud_out;
480 const ucl_object_t *cur, *celt;
481
482 switch (obj->type) {
483 case UCL_INT:
484 ucl_emitter_print_key_msgpack (print_key, ctx, obj);
485 ucl_emitter_print_int_msgpack (ctx, ucl_object_toint (obj));
486 break;
487
488 case UCL_FLOAT:
489 case UCL_TIME:
490 ucl_emitter_print_key_msgpack (print_key, ctx, obj);
491 ucl_emitter_print_double_msgpack (ctx, ucl_object_todouble (obj));
492 break;
493
494 case UCL_BOOLEAN:
495 ucl_emitter_print_key_msgpack (print_key, ctx, obj);
496 ucl_emitter_print_bool_msgpack (ctx, ucl_object_toboolean (obj));
497 break;
498
499 case UCL_STRING:
500 ucl_emitter_print_key_msgpack (print_key, ctx, obj);
501
502 if (obj->flags & UCL_OBJECT_BINARY) {
503 ucl_emitter_print_binary_string_msgpack (ctx, obj->value.sv,
504 obj->len);
505 }
506 else {
507 ucl_emitter_print_string_msgpack (ctx, obj->value.sv, obj->len);
508 }
509 break;
510
511 case UCL_NULL:
512 ucl_emitter_print_key_msgpack (print_key, ctx, obj);
513 ucl_emitter_print_null_msgpack (ctx);
514 break;
515
516 case UCL_OBJECT:
517 ucl_emitter_print_key_msgpack (print_key, ctx, obj);
518 ucl_emit_msgpack_start_obj (ctx, obj, print_key);
519 it = NULL;
520
521 while ((cur = ucl_iterate_object (obj, &it, true)) != NULL) {
522 LL_FOREACH (cur, celt) {
523 ucl_emit_msgpack_elt (ctx, celt, false, true);
524 /* XXX:
525 * in msgpack the length of objects is encoded within a single elt
526 * so in case of multi-value keys we are using merely the first
527 * element ignoring others
528 */
529 break;
530 }
531 }
532
533 break;
534
535 case UCL_ARRAY:
536 ucl_emitter_print_key_msgpack (print_key, ctx, obj);
537 ucl_emit_msgpack_start_array (ctx, obj, print_key);
538 it = NULL;
539
540 while ((cur = ucl_iterate_object (obj, &it, true)) != NULL) {
541 ucl_emit_msgpack_elt (ctx, cur, false, false);
542 }
543
544 break;
545
546 case UCL_USERDATA:
547 ud = (struct ucl_object_userdata *)obj;
548 ucl_emitter_print_key_msgpack (print_key, ctx, obj);
549
550 if (ud->emitter) {
551 ud_out = ud->emitter (obj->value.ud);
552 if (ud_out == NULL) {
553 ud_out = "null";
554 }
555 }
556 ucl_emitter_print_string_msgpack (ctx, obj->value.sv, obj->len);
557 break;
558 }
559 }
560
561 static void
ucl_emit_msgpack_start_obj(struct ucl_emitter_context * ctx,const ucl_object_t * obj,bool print_key)562 ucl_emit_msgpack_start_obj (struct ucl_emitter_context *ctx,
563 const ucl_object_t *obj, bool print_key)
564 {
565 ucl_emitter_print_object_msgpack (ctx, obj->len);
566 }
567
568 static void
ucl_emit_msgpack_start_array(struct ucl_emitter_context * ctx,const ucl_object_t * obj,bool print_key)569 ucl_emit_msgpack_start_array (struct ucl_emitter_context *ctx,
570 const ucl_object_t *obj, bool print_key)
571 {
572 ucl_emitter_print_array_msgpack (ctx, obj->len);
573 }
574
575 static void
ucl_emit_msgpack_end_object(struct ucl_emitter_context * ctx,const ucl_object_t * obj)576 ucl_emit_msgpack_end_object (struct ucl_emitter_context *ctx,
577 const ucl_object_t *obj)
578 {
579
580 }
581
582 static void
ucl_emit_msgpack_end_array(struct ucl_emitter_context * ctx,const ucl_object_t * obj)583 ucl_emit_msgpack_end_array (struct ucl_emitter_context *ctx,
584 const ucl_object_t *obj)
585 {
586
587 }
588
589 unsigned char *
ucl_object_emit(const ucl_object_t * obj,enum ucl_emitter emit_type)590 ucl_object_emit (const ucl_object_t *obj, enum ucl_emitter emit_type)
591 {
592 return ucl_object_emit_len (obj, emit_type, NULL);
593 }
594
595 unsigned char *
ucl_object_emit_len(const ucl_object_t * obj,enum ucl_emitter emit_type,size_t * outlen)596 ucl_object_emit_len (const ucl_object_t *obj, enum ucl_emitter emit_type,
597 size_t *outlen)
598 {
599 unsigned char *res = NULL;
600 struct ucl_emitter_functions *func;
601 UT_string *s;
602
603 if (obj == NULL) {
604 return NULL;
605 }
606
607 func = ucl_object_emit_memory_funcs ((void **)&res);
608 s = func->ud;
609
610 if (func != NULL) {
611 ucl_object_emit_full (obj, emit_type, func);
612
613 if (outlen != NULL) {
614 *outlen = s->i;
615 }
616
617 ucl_object_emit_funcs_free (func);
618 }
619
620 return res;
621 }
622
623 bool
ucl_object_emit_full(const ucl_object_t * obj,enum ucl_emitter emit_type,struct ucl_emitter_functions * emitter)624 ucl_object_emit_full (const ucl_object_t *obj, enum ucl_emitter emit_type,
625 struct ucl_emitter_functions *emitter)
626 {
627 const struct ucl_emitter_context *ctx;
628 struct ucl_emitter_context my_ctx;
629 bool res = false;
630
631 ctx = ucl_emit_get_standard_context (emit_type);
632 if (ctx != NULL) {
633 memcpy (&my_ctx, ctx, sizeof (my_ctx));
634 my_ctx.func = emitter;
635 my_ctx.indent = 0;
636 my_ctx.top = obj;
637
638 my_ctx.ops->ucl_emitter_write_elt (&my_ctx, obj, true, false);
639 res = true;
640 }
641
642 return res;
643 }
644