]>
Commit | Line | Data |
---|---|---|
15db4e7f | 1 | #include "git-compat-util.h" |
75459410 JH |
2 | #include "json-writer.h" |
3 | ||
4 | void jw_init(struct json_writer *jw) | |
5 | { | |
5726a6b4 ÆAB |
6 | struct json_writer blank = JSON_WRITER_INIT; |
7 | memcpy(jw, &blank, sizeof(*jw));; | |
75459410 JH |
8 | } |
9 | ||
10 | void jw_release(struct json_writer *jw) | |
11 | { | |
12 | strbuf_release(&jw->json); | |
13 | strbuf_release(&jw->open_stack); | |
14 | } | |
15 | ||
16 | /* | |
17 | * Append JSON-quoted version of the given string to 'out'. | |
18 | */ | |
19 | static void append_quoted_string(struct strbuf *out, const char *in) | |
20 | { | |
21 | unsigned char c; | |
22 | ||
23 | strbuf_addch(out, '"'); | |
24 | while ((c = *in++) != '\0') { | |
25 | if (c == '"') | |
26 | strbuf_addstr(out, "\\\""); | |
27 | else if (c == '\\') | |
28 | strbuf_addstr(out, "\\\\"); | |
29 | else if (c == '\n') | |
30 | strbuf_addstr(out, "\\n"); | |
31 | else if (c == '\r') | |
32 | strbuf_addstr(out, "\\r"); | |
33 | else if (c == '\t') | |
34 | strbuf_addstr(out, "\\t"); | |
35 | else if (c == '\f') | |
36 | strbuf_addstr(out, "\\f"); | |
37 | else if (c == '\b') | |
38 | strbuf_addstr(out, "\\b"); | |
39 | else if (c < 0x20) | |
40 | strbuf_addf(out, "\\u%04x", c); | |
41 | else | |
42 | strbuf_addch(out, c); | |
43 | } | |
44 | strbuf_addch(out, '"'); | |
45 | } | |
46 | ||
47 | static void indent_pretty(struct json_writer *jw) | |
48 | { | |
49 | int k; | |
50 | ||
51 | for (k = 0; k < jw->open_stack.len; k++) | |
52 | strbuf_addstr(&jw->json, " "); | |
53 | } | |
54 | ||
55 | /* | |
56 | * Begin an object or array (either top-level or nested within the currently | |
57 | * open object or array). | |
58 | */ | |
59 | static void begin(struct json_writer *jw, char ch_open, int pretty) | |
60 | { | |
61 | jw->pretty = pretty; | |
62 | ||
63 | strbuf_addch(&jw->json, ch_open); | |
64 | ||
65 | strbuf_addch(&jw->open_stack, ch_open); | |
66 | jw->need_comma = 0; | |
67 | } | |
68 | ||
69 | /* | |
70 | * Assert that the top of the open-stack is an object. | |
71 | */ | |
72 | static void assert_in_object(const struct json_writer *jw, const char *key) | |
73 | { | |
74 | if (!jw->open_stack.len) | |
75 | BUG("json-writer: object: missing jw_object_begin(): '%s'", key); | |
76 | if (jw->open_stack.buf[jw->open_stack.len - 1] != '{') | |
77 | BUG("json-writer: object: not in object: '%s'", key); | |
78 | } | |
79 | ||
80 | /* | |
81 | * Assert that the top of the open-stack is an array. | |
82 | */ | |
83 | static void assert_in_array(const struct json_writer *jw) | |
84 | { | |
85 | if (!jw->open_stack.len) | |
86 | BUG("json-writer: array: missing jw_array_begin()"); | |
87 | if (jw->open_stack.buf[jw->open_stack.len - 1] != '[') | |
88 | BUG("json-writer: array: not in array"); | |
89 | } | |
90 | ||
91 | /* | |
92 | * Add comma if we have already seen a member at this level. | |
93 | */ | |
94 | static void maybe_add_comma(struct json_writer *jw) | |
95 | { | |
96 | if (jw->need_comma) | |
97 | strbuf_addch(&jw->json, ','); | |
98 | else | |
99 | jw->need_comma = 1; | |
100 | } | |
101 | ||
102 | static void fmt_double(struct json_writer *jw, int precision, | |
103 | double value) | |
104 | { | |
105 | if (precision < 0) { | |
106 | strbuf_addf(&jw->json, "%f", value); | |
107 | } else { | |
108 | struct strbuf fmt = STRBUF_INIT; | |
109 | strbuf_addf(&fmt, "%%.%df", precision); | |
110 | strbuf_addf(&jw->json, fmt.buf, value); | |
111 | strbuf_release(&fmt); | |
112 | } | |
113 | } | |
114 | ||
115 | static void object_common(struct json_writer *jw, const char *key) | |
116 | { | |
117 | assert_in_object(jw, key); | |
118 | maybe_add_comma(jw); | |
119 | ||
120 | if (jw->pretty) { | |
121 | strbuf_addch(&jw->json, '\n'); | |
122 | indent_pretty(jw); | |
123 | } | |
124 | ||
125 | append_quoted_string(&jw->json, key); | |
126 | strbuf_addch(&jw->json, ':'); | |
127 | if (jw->pretty) | |
128 | strbuf_addch(&jw->json, ' '); | |
129 | } | |
130 | ||
131 | static void array_common(struct json_writer *jw) | |
132 | { | |
133 | assert_in_array(jw); | |
134 | maybe_add_comma(jw); | |
135 | ||
136 | if (jw->pretty) { | |
137 | strbuf_addch(&jw->json, '\n'); | |
138 | indent_pretty(jw); | |
139 | } | |
140 | } | |
141 | ||
142 | /* | |
143 | * Assert that the given JSON object or JSON array has been properly | |
144 | * terminated. (Has closing bracket.) | |
145 | */ | |
146 | static void assert_is_terminated(const struct json_writer *jw) | |
147 | { | |
148 | if (jw->open_stack.len) | |
149 | BUG("json-writer: object: missing jw_end(): '%s'", | |
150 | jw->json.buf); | |
151 | } | |
152 | ||
153 | void jw_object_begin(struct json_writer *jw, int pretty) | |
154 | { | |
155 | begin(jw, '{', pretty); | |
156 | } | |
157 | ||
158 | void jw_object_string(struct json_writer *jw, const char *key, const char *value) | |
159 | { | |
160 | object_common(jw, key); | |
161 | append_quoted_string(&jw->json, value); | |
162 | } | |
163 | ||
164 | void jw_object_intmax(struct json_writer *jw, const char *key, intmax_t value) | |
165 | { | |
166 | object_common(jw, key); | |
167 | strbuf_addf(&jw->json, "%"PRIdMAX, value); | |
168 | } | |
169 | ||
170 | void jw_object_double(struct json_writer *jw, const char *key, int precision, | |
171 | double value) | |
172 | { | |
173 | object_common(jw, key); | |
174 | fmt_double(jw, precision, value); | |
175 | } | |
176 | ||
177 | void jw_object_true(struct json_writer *jw, const char *key) | |
178 | { | |
179 | object_common(jw, key); | |
180 | strbuf_addstr(&jw->json, "true"); | |
181 | } | |
182 | ||
183 | void jw_object_false(struct json_writer *jw, const char *key) | |
184 | { | |
185 | object_common(jw, key); | |
186 | strbuf_addstr(&jw->json, "false"); | |
187 | } | |
188 | ||
189 | void jw_object_bool(struct json_writer *jw, const char *key, int value) | |
190 | { | |
191 | if (value) | |
192 | jw_object_true(jw, key); | |
193 | else | |
194 | jw_object_false(jw, key); | |
195 | } | |
196 | ||
197 | void jw_object_null(struct json_writer *jw, const char *key) | |
198 | { | |
199 | object_common(jw, key); | |
200 | strbuf_addstr(&jw->json, "null"); | |
201 | } | |
202 | ||
203 | static void increase_indent(struct strbuf *sb, | |
204 | const struct json_writer *jw, | |
205 | int indent) | |
206 | { | |
207 | int k; | |
208 | ||
209 | strbuf_reset(sb); | |
210 | for (k = 0; k < jw->json.len; k++) { | |
211 | char ch = jw->json.buf[k]; | |
212 | strbuf_addch(sb, ch); | |
213 | if (ch == '\n') | |
214 | strbuf_addchars(sb, ' ', indent); | |
215 | } | |
216 | } | |
217 | ||
218 | static void kill_indent(struct strbuf *sb, | |
219 | const struct json_writer *jw) | |
220 | { | |
221 | int k; | |
222 | int eat_it = 0; | |
223 | ||
224 | strbuf_reset(sb); | |
225 | for (k = 0; k < jw->json.len; k++) { | |
226 | char ch = jw->json.buf[k]; | |
227 | if (eat_it && ch == ' ') | |
228 | continue; | |
229 | if (ch == '\n') { | |
230 | eat_it = 1; | |
231 | continue; | |
232 | } | |
233 | eat_it = 0; | |
234 | strbuf_addch(sb, ch); | |
235 | } | |
236 | } | |
237 | ||
238 | static void append_sub_jw(struct json_writer *jw, | |
239 | const struct json_writer *value) | |
240 | { | |
241 | /* | |
242 | * If both are pretty, increase the indentation of the sub_jw | |
243 | * to better fit under the super. | |
244 | * | |
245 | * If the super is pretty, but the sub_jw is compact, leave the | |
246 | * sub_jw compact. (We don't want to parse and rebuild the sub_jw | |
247 | * for this debug-ish feature.) | |
248 | * | |
249 | * If the super is compact, and the sub_jw is pretty, convert | |
250 | * the sub_jw to compact. | |
251 | * | |
252 | * If both are compact, keep the sub_jw compact. | |
253 | */ | |
254 | if (jw->pretty && jw->open_stack.len && value->pretty) { | |
255 | struct strbuf sb = STRBUF_INIT; | |
256 | increase_indent(&sb, value, jw->open_stack.len * 2); | |
257 | strbuf_addbuf(&jw->json, &sb); | |
258 | strbuf_release(&sb); | |
259 | return; | |
260 | } | |
261 | if (!jw->pretty && value->pretty) { | |
262 | struct strbuf sb = STRBUF_INIT; | |
263 | kill_indent(&sb, value); | |
264 | strbuf_addbuf(&jw->json, &sb); | |
265 | strbuf_release(&sb); | |
266 | return; | |
267 | } | |
268 | ||
269 | strbuf_addbuf(&jw->json, &value->json); | |
270 | } | |
271 | ||
272 | /* | |
273 | * Append existing (properly terminated) JSON sub-data (object or array) | |
274 | * as-is onto the given JSON data. | |
275 | */ | |
276 | void jw_object_sub_jw(struct json_writer *jw, const char *key, | |
277 | const struct json_writer *value) | |
278 | { | |
279 | assert_is_terminated(value); | |
280 | ||
281 | object_common(jw, key); | |
282 | append_sub_jw(jw, value); | |
283 | } | |
284 | ||
285 | void jw_object_inline_begin_object(struct json_writer *jw, const char *key) | |
286 | { | |
287 | object_common(jw, key); | |
288 | ||
289 | jw_object_begin(jw, jw->pretty); | |
290 | } | |
291 | ||
292 | void jw_object_inline_begin_array(struct json_writer *jw, const char *key) | |
293 | { | |
294 | object_common(jw, key); | |
295 | ||
296 | jw_array_begin(jw, jw->pretty); | |
297 | } | |
298 | ||
299 | void jw_array_begin(struct json_writer *jw, int pretty) | |
300 | { | |
301 | begin(jw, '[', pretty); | |
302 | } | |
303 | ||
304 | void jw_array_string(struct json_writer *jw, const char *value) | |
305 | { | |
306 | array_common(jw); | |
307 | append_quoted_string(&jw->json, value); | |
308 | } | |
309 | ||
310 | void jw_array_intmax(struct json_writer *jw, intmax_t value) | |
311 | { | |
312 | array_common(jw); | |
313 | strbuf_addf(&jw->json, "%"PRIdMAX, value); | |
314 | } | |
315 | ||
316 | void jw_array_double(struct json_writer *jw, int precision, double value) | |
317 | { | |
318 | array_common(jw); | |
319 | fmt_double(jw, precision, value); | |
320 | } | |
321 | ||
322 | void jw_array_true(struct json_writer *jw) | |
323 | { | |
324 | array_common(jw); | |
325 | strbuf_addstr(&jw->json, "true"); | |
326 | } | |
327 | ||
328 | void jw_array_false(struct json_writer *jw) | |
329 | { | |
330 | array_common(jw); | |
331 | strbuf_addstr(&jw->json, "false"); | |
332 | } | |
333 | ||
334 | void jw_array_bool(struct json_writer *jw, int value) | |
335 | { | |
336 | if (value) | |
337 | jw_array_true(jw); | |
338 | else | |
339 | jw_array_false(jw); | |
340 | } | |
341 | ||
342 | void jw_array_null(struct json_writer *jw) | |
343 | { | |
344 | array_common(jw); | |
345 | strbuf_addstr(&jw->json, "null"); | |
346 | } | |
347 | ||
348 | void jw_array_sub_jw(struct json_writer *jw, const struct json_writer *value) | |
349 | { | |
350 | assert_is_terminated(value); | |
351 | ||
352 | array_common(jw); | |
353 | append_sub_jw(jw, value); | |
354 | } | |
355 | ||
356 | void jw_array_argc_argv(struct json_writer *jw, int argc, const char **argv) | |
357 | { | |
358 | int k; | |
359 | ||
360 | for (k = 0; k < argc; k++) | |
361 | jw_array_string(jw, argv[k]); | |
362 | } | |
363 | ||
364 | void jw_array_argv(struct json_writer *jw, const char **argv) | |
365 | { | |
366 | while (*argv) | |
367 | jw_array_string(jw, *argv++); | |
368 | } | |
369 | ||
370 | void jw_array_inline_begin_object(struct json_writer *jw) | |
371 | { | |
372 | array_common(jw); | |
373 | ||
374 | jw_object_begin(jw, jw->pretty); | |
375 | } | |
376 | ||
377 | void jw_array_inline_begin_array(struct json_writer *jw) | |
378 | { | |
379 | array_common(jw); | |
380 | ||
381 | jw_array_begin(jw, jw->pretty); | |
382 | } | |
383 | ||
384 | int jw_is_terminated(const struct json_writer *jw) | |
385 | { | |
386 | return !jw->open_stack.len; | |
387 | } | |
388 | ||
389 | void jw_end(struct json_writer *jw) | |
390 | { | |
391 | char ch_open; | |
392 | int len; | |
393 | ||
394 | if (!jw->open_stack.len) | |
395 | BUG("json-writer: too many jw_end(): '%s'", jw->json.buf); | |
396 | ||
397 | len = jw->open_stack.len - 1; | |
398 | ch_open = jw->open_stack.buf[len]; | |
399 | ||
400 | strbuf_setlen(&jw->open_stack, len); | |
401 | jw->need_comma = 1; | |
402 | ||
403 | if (jw->pretty) { | |
404 | strbuf_addch(&jw->json, '\n'); | |
405 | indent_pretty(jw); | |
406 | } | |
407 | ||
408 | if (ch_open == '{') | |
409 | strbuf_addch(&jw->json, '}'); | |
410 | else | |
411 | strbuf_addch(&jw->json, ']'); | |
412 | } |