main
xs_json.h
1/* copyright (c) 2022 - 2026 grunfink et al. / MIT license */
2
3#ifndef _XS_JSON_H
4
5#define _XS_JSON_H
6
7#include "xs.h"
8
9#ifndef MAX_JSON_DEPTH
10#define MAX_JSON_DEPTH 32
11#endif
12
13void xs_json_dump_value(const xs_val *data, int level, int indent, FILE *f);
14int xs_json_dump(const xs_val *data, int indent, FILE *f);
15xs_str *xs_json_dumps(const xs_val *data, int indent);
16
17xs_val *xs_json_load_full(FILE *f, int maxdepth);
18xs_val *xs_json_loads_full(const xs_str *json, int maxdepth);
19#define xs_json_load(f) xs_json_load_full(f, MAX_JSON_DEPTH)
20#define xs_json_loads(s) xs_json_loads_full(s, MAX_JSON_DEPTH)
21
22xstype xs_json_load_type(FILE *f);
23int xs_json_load_array_iter(FILE *f, xs_val **value, xstype *pt, int *c);
24int xs_json_load_object_iter(FILE *f, xs_str **key, xs_val **value, xstype *pt, int *c);
25int xs_json_load_array(FILE *f, int maxdepth, xs_list **l);
26int xs_json_load_object(FILE *f, int maxdepth, xs_dict **d);
27
28
29#ifdef XS_IMPLEMENTATION
30
31/** IMPLEMENTATION **/
32
33#include "xs_unicode.h"
34
35/** JSON dumps **/
36
37static void _xs_json_dump_str(const char *data, FILE *f)
38/* dumps a string in JSON format */
39{
40 unsigned char c;
41 fputs("\"", f);
42
43 while ((c = *data)) {
44 if (c == '\n')
45 fputs("\\n", f);
46 else
47 if (c == '\r')
48 fputs("\\r", f);
49 else
50 if (c == '\t')
51 fputs("\\t", f);
52 else
53 if (c == '\\')
54 fputs("\\\\", f);
55 else
56 if (c == '"')
57 fputs("\\\"", f);
58 else
59 if (c < 32)
60 fprintf(f, "\\u%04x", (unsigned int) c);
61 else
62 fputc(c, f);
63
64 data++;
65 }
66
67 fputs("\"", f);
68}
69
70
71static void _xs_json_indent(int level, int indent, FILE *f)
72/* adds indentation */
73{
74 if (indent) {
75 int n;
76
77 fputc('\n', f);
78
79 for (n = 0; n < level * indent; n++)
80 fputc(' ', f);
81 }
82}
83
84
85void xs_json_dump_value(const xs_val *data, int level, int indent, FILE *f)
86/* dumps partial data as JSON */
87{
88 int c = 0;
89 const xs_val *v;
90
91 switch (xs_type(data)) {
92 case XSTYPE_NULL:
93 fputs("null", f);
94 break;
95
96 case XSTYPE_TRUE:
97 fputs("true", f);
98 break;
99
100 case XSTYPE_FALSE:
101 fputs("false", f);
102 break;
103
104 case XSTYPE_NUMBER:
105 fputs(xs_number_str(data), f);
106 break;
107
108 case XSTYPE_LIST:
109 fputc('[', f);
110
111 xs_list_foreach(data, v) {
112 if (c != 0)
113 fputc(',', f);
114
115 _xs_json_indent(level + 1, indent, f);
116 xs_json_dump_value(v, level + 1, indent, f);
117
118 c++;
119 }
120
121 _xs_json_indent(level, indent, f);
122 fputc(']', f);
123
124 break;
125
126 case XSTYPE_DICT:
127 fputc('{', f);
128
129 const xs_str *k;
130
131 xs_dict_foreach(data, k, v) {
132 if (c != 0)
133 fputc(',', f);
134
135 _xs_json_indent(level + 1, indent, f);
136
137 _xs_json_dump_str(k, f);
138 fputc(':', f);
139
140 if (indent)
141 fputc(' ', f);
142
143 xs_json_dump_value(v, level + 1, indent, f);
144
145 c++;
146 }
147
148 _xs_json_indent(level, indent, f);
149 fputc('}', f);
150 break;
151
152 case XSTYPE_STRING:
153 _xs_json_dump_str(data, f);
154 break;
155
156 default:
157 break;
158 }
159}
160
161
162int xs_json_dump(const xs_val *data, int indent, FILE *f)
163/* dumps data into a file as JSON */
164{
165 xstype t = xs_type(data);
166
167 if (t == XSTYPE_LIST || t == XSTYPE_DICT) {
168 xs_json_dump_value(data, 0, indent, f);
169 return 1;
170 }
171
172 return 0;
173}
174
175
176xs_str *xs_json_dumps(const xs_val *data, int indent)
177/* dumps data as a JSON string */
178{
179 xs_str *s = NULL;
180 size_t sz;
181 FILE *f;
182
183 if ((f = open_memstream(&s, &sz)) != NULL) {
184 int r = xs_json_dump(data, indent, f);
185 fclose(f);
186
187 if (!r)
188 s = xs_free(s);
189 }
190
191 return s;
192}
193
194
195/** JSON loads **/
196
197typedef enum {
198 JS_ERROR = -1,
199 JS_INCOMPLETE,
200 JS_OCURLY,
201 JS_OBRACK,
202 JS_CCURLY,
203 JS_CBRACK,
204 JS_COMMA,
205 JS_COLON,
206 JS_VALUE,
207 JS_STRING,
208 JS_NUMBER,
209 JS_TRUE,
210 JS_FALSE,
211 JS_NULL,
212 JS_ARRAY,
213 JS_OBJECT
214} js_type;
215
216
217static xs_val *_xs_json_load_lexer(FILE *f, js_type *t)
218{
219 int c;
220 xs_val *v = NULL;
221 int offset;
222
223 *t = JS_ERROR;
224
225 /* skip blanks */
226 while ((c = fgetc(f)) == ' ' || c == '\t' || c == '\n' || c == '\r');
227
228 if (c == '{')
229 *t = JS_OCURLY;
230 else
231 if (c == '}')
232 *t = JS_CCURLY;
233 else
234 if (c == '[')
235 *t = JS_OBRACK;
236 else
237 if (c == ']')
238 *t = JS_CBRACK;
239 else
240 if (c == ',')
241 *t = JS_COMMA;
242 else
243 if (c == ':')
244 *t = JS_COLON;
245 else
246 if (c == '"') {
247 *t = JS_STRING;
248
249 v = xs_str_new(NULL);
250 offset = 0;
251
252 while ((c = fgetc(f)) != '"' && c != EOF && *t != JS_ERROR) {
253 if (c == '\\') {
254 unsigned int cp = fgetc(f);
255
256 switch (cp) {
257 case 'n': cp = '\n'; break;
258 case 'r': cp = '\r'; break;
259 case 't': cp = '\t'; break;
260 case '"': cp = '"'; break;
261 case '\\': cp = '\\'; break;
262 case '/': cp = '/'; break;
263 case 'u': /* Unicode codepoint as an hex char */
264 if (fscanf(f, "%04x", &cp) != 1) {
265 *t = JS_ERROR;
266 break;
267 }
268
269 if (xs_is_surrogate(cp)) {
270 /* \u must follow */
271 if (fgetc(f) != '\\' || fgetc(f) != 'u') {
272 *t = JS_ERROR;
273 break;
274 }
275
276 unsigned int p2;
277 if (fscanf(f, "%04x", &p2) != 1) {
278 *t = JS_ERROR;
279 break;
280 }
281
282 cp = xs_surrogate_dec(cp, p2);
283 }
284
285 /* replace dangerous control codes with their visual representations */
286 if (cp == 0 || (cp < ' ' && !strchr("\r\n\t", cp)))
287 cp += 0x2400;
288
289 break;
290
291 default:
292 *t = JS_ERROR;
293 break;
294 }
295
296 v = xs_utf8_insert(v, cp, &offset);
297 }
298 else {
299 if (c >= 0 && c < ' ') {
300 v = xs_utf8_insert(v, c + 0x2400, &offset);
301 }
302 else {
303 char cc = c;
304 v = xs_insert_m(v, offset, &cc, 1);
305 offset++;
306 }
307
308 if (!xs_is_string(v)) {
309 *t = JS_ERROR;
310 break;
311 }
312 }
313 }
314
315 if (c == EOF)
316 *t = JS_ERROR;
317 }
318 else
319 if (c == '-' || (c >= '0' && c <= '9') || c == '.') {
320 double d;
321
322 ungetc(c, f);
323 if (fscanf(f, "%lf", &d) == 1) {
324 *t = JS_NUMBER;
325 v = xs_number_new(d);
326 }
327 }
328 else
329 if (c == 't') {
330 if (fgetc(f) == 'r' && fgetc(f) == 'u' && fgetc(f) == 'e') {
331 *t = JS_TRUE;
332 v = xs_val_new(XSTYPE_TRUE);
333 }
334 }
335 else
336 if (c == 'f') {
337 if (fgetc(f) == 'a' && fgetc(f) == 'l' &&
338 fgetc(f) == 's' && fgetc(f) == 'e') {
339 *t = JS_FALSE;
340 v = xs_val_new(XSTYPE_FALSE);
341 }
342 }
343 else
344 if (c == 'n') {
345 if (fgetc(f) == 'u' && fgetc(f) == 'l' && fgetc(f) == 'l') {
346 *t = JS_NULL;
347 v = xs_val_new(XSTYPE_NULL);
348 }
349 }
350
351 if (*t == JS_ERROR)
352 v = xs_free(v);
353
354 return v;
355}
356
357
358int xs_json_load_array_iter(FILE *f, xs_val **value, xstype *pt, int *c)
359/* loads the next scalar value from the JSON stream */
360/* if the value ahead is compound, value is NULL and pt is set */
361{
362 js_type t;
363
364 *value = _xs_json_load_lexer(f, &t);
365
366 if (t == JS_ERROR)
367 return -1;
368
369 if (t == JS_CBRACK)
370 return 0;
371
372 if (*c > 0) {
373 if (t == JS_COMMA)
374 *value = _xs_json_load_lexer(f, &t);
375 else
376 return -1;
377 }
378
379 if (*value == NULL) {
380 /* possible compound type ahead */
381 if (t == JS_OBRACK)
382 *pt = XSTYPE_LIST;
383 else
384 if (t == JS_OCURLY)
385 *pt = XSTYPE_DICT;
386 else
387 return -1;
388 }
389 else
390 *pt = xs_type(*value);
391
392 *c = *c + 1;
393
394 return 1;
395}
396
397
398int xs_json_load_array(FILE *f, int maxdepth, xs_list **l)
399/* loads a full JSON array (after the initial OBRACK) */
400/* l can be NULL for the content to be dropped */
401{
402 xstype t;
403 int r = 0;
404 int c = 0;
405
406 for (;;) {
407 xs *v = NULL;
408 r = xs_json_load_array_iter(f, &v, &t, &c);
409
410 if (r == 1) {
411 /* partial load? */
412 if (v == NULL && maxdepth != 0) {
413 if (t == XSTYPE_LIST) {
414 if (l)
415 v = xs_list_new();
416
417 r = xs_json_load_array(f, maxdepth - 1, &v);
418 }
419 else
420 if (t == XSTYPE_DICT) {
421 if (l)
422 v = xs_dict_new();
423
424 r = xs_json_load_object(f, maxdepth - 1, &v);
425 }
426 }
427
428 /* error? */
429 if (r < 0)
430 break;
431
432 if (l)
433 *l = xs_list_append(*l, v);
434 }
435 else
436 break;
437 }
438
439 if (r < 0 && l)
440 *l = xs_free(*l);
441
442 return r;
443}
444
445
446int xs_json_load_object_iter(FILE *f, xs_str **key, xs_val **value, xstype *pt, int *c)
447/* loads the next key and scalar value from the JSON stream */
448/* if the value ahead is compound, value is NULL and pt is set */
449{
450 js_type t;
451
452 *key = _xs_json_load_lexer(f, &t);
453
454 if (t == JS_ERROR)
455 return -1;
456
457 if (t == JS_CCURLY)
458 return 0;
459
460 if (*c > 0) {
461 if (t == JS_COMMA)
462 *key = _xs_json_load_lexer(f, &t);
463 else
464 return -1;
465 }
466
467 if (t != JS_STRING)
468 return -1;
469
470 xs_free(_xs_json_load_lexer(f, &t));
471
472 if (t != JS_COLON)
473 return -1;
474
475 *value = _xs_json_load_lexer(f, &t);
476
477 if (*value == NULL) {
478 /* possible complex type ahead */
479 if (t == JS_OBRACK)
480 *pt = XSTYPE_LIST;
481 else
482 if (t == JS_OCURLY)
483 *pt = XSTYPE_DICT;
484 else
485 return -1;
486 }
487 else
488 *pt = xs_type(*value);
489
490 *c = *c + 1;
491
492 return 1;
493}
494
495
496int xs_json_load_object(FILE *f, int maxdepth, xs_dict **d)
497/* loads a full JSON object (after the initial OCURLY) */
498/* d can be NULL for the content to be dropped */
499{
500 xstype t;
501 int r = 0;
502 int c = 0;
503
504 for (;;) {
505 xs *k = NULL;
506 xs *v = NULL;
507 r = xs_json_load_object_iter(f, &k, &v, &t, &c);
508
509 if (r == 1) {
510 /* partial load? */
511 if (v == NULL && maxdepth != 0) {
512 if (t == XSTYPE_LIST) {
513 if (d)
514 v = xs_list_new();
515
516 r = xs_json_load_array(f, maxdepth - 1, &v);
517 }
518 else
519 if (t == XSTYPE_DICT) {
520 if (d)
521 v = xs_dict_new();
522
523 r = xs_json_load_object(f, maxdepth - 1, &v);
524 }
525 }
526
527 /* error? */
528 if (r < 0)
529 break;
530
531 if (d)
532 *d = xs_dict_append(*d, k, v);
533 }
534 else
535 break;
536 }
537
538 if (r < 0 && d)
539 *d = xs_free(*d);
540
541 return r;
542}
543
544
545xstype xs_json_load_type(FILE *f)
546/* identifies the type of a JSON stream */
547{
548 xstype t = XSTYPE_NULL;
549 js_type jt;
550
551 xs_free(_xs_json_load_lexer(f, &jt));
552
553 if (jt == JS_OBRACK)
554 t = XSTYPE_LIST;
555 else
556 if (jt == JS_OCURLY)
557 t = XSTYPE_DICT;
558
559 return t;
560}
561
562
563xs_val *xs_json_load_full(FILE *f, int maxdepth)
564/* loads a JSON file */
565{
566 xs_val *v = NULL;
567 xstype t = xs_json_load_type(f);
568
569 if (t == XSTYPE_LIST) {
570 v = xs_list_new();
571 xs_json_load_array(f, maxdepth, &v);
572 }
573 else
574 if (t == XSTYPE_DICT) {
575 v = xs_dict_new();
576 xs_json_load_object(f, maxdepth, &v);
577 }
578
579 return v;
580}
581
582
583xs_val *xs_json_loads_full(const xs_str *json, int maxdepth)
584/* loads a string in JSON format and converts to a multiple data */
585{
586 FILE *f;
587 xs_val *v = NULL;
588
589 if ((f = fmemopen((char *)json, strlen(json), "r")) != NULL) {
590 v = xs_json_load_full(f, maxdepth);
591 fclose(f);
592 }
593
594 return v;
595}
596
597
598#endif /* XS_IMPLEMENTATION */
599
600#endif /* _XS_JSON_H */
