1 /* Copyright (c) 2014, 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 
32 struct ucl_emitter_streamline_stack {
33 	bool is_array;
34 	bool empty;
35 	const ucl_object_t *obj;
36 	struct ucl_emitter_streamline_stack *next;
37 };
38 
39 struct ucl_emitter_context_streamline {
40 	/* Inherited from the main context */
41 	/** Name of emitter (e.g. json, compact_json) */
42 	const char *name;
43 	/** Unique id (e.g. UCL_EMIT_JSON for standard emitters */
44 	int id;
45 	/** A set of output functions */
46 	const struct ucl_emitter_functions *func;
47 	/** A set of output operations */
48 	const struct ucl_emitter_operations *ops;
49 	/** Current amount of indent tabs */
50 	unsigned int indent;
51 	/** Top level object */
52 	const ucl_object_t *top;
53 	/** Optional comments */
54 	const ucl_object_t *comments;
55 
56 	/* Streamline specific fields */
57 	struct ucl_emitter_streamline_stack *containers;
58 };
59 
60 #define TO_STREAMLINE(ctx) (struct ucl_emitter_context_streamline *)(ctx)
61 
62 struct ucl_emitter_context*
ucl_object_emit_streamline_new(const ucl_object_t * obj,enum ucl_emitter emit_type,struct ucl_emitter_functions * emitter)63 ucl_object_emit_streamline_new (const ucl_object_t *obj,
64 		enum ucl_emitter emit_type,
65 		struct ucl_emitter_functions *emitter)
66 {
67 	const struct ucl_emitter_context *ctx;
68 	struct ucl_emitter_context_streamline *sctx;
69 
70 	ctx = ucl_emit_get_standard_context (emit_type);
71 	if (ctx == NULL) {
72 		return NULL;
73 	}
74 
75 	sctx = calloc (1, sizeof (*sctx));
76 	if (sctx == NULL) {
77 		return NULL;
78 	}
79 
80 	memcpy (sctx, ctx, sizeof (*ctx));
81 	sctx->func = emitter;
82 	sctx->top = obj;
83 
84 	ucl_object_emit_streamline_start_container ((struct ucl_emitter_context *)sctx,
85 			obj);
86 
87 	return (struct ucl_emitter_context *)sctx;
88 }
89 
90 void
ucl_object_emit_streamline_start_container(struct ucl_emitter_context * ctx,const ucl_object_t * obj)91 ucl_object_emit_streamline_start_container (struct ucl_emitter_context *ctx,
92 		const ucl_object_t *obj)
93 {
94 	struct ucl_emitter_context_streamline *sctx = TO_STREAMLINE(ctx);
95 	struct ucl_emitter_streamline_stack *st, *top;
96 	bool print_key = false;
97 
98 	/* Check top object presence */
99 	if (sctx->top == NULL) {
100 		sctx->top = obj;
101 	}
102 
103 	top = sctx->containers;
104 	st = malloc (sizeof (*st));
105 	if (st != NULL) {
106 		if (top != NULL && !top->is_array) {
107 			print_key = true;
108 		}
109 		st->empty = true;
110 		st->obj = obj;
111 		if (obj != NULL && obj->type == UCL_ARRAY) {
112 			st->is_array = true;
113 			sctx->ops->ucl_emitter_start_array (ctx, obj, print_key);
114 		}
115 		else {
116 			st->is_array = false;
117 			sctx->ops->ucl_emitter_start_object (ctx, obj, print_key);
118 		}
119 		LL_PREPEND (sctx->containers, st);
120 	}
121 }
122 
123 void
ucl_object_emit_streamline_add_object(struct ucl_emitter_context * ctx,const ucl_object_t * obj)124 ucl_object_emit_streamline_add_object (
125 		struct ucl_emitter_context *ctx, const ucl_object_t *obj)
126 {
127 	struct ucl_emitter_context_streamline *sctx = TO_STREAMLINE(ctx);
128 	bool is_array = false, is_first = false;
129 
130 	if (sctx->containers != NULL) {
131 		if (sctx->containers->is_array) {
132 			is_array = true;
133 		}
134 		if (sctx->containers->empty) {
135 			is_first = true;
136 			sctx->containers->empty = false;
137 		}
138 	}
139 
140 	sctx->ops->ucl_emitter_write_elt (ctx, obj, is_first, !is_array);
141 }
142 
143 void
ucl_object_emit_streamline_end_container(struct ucl_emitter_context * ctx)144 ucl_object_emit_streamline_end_container (struct ucl_emitter_context *ctx)
145 {
146 	struct ucl_emitter_context_streamline *sctx = TO_STREAMLINE(ctx);
147 	struct ucl_emitter_streamline_stack *st;
148 
149 	if (sctx->containers != NULL) {
150 		st = sctx->containers;
151 
152 		if (st->is_array) {
153 			sctx->ops->ucl_emitter_end_array (ctx, st->obj);
154 		}
155 		else {
156 			sctx->ops->ucl_emitter_end_object (ctx, st->obj);
157 		}
158 		sctx->containers = st->next;
159 		free (st);
160 	}
161 }
162 
163 void
ucl_object_emit_streamline_finish(struct ucl_emitter_context * ctx)164 ucl_object_emit_streamline_finish (struct ucl_emitter_context *ctx)
165 {
166 	struct ucl_emitter_context_streamline *sctx = TO_STREAMLINE(ctx);
167 
168 	while (sctx->containers != NULL) {
169 		ucl_object_emit_streamline_end_container (ctx);
170 	}
171 
172 	free (sctx);
173 }
174