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 */