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