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