1: /*************************************************************************
2: * (C) 2017 AITNET ltd - Sofia/Bulgaria - <misho@aitnet.org>
3: * by Michael Pounov <misho@elwix.org>
4: *
5: * $Author: misho $
6: * $Id: json.c,v 1.14 2026/03/31 15:29:12 misho Exp $
7: *
8: **************************************************************************
9: The ELWIX and AITNET software is distributed under the following
10: terms:
11:
12: All of the documentation and software included in the ELWIX and AITNET
13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
14:
15: Copyright 2004 - 2026
16: by Michael Pounov <misho@elwix.org>. All rights reserved.
17:
18: Redistribution and use in source and binary forms, with or without
19: modification, are permitted provided that the following conditions
20: are met:
21: 1. Redistributions of source code must retain the above copyright
22: notice, this list of conditions and the following disclaimer.
23: 2. Redistributions in binary form must reproduce the above copyright
24: notice, this list of conditions and the following disclaimer in the
25: documentation and/or other materials provided with the distribution.
26: 3. All advertising materials mentioning features or use of this software
27: must display the following acknowledgement:
28: This product includes software developed by Michael Pounov <misho@elwix.org>
29: ELWIX - Embedded LightWeight unIX and its contributors.
30: 4. Neither the name of AITNET nor the names of its contributors
31: may be used to endorse or promote products derived from this software
32: without specific prior written permission.
33:
34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37: ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44: SUCH DAMAGE.
45: */
46: #include "global.h"
47:
48:
49: /* JSON error strings */
50: const char *jerrstr[] = {
51: "No error",
52: "Not enough tokens were provided",
53: "Invalid character",
54: "JSON string isn't full",
55: "Invalid parameter",
56: NULL
57: };
58:
59:
60: /*
61: * json_init() - Initialize JSON handler
62: *
63: * @json = JSON handler, if there is NULL then dynamically will be allocated
64: * @jstrict = JSON strict mode, when we select strict mode every unquoted value is error
65: * return: =NULL error or !=NULL ready for use JSON handler and should be free with json_free()
66: */
67: json_t *
68: json_init(json_t * __restrict json, int jstrict)
69: {
70: json_t *j = json;
71:
72: if (!j) {
73: j = e_malloc(sizeof(json_t));
74: if (!j) {
75: LOGERR;
76: return NULL;
77: }
78: }
79:
80: memset(j, 0, sizeof(json_t));
81: j->h_parent = -1;
82: j->h_strict = jstrict;
83:
84: /* handler is dynamically allocated! */
85: if (!json)
86: j->h_alloc = j;
87:
88: return j;
89: }
90:
91: /*
92: * json_free() - Free JSON handler
93: *
94: * @json = JSON handler
95: * return: none
96: */
97: void
98: json_free(json_t * __restrict json)
99: {
100: if (json) {
101: if (json->h_alloc)
102: e_free(json);
103: else
104: memset(json, 0, sizeof(json_t));
105: }
106: }
107:
108: static jtok_t *
109: json_gettoken(json_t * __restrict json, jtok_t * __restrict jtoks, u_int toksnum)
110: {
111: jtok_t *tok;
112:
113: assert(json || !(!jtoks && toksnum));
114:
115: if (json->h_next >= toksnum) {
116: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
117: return NULL;
118: } else
119: tok = &jtoks[json->h_next];
120: tok->tok_idx = json->h_next++;
121: tok->tok_start = tok->tok_end = tok->tok_parent = -1;
122: tok->tok_size = 0;
123:
124: return tok;
125: }
126:
127: inline void
128: json_filltoken(jtok_t * __restrict tok, jtype_t type, long start, long end, long parent)
129: {
130: assert(tok);
131:
132: tok->tok_type = type;
133: tok->tok_start = start;
134: tok->tok_end = end;
135: tok->tok_parent = parent;
136: tok->tok_size = 0;
137: }
138:
139: static int
140: json_parse_string(json_t * __restrict json, const char *jstr, size_t jlen, jtok_t * __restrict jtoks, u_int toksnum)
141: {
142: jtok_t *tok;
143: u_long pos;
144: char ch;
145: register int i;
146:
147: assert(json || jstr || !(!jtoks && toksnum));
148:
149: for (pos = json->h_pos++; json->h_pos < jlen && jstr[json->h_pos]; json->h_pos++) {
150: ch = jstr[json->h_pos];
151:
152: if (ch == '\"') {
153: if (!jtoks)
154: return 0;
155: if (!(tok = json_gettoken(json, jtoks, toksnum))) {
156: json->h_pos = pos;
157: return -1;
158: } else
159: json_filltoken(tok, J_STRING, pos + 1, json->h_pos, json->h_parent);
160: return 0;
161: }
162:
163: if (ch == '\\' && json->h_pos + 1 < jlen) {
164: switch (jstr[++json->h_pos]) {
165: case '\"':
166: case '/':
167: case '\\':
168: case 'b':
169: case 'f':
170: case 'r':
171: case 'n':
172: case 't':
173: /* Allowed escaped symbols */
174: break;
175: case 'u':
176: /* Allows escaped symbol \uXXXX */
177: json->h_pos++;
178: for (i = 0; i < 4 && json->h_pos < jlen && jstr[json->h_pos]; i++, json->h_pos++) {
179: /* If it isn't a hex character we have an error */
180: if (!((jstr[json->h_pos] >= 48 && jstr[json->h_pos] <= 57) || /* 0-9 */
181: (jstr[json->h_pos] >= 65 && jstr[json->h_pos] <= 70) || /* A-F */
182: (jstr[json->h_pos] >= 97 && jstr[json->h_pos] <= 102))) { /* a-f */
183: json->h_pos = pos;
184: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
185: return -1;
186: }
187: }
188: json->h_pos--;
189: break;
190: default:
191: /* Unexpected symbol */
192: json->h_pos = pos;
193: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
194: return -1;
195: }
196: }
197: }
198:
199: json->h_pos = pos;
200: elwix_SetErr(J_ERR_PART, "%s", jerrstr[J_ERR_PART]);
201: return -1;
202: }
203:
204: static int
205: json_parse_value(json_t * __restrict json, const char *jstr, size_t jlen, jtok_t * __restrict jtoks, u_int toksnum)
206: {
207: jtok_t *tok;
208: u_long pos;
209:
210: assert(json || jstr || !(!jtoks && toksnum));
211:
212: for (pos = json->h_pos; json->h_pos < jlen && jstr[json->h_pos]; json->h_pos++) {
213: switch (jstr[json->h_pos]) {
214: case ':':
215: if (json->h_strict)
216: goto found;
217: break;
218: case '\t':
219: case '\r':
220: case '\n':
221: case ' ':
222: case ',':
223: case ']':
224: case '}':
225: goto found;
226: }
227: if (jstr[json->h_pos] < 32 || (u_char) jstr[json->h_pos] > 127) {
228: json->h_pos = pos;
229: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
230: return -1;
231: }
232: }
233:
234: if (json->h_strict) {
235: json->h_pos = pos;
236: elwix_SetErr(J_ERR_PART, "%s", jerrstr[J_ERR_PART]);
237: return -1;
238: }
239: found:
240: if (jtoks) {
241: if (!(tok = json_gettoken(json, jtoks, toksnum))) {
242: json->h_pos = pos;
243: return -1;
244: } else
245: json_filltoken(tok, J_VALUE, pos, json->h_pos, json->h_parent);
246: }
247:
248: json->h_pos--;
249: return 0;
250: }
251:
252: /*
253: * json_parse() - Parse JSON string
254: *
255: * @json = JSON handler
256: * @jstr = JSON string
257: * @jlen = JSON string length
258: * @jtoks = Token array
259: * @toksnum = Token array size, return number of allocated tokens in array
260: * return: -1 error or number of found tokens
261: */
262: u_int
263: json_parse(json_t * __restrict json, const char *jstr, size_t jlen, jtok_t * __restrict jtoks, u_int toksnum)
264: {
265: register int i;
266: register u_int cx;
267: jtype_t type;
268: jtok_t *tok;
269: char ch;
270:
271: if (!json || !jstr || (!jtoks && toksnum)) {
272: elwix_SetErr(J_ERR_PARAM, "%s", jerrstr[J_ERR_PARAM]);
273: return (u_int) -1;
274: }
275:
276: for (cx = json->h_next; json->h_pos < jlen && jstr[json->h_pos]; json->h_pos++) {
277: switch ((ch = jstr[json->h_pos])) {
278: case '{':
279: case '[':
280: cx++; /* start new object/array token */
281: if (!jtoks)
282: break;
283:
284: tok = json_gettoken(json, jtoks, toksnum);
285: if (!tok)
286: return (u_int) -1;
287: if (json->h_parent != -1) {
288: jtoks[json->h_parent].tok_size++;
289: tok->tok_parent = json->h_parent;
290: }
291: tok->tok_type = (ch == '{' ? J_OBJECT : J_ARRAY);
292: tok->tok_start = json->h_pos;
293: json->h_parent = json->h_next - 1;
294: break;
295: case '}':
296: case ']':
297: if (!jtoks)
298: break;
299:
300: if (json->h_next < 1) {
301: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
302: return (u_int) -1;
303: }
304:
305: type = (ch == '}' ? J_OBJECT : J_ARRAY);
306: tok = &jtoks[json->h_next - 1];
307: while (42) {
308: if (tok->tok_start != -1 && tok->tok_end == -1) {
309: if (tok->tok_type != type) {
310: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
311: return (u_int) -1;
312: }
313: tok->tok_end = json->h_pos + 1;
314: json->h_parent = tok->tok_parent;
315: break;
316: }
317: if (tok->tok_parent == -1) {
318: if (tok->tok_type != type || json->h_parent == -1) {
319: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
320: return (u_int) -1;
321: }
322: break;
323: }
324: tok = &jtoks[tok->tok_parent];
325: }
326: break;
327: case '\"':
328: if (json_parse_string(json, jstr, jlen, jtoks, toksnum) == -1)
329: return (u_int) -1;
330: cx++; /* start new string token */
331: if (jtoks && json->h_parent != -1)
332: jtoks[json->h_parent].tok_size++;
333: break;
334: case '\t':
335: case '\r':
336: case '\n':
337: case ' ':
338: /* whitespace, skip */
339: break;
340: case ':':
341: json->h_parent = json->h_next - 1;
342: break;
343: case ',':
344: if (jtoks && json->h_parent != -1 &&
345: jtoks[json->h_parent].tok_type != J_OBJECT &&
346: jtoks[json->h_parent].tok_type != J_ARRAY)
347: json->h_parent = jtoks[json->h_parent].tok_parent;
348: break;
349: case '-':
350: case '0':
351: case '1':
352: case '2':
353: case '3':
354: case '4':
355: case '5':
356: case '6':
357: case '7':
358: case '8':
359: case '9':
360: case 't':
361: case 'f':
362: case 'n':
363: if (json->h_strict) {
364: if (jtoks && json->h_parent != -1) {
365: /* they must not be keys of the object */
366: if (jtoks[json->h_parent].tok_type == J_OBJECT ||
367: (jtoks[json->h_parent].tok_type == J_STRING &&
368: jtoks[json->h_parent].tok_size)) {
369: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
370: return (u_int) -1;
371: }
372: }
373:
374: if (json_parse_value(json, jstr, jlen, jtoks, toksnum) == -1)
375: return (u_int) -1;
376: cx++; /* start new value token */
377: if (jtoks && json->h_parent != -1)
378: jtoks[json->h_parent].tok_size++;
379: break;
380: }
381: default:
382: if (json->h_strict) {
383: elwix_SetErr(J_ERR_INVAL, "%s", jerrstr[J_ERR_INVAL]);
384: return (u_int) -1;
385: }
386:
387: if (json_parse_value(json, jstr, jlen, jtoks, toksnum) == -1)
388: return (u_int) -1;
389: cx++; /* start new value token */
390: if (jtoks && json->h_parent != -1)
391: jtoks[json->h_parent].tok_size++;
392: break;
393: }
394: }
395:
396: if (jtoks) {
397: for (i = json->h_next - 1; i >= 0; i--) {
398: /* unmatched opened object or array */
399: if (jtoks[i].tok_start != -1 && jtoks[i].tok_end == -1) {
400: elwix_SetErr(J_ERR_PART, "%s", jerrstr[J_ERR_PART]);
401: return (u_int) -1;
402: }
403: }
404: } else
405: cx++; /* increment needed tokens number for termination empty token */
406:
407: return cx;
408: }
409:
410: /*
411: * json_token2val() - Return token to AIT variable
412: *
413: * @jstr = JSON string
414: * @tok = Token for convert
415: * @return =NULL error or !=NULL allocated variable, after use should be ait_freeVar()
416: */
417: ait_val_t *
418: json_token2val(const char *jstr, jtok_t * __restrict tok)
419: {
420: ait_val_t *v = NULL;
421:
422: if (!jstr || !tok)
423: return NULL;
424:
425: v = ait_allocVar();
426: if (!v)
427: return NULL;
428:
429: AIT_SET_STRSIZ(v, json_toklen(tok));
430: if (AIT_GET_STR(v))
431: strncpy(AIT_GET_STR(v), json_tokstr(jstr, tok), AIT_LEN(v) - 1);
432: else
433: ait_freeVar(&v);
434:
435: return v;
436: }
437:
438: /*
439: * json_token2rstr() - Return token to raw string
440: *
441: * @jstr = JSON string
442: * @tok = Token for convert
443: * @return =NULL error or !=NULL allocated str, after use should be json_freestr()|e_free()
444: */
445: char *
446: json_token2rstr(const char *jstr, jtok_t * __restrict tok)
447: {
448: char *str = NULL;
449: size_t len;
450:
451: if (!jstr || !tok)
452: return NULL;
453:
454: len = json_toklen(tok);
455: str = e_malloc(len + 1);
456: if (!str)
457: return NULL;
458: else {
459: memcpy(str, json_tokstr(jstr, tok), len);
460: str[len] = 0;
461: }
462:
463: return str;
464: }
465:
466: /*
467: * json_token2str() - Return token to string
468: *
469: * @jstr = JSON string
470: * @tok = Token for convert
471: * @return =NULL error or !=NULL allocated str, after use should be json_freestr()|e_free()
472: */
473: char *
474: json_token2str(const char *jstr, jtok_t * __restrict tok)
475: {
476: char *s, *s2, *wrk, *str = NULL;
477: size_t len;
478:
479: if (!jstr || !tok)
480: return NULL;
481:
482:
483: len = json_toklen(tok);
484: str = e_malloc(len + 1);
485: if (!str)
486: return NULL;
487: else {
488: memset(str, 0, len + 1);
489:
490: wrk = e_strdup(json_tokstr(jstr, tok));
491: wrk[len] = 0;
492: for (s = wrk, s2 = str; *s; s++)
493: *s2++ = (*s != '\\') ? *s : *++s;
494: e_free(wrk);
495: }
496:
497: return str;
498: }
499:
500: /*
501: * json_token2num() - Return token to numeric
502: *
503: * @jstr = JSON string
504: * @tok = Token for convert
505: * @return number
506: */
507: long
508: json_token2num(const char *jstr, jtok_t * __restrict tok)
509: {
510: long ret = 0;
511: char *str;
512:
513: str = json_token2rstr(jstr, tok);
514: if (!str)
515: return 0;
516:
517: ret = strtol(str, NULL, 0);
518: e_free(str);
519: return ret;
520: }
521:
522: /*
523: * json_token2dbl() - Return token to double
524: *
525: * @jstr = JSON string
526: * @tok = Token for convert
527: * @return number
528: */
529: double
530: json_token2dbl(const char *jstr, jtok_t * __restrict tok)
531: {
532: double ret = 0;
533: char *str;
534:
535: str = json_token2rstr(jstr, tok);
536: if (!str)
537: return 0;
538:
539: ret = strtod(str, NULL);
540: e_free(str);
541: return ret;
542: }
543:
544: /*
545: * json_token2bool() - Return token to bool int
546: *
547: * @jstr = JSON string
548: * @tok = Token for convert
549: * @return 0 for FALSE and !=0 for TRUE
550: */
551: int
552: json_token2bool(const char *jstr, jtok_t * __restrict tok)
553: {
554: double ret = 0;
555: char *str;
556:
557: str = json_token2rstr(jstr, tok);
558: if (!str)
559: return 0;
560:
561: switch (*str) {
562: case 't':
563: case 'T':
564: ret = 1;
565: break;
566: case 'f':
567: case 'F':
568: ret = 0;
569: break;
570: default:
571: ret = (int) strtol(str, NULL, 10);
572: break;
573: }
574: e_free(str);
575: return ret;
576: }
577:
578: /*
579: * json_findbykey() - Find token data by key
580: *
581: * @jstr = JSON string
582: * @key = Search key
583: * @type = Search key for particular token type, if is J_UNDEF this mean any type
584: * @toks = Parsed tokens
585: * @toksnum = Number of parsed tokens
586: * return: =NULL error or !=NULL data token found
587: */
588: jtok_t *
589: json_findbykey(const char *jstr, const char *key, jtype_t type, jtok_t * __restrict toks, int toksnum)
590: {
591: jtok_t *tok = NULL;
592: register int i;
593: int klen;
594:
595: if (!jstr || !key || !toks)
596: return NULL;
597: else
598: klen = strlen(key);
599:
600: for (i = 1; i < toksnum; i++) {
601: if (toks[i].tok_type == J_STRING && toks[i].tok_size == 1 &&
602: klen == toks[i].tok_end - toks[i].tok_start &&
603: !strncmp(jstr + toks[i].tok_start, key, klen)) {
604: if (type != J_UNDEF) {
605: if (toks[i + 1].tok_type == type) {
606: tok = toks + i + 1;
607: break;
608: }
609: } else {
610: tok = toks + i + 1;
611: break;
612: }
613: }
614: }
615:
616: return tok;
617: }
618:
619: /*
620: * json_findbykeyatscope() - Find token data by key at particular scope
621: *
622: * @scope = Search at object scope, =0 main object scope
623: * @jstr = JSON string
624: * @key = Search key
625: * @type = Search key for particular token type, if is J_UNDEF this mean any type
626: * @toks = Parsed tokens
627: * @toksnum = Number of parsed tokens
628: * return: =NULL error or !=NULL data token found
629: */
630: jtok_t *
631: json_findbykeyatscope(long scope, const char *jstr, const char *key, jtype_t type, jtok_t * __restrict toks, int toksnum)
632: {
633: jtok_t *tok = NULL;
634: register int i;
635: int klen;
636:
637: if (!jstr || !key || !toks)
638: return NULL;
639: else
640: klen = strlen(key);
641:
642: for (i = 1; i < toksnum; i++) {
643: if (toks[i].tok_type == J_STRING && toks[i].tok_size == 1 &&
644: toks[i].tok_parent == scope &&
645: klen == toks[i].tok_end - toks[i].tok_start &&
646: !strncmp(jstr + toks[i].tok_start, key, klen)) {
647: if (type != J_UNDEF) {
648: if (toks[i + 1].tok_type == type) {
649: tok = toks + i + 1;
650: break;
651: }
652: } else {
653: tok = toks + i + 1;
654: break;
655: }
656: }
657: }
658:
659: return tok;
660: }
661:
662: /*
663: * json_findbypos() - Find token by position on JSON string
664: *
665: * @pos = Offset from begin of JSON string
666: * @toks = Parsed tokens
667: * @toksnum = Number of parsed tokens
668: * return: =NULL error or !=NULL token found
669: */
670: jtok_t *
671: json_findbypos(u_long pos, jtok_t * __restrict toks, int toksnum)
672: {
673: jtok_t *tok = NULL;
674: register int i;
675:
676: if (!toks)
677: return NULL;
678:
679: for (i = 1; i < toksnum; i++)
680: if (pos <= toks[i].tok_end && pos >= toks[i].tok_start) {
681: tok = toks + i;
682: break;
683: }
684:
685: return tok;
686: }
687:
688: /*
689: * json_token2vars() - Convert token to string variable array
690: *
691: * @jstr = JSON string
692: * @tok = Token for convert
693: * return: =NULL error or !=NULL allocated array with string variables,
694: * after use should be ait_freeVars()
695: */
696: array_t *
697: json_token2vars(const char *jstr, jtok_t * __restrict tok)
698: {
699: array_t *arr = NULL;
700: register int i, j;
701: int siz;
702: ait_val_t *v;
703: jtok_t *t;
704:
705: if (!jstr || !tok)
706: return NULL;
707:
708: siz = tok->tok_size;
709: if (!siz && json_toktype(tok) != J_ARRAY && json_toktype(tok) != J_OBJECT)
710: siz++;
711:
712: arr = ait_allocVars(siz);
713: if (!arr)
714: return NULL;
715:
716: if (tok->tok_type == J_STRING || tok->tok_type == J_VALUE) {
717: v = ait_getVars(&arr, 0);
718: AIT_SET_STRSIZ(v, json_toklen(tok) + 1);
719: if (AIT_GET_STR(v)) {
720: json_tokstrcpy(AIT_GET_STR(v), jstr, tok);
721: } else {
722: ait_freeVar(&v);
723: }
724: } else if (tok->tok_type == J_ARRAY) {
725: for (i = 0, j = 1; i < tok->tok_size; i++) {
726: t = &tok[i + j];
727: v = ait_getVars(&arr, i);
728: AIT_SET_STRSIZ(v, json_toklen(t) + 1);
729: if (AIT_GET_STR(v)) {
730: json_tokstrcpy(AIT_GET_STR(v), jstr, t);
731: } else {
732: ait_freeVar(&v);
733: }
734:
735: /* if there we have array from objects should parse all object tokens */
736: while (i < tok->tok_size - 1 && tok->tok_idx != tok[i + j + 1].tok_parent)
737: j++;
738: }
739: } else if (tok->tok_type == J_OBJECT) {
740: for (i = 0; tok->tok_idx <= tok[i + 1].tok_parent; i++) {
741: t = &tok[i + 1];
742: v = ait_getVars(&arr, i);
743: AIT_SET_STRSIZ(v, json_toklen(t) + 1);
744: if (AIT_GET_STR(v)) {
745: json_tokstrcpy(AIT_GET_STR(v), jstr, t);
746: } else {
747: ait_freeVar(&v);
748: }
749: }
750: } else {
751: elwix_SetErr(J_ERR_PARAM, "%s", jerrstr[J_ERR_PARAM]);
752: ait_freeVars(&arr);
753: return NULL;
754: }
755:
756: return arr;
757: }
758:
759: /*
760: * json_token2array() - Convert token to string array
761: *
762: * @jstr = JSON string
763: * @tok = Token for convert
764: * return: =NULL error or !=NULL allocated array with strings,
765: * after use should be ait_freearray()
766: */
767: array_t *
768: json_token2array(const char *jstr, jtok_t * __restrict tok)
769: {
770: array_t *arr = NULL;
771: register int i, j;
772: int siz;
773: char *str;
774: jtok_t *t;
775:
776: if (!jstr || !tok)
777: return NULL;
778:
779: siz = tok->tok_size;
780: if (!siz && json_toktype(tok) != J_ARRAY && json_toktype(tok) != J_OBJECT)
781: siz++;
782:
783: arr = array_Init(siz);
784: if (!arr)
785: return NULL;
786:
787: if (tok->tok_type == J_STRING || tok->tok_type == J_VALUE) {
788: str = e_malloc(json_toklen(tok) + 1);
789: if (!str) {
790: array_Destroy(&arr);
791: return NULL;
792: } else
793: json_tokstrcpy(str, jstr, tok);
794: if (array_Push(arr, str, 0) == -1) {
795: e_free(str);
796: array_Destroy(&arr);
797: return NULL;
798: }
799: } else if (tok->tok_type == J_ARRAY) {
800: for (i = 0, j = 1; i < tok->tok_size; i++) {
801: t = &tok[i + j];
802: str = e_malloc(json_toklen(t) + 1);
803: if (!str) {
804: json_freearray(&arr);
805: return NULL;
806: } else
807: json_tokstrcpy(str, jstr, t);
808: if (array_Push(arr, str, 0) == -1) {
809: e_free(str);
810: json_freearray(&arr);
811: return NULL;
812: }
813:
814: /* if there we have array from objects should parse all object tokens */
815: while (i < tok->tok_size - 1 && tok->tok_idx != tok[i + j + 1].tok_parent)
816: j++;
817: }
818: } else if (tok->tok_type == J_OBJECT) {
819: for (i = 0; tok->tok_idx <= tok[i + 1].tok_parent; i++) {
820: t = &tok[i + 1];
821: str = e_malloc(json_toklen(t) + 1);
822: if (!str) {
823: json_freearray(&arr);
824: return NULL;
825: } else
826: json_tokstrcpy(str, jstr, t);
827: if (array_Push(arr, str, 0) == -1) {
828: e_free(str);
829: json_freearray(&arr);
830: return NULL;
831: }
832: }
833: } else {
834: elwix_SetErr(J_ERR_PARAM, "%s", jerrstr[J_ERR_PARAM]);
835: array_Destroy(&arr);
836: return NULL;
837: }
838:
839: return arr;
840: }
841:
842: /*
843: * json_freearray() - Free & destroy allocated array from json_token2array function
844: *
845: * @parr = Array
846: * return -1 error or 0 ok
847: */
848: int
849: json_freearray(array_t **parr)
850: {
851: if (!parr)
852: return -1;
853:
854: array_Free(*parr);
855: array_Destroy(parr);
856: return 0;
857: }
858:
859:
860: /*
861: * json_add_begin_object() - Adds begin of object {
862: *
863: * @jstr = JSON string
864: * @jlen = JSON string length
865: * @wspace = whitespace include
866: * return: -1 error or !=-1 actual JSON string length
867: */
868: int
869: json_add_begin_object(char * __restrict jstr, int jlen, int wspace)
870: {
871: int len;
872: size_t eos;
873:
874: if (!jstr)
875: return -1;
876: else
877: eos = strlen(jstr);
878:
879:
880: if (wspace)
881: len = strlcat(jstr, "{ ", jlen);
882: else
883: len = strlcat(jstr, "{", jlen);
884:
885: if (len >= jlen) {
886: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
887: jstr[eos] = 0;
888: return -1;
889: }
890:
891: return len;
892: }
893:
894: /*
895: * json_add_end_object() - Adds end of object }
896: *
897: * @jstr = JSON string
898: * @jlen = JSON string length
899: * @wspace = whitespace include
900: * return: -1 error or !=-1 actual JSON string length
901: */
902: int
903: json_add_end_object(char * __restrict jstr, int jlen, int wspace)
904: {
905: int len;
906: size_t eos;
907:
908: if (!jstr)
909: return -1;
910: else
911: eos = strlen(jstr);
912:
913: if (wspace)
914: len = strlcat(jstr, " }", jlen);
915: else
916: len = strlcat(jstr, "}", jlen);
917:
918: if (len >= jlen) {
919: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
920: jstr[eos] = 0;
921: return -1;
922: }
923:
924: return len;
925: }
926:
927: /*
928: * json_add_begin_array() - Adds begin of array [
929: *
930: * @jstr = JSON string
931: * @jlen = JSON string length
932: * @wspace = whitespace include
933: * return: -1 error or !=-1 actual JSON string length
934: */
935: int
936: json_add_begin_array(char * __restrict jstr, int jlen, int wspace)
937: {
938: int len;
939: size_t eos;
940:
941: if (!jstr)
942: return -1;
943: else
944: eos = strlen(jstr);
945:
946: if (wspace)
947: len = strlcat(jstr, "[ ", jlen);
948: else
949: len = strlcat(jstr, "[", jlen);
950:
951: if (len >= jlen) {
952: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
953: jstr[eos] = 0;
954: return -1;
955: }
956:
957: return len;
958: }
959:
960: /*
961: * json_add_end_array() - Adds end of array ]
962: *
963: * @jstr = JSON string
964: * @jlen = JSON string length
965: * @wspace = whitespace include
966: * return: -1 error or !=-1 actual JSON string length
967: */
968: int
969: json_add_end_array(char * __restrict jstr, int jlen, int wspace)
970: {
971: int len;
972: size_t eos;
973:
974: if (!jstr)
975: return -1;
976: else
977: eos = strlen(jstr);
978:
979: if (wspace)
980: len = strlcat(jstr, " ]", jlen);
981: else
982: len = strlcat(jstr, "]", jlen);
983:
984: if (len >= jlen) {
985: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
986: jstr[eos] = 0;
987: return -1;
988: }
989:
990: return len;
991: }
992:
993: /*
994: * json_add_char() - Adds character
995: *
996: * @jstr = JSON string
997: * @jlen = JSON string length
998: * @ch = Character
999: * return: -1 error or !=-1 actual JSON string length
1000: */
1001: int
1002: json_add_char(char * __restrict jstr, int jlen, u_char ch)
1003: {
1004: int len;
1005:
1006: if (!jstr)
1007: return -1;
1008:
1009: len = strlen(jstr) + 1;
1010: if (len >= jlen) {
1011: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1012: return -1;
1013: } else {
1014: jstr[len++] = (char) ch;
1015: jstr[len] = 0;
1016: }
1017:
1018: return len;
1019: }
1020:
1021: /*
1022: * json_add_colon() - Adds key/value pair delimiter colon :
1023: *
1024: * @jstr = JSON string
1025: * @jlen = JSON string length
1026: * @wspace = whitespace include
1027: * return: -1 error or !=-1 actual JSON string length
1028: */
1029: int
1030: json_add_colon(char * __restrict jstr, int jlen, int wspace)
1031: {
1032: int len;
1033: size_t eos;
1034:
1035: if (!jstr)
1036: return -1;
1037: else
1038: eos = strlen(jstr);
1039:
1040: if (wspace)
1041: len = strlcat(jstr, ": ", jlen);
1042: else
1043: len = strlcat(jstr, ":", jlen);
1044:
1045: if (len >= jlen) {
1046: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1047: jstr[eos] = 0;
1048: return -1;
1049: }
1050:
1051: return len;
1052: }
1053:
1054: /*
1055: * json_add_comma() - Adds value delimiter comma ,
1056: *
1057: * @jstr = JSON string
1058: * @jlen = JSON string length
1059: * @wspace = whitespace include
1060: * return: -1 error or !=-1 actual JSON string length
1061: */
1062: int
1063: json_add_comma(char * __restrict jstr, int jlen, int wspace)
1064: {
1065: int len;
1066: size_t eos;
1067:
1068: if (!jstr)
1069: return -1;
1070: else
1071: eos = strlen(jstr);
1072:
1073: if (wspace)
1074: len = strlcat(jstr, ", ", jlen);
1075: else
1076: len = strlcat(jstr, ",", jlen);
1077:
1078: if (len >= jlen) {
1079: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1080: jstr[eos] = 0;
1081: return -1;
1082: }
1083:
1084: return len;
1085: }
1086:
1087: /*
1088: * json_add_string() - Adds string
1089: *
1090: * @jstr = JSON string
1091: * @jlen = JSON string length
1092: * @unquot = Unquoted string
1093: * @str = String, it can't be NULL
1094: * return: -1 error or !=-1 actual JSON string length
1095: */
1096: int
1097: json_add_string(char * __restrict jstr, int jlen, int unquot, const char *str)
1098: {
1099: int len;
1100: size_t eos;
1101:
1102: if (!jstr || !str)
1103: return -1;
1104: else
1105: eos = strlen(jstr);
1106:
1107: if (!unquot) {
1108: len = strlcat(jstr, "\"", jlen);
1109: if (len >= jlen) {
1110: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1111: jstr[eos] = 0;
1112: return -1;
1113: }
1114: }
1115: len = strlcat(jstr, str, jlen);
1116: if (len >= jlen) {
1117: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1118: jstr[eos] = 0;
1119: return -1;
1120: }
1121: if (!unquot) {
1122: len = strlcat(jstr, "\"", jlen);
1123: if (len >= jlen) {
1124: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1125: jstr[eos] = 0;
1126: return -1;
1127: }
1128: }
1129:
1130: return len;
1131: }
1132:
1133: /*
1134: * json_add_value() - Adds value
1135: *
1136: * @jstr = JSON string
1137: * @jlen = JSON string length
1138: * @unquot = Unquoted number
1139: * @num = Number
1140: * return: -1 error or !=-1 actual JSON string length
1141: */
1142: int
1143: json_add_value(char * __restrict jstr, int jlen, int unquot, long num)
1144: {
1145: int len;
1146: char wrk[STRSIZ] = { [0 ... STRSIZ - 1] = 0 };
1147: size_t eos;
1148:
1149: if (!jstr)
1150: return -1;
1151: else
1152: eos = strlen(jstr);
1153:
1154: if (!unquot) {
1155: len = strlcat(jstr, "\"", jlen);
1156: if (len >= jlen) {
1157: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1158: jstr[eos] = 0;
1159: return -1;
1160: }
1161: }
1162: snprintf(wrk, sizeof wrk, "%ld", num);
1163: len = strlcat(jstr, wrk, jlen);
1164: if (len >= jlen) {
1165: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1166: jstr[eos] = 0;
1167: return -1;
1168: }
1169: if (!unquot) {
1170: len = strlcat(jstr, "\"", jlen);
1171: if (len >= jlen) {
1172: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1173: jstr[eos] = 0;
1174: return -1;
1175: }
1176: }
1177:
1178: return len;
1179: }
1180:
1181: /*
1182: * json_add_pair() - Adds key/value pair
1183: *
1184: * @jstr = JSON string
1185: * @jlen = JSON string length
1186: * @wspace = whitespace include
1187: * @key = Key string
1188: * @val = Value string
1189: * return: -1 error or !=-1 actual JSON string length
1190: */
1191: int
1192: json_add_pair(char * __restrict jstr, int jlen, int wspace, const char *key, const char *val)
1193: {
1194: int len = -1;
1195: size_t eos;
1196:
1197: if (!jstr || !key || !val)
1198: return -1;
1199: else
1200: eos = strlen(jstr);
1201:
1202: if (json_add_string(jstr, jlen, 0, key) == -1) {
1203: jstr[eos] = 0;
1204: return -1;
1205: }
1206: if (json_add_colon(jstr, jlen, wspace) == -1) {
1207: jstr[eos] = 0;
1208: return -1;
1209: }
1210: if ((len = json_add_string(jstr, jlen, 0, val)) == -1) {
1211: jstr[eos] = 0;
1212: return -1;
1213: }
1214:
1215: return len;
1216: }
1217:
1218: /*
1219: * json_add_pair2() - Adds key/value pair with formated args
1220: *
1221: * @jstr = JSON string
1222: * @jlen = JSON string length
1223: * @wspace = whitespace include
1224: * @key = Key string
1225: * @fmt = Format string for values
1226: * return: -1 error or !=-1 actual JSON string length
1227: */
1228: int
1229: json_add_pair2(char * __restrict jstr, int jlen, int wspace, const char *key, const char *fmt, ...)
1230: {
1231: int len = -1;
1232: size_t eos;
1233: va_list lst;
1234: char szStr[BUFSIZ] = { [0 ... BUFSIZ - 1] = 0 };
1235:
1236: if (!jstr || !key || !fmt)
1237: return -1;
1238: else
1239: eos = strlen(jstr);
1240:
1241: if (json_add_string(jstr, jlen, 0, key) == -1) {
1242: jstr[eos] = 0;
1243: return -1;
1244: }
1245: if (json_add_colon(jstr, jlen, wspace) == -1) {
1246: jstr[eos] = 0;
1247: return -1;
1248: }
1249: va_start(lst, fmt);
1250: vsnprintf(szStr, sizeof szStr, fmt, lst);
1251: va_end(lst);
1252: if ((len = json_add_string(jstr, jlen, 0, szStr)) == -1) {
1253: jstr[eos] = 0;
1254: return -1;
1255: }
1256:
1257: return len;
1258: }
1259:
1260: /*
1261: * json_add_array() - Adds array
1262: *
1263: * @jstr = JSON string
1264: * @jlen = JSON string length
1265: * @wspace = whitespace include
1266: * @arr = Array with variables
1267: * return: -1 error or !=-1 actual JSON string length
1268: */
1269: int
1270: json_add_array(char * __restrict jstr, int jlen, int wspace, array_t * __restrict arr)
1271: {
1272: int len = -1;
1273: register int i;
1274: ait_val_t *v;
1275: size_t eos;
1276:
1277: if (!jstr || !arr)
1278: return -1;
1279: else
1280: eos = strlen(jstr);
1281:
1282: if (json_add_begin_array(jstr, jlen, wspace) == -1) {
1283: jstr[eos] = 0;
1284: return -1;
1285: }
1286: for (i = 0; i < array_Size(arr); i++) {
1287: v = array(arr, i, ait_val_t*);
1288: if (v) {
1289: if (AIT_TYPE(v) == string) {
1290: if (json_add_string(jstr, jlen, 0, AIT_GET_STR(v)) == -1) {
1291: jstr[eos] = 0;
1292: return -1;
1293: }
1294: } else {
1295: if (json_add_value(jstr, jlen, 0, AIT_GET_LIKE(v, long)) == -1) {
1296: jstr[eos] = 0;
1297: return -1;
1298: }
1299: }
1300: if (i < array_Size(arr) - 1 && json_add_comma(jstr, jlen, wspace) == -1) {
1301: jstr[eos] = 0;
1302: return -1;
1303: }
1304: }
1305: }
1306: if ((len = json_add_end_array(jstr, jlen, wspace)) == -1) {
1307: jstr[eos] = 0;
1308: return -1;
1309: }
1310:
1311: return len;
1312: }
1313:
1314: /*
1315: * json_dump_yaml() - Dump parsed JSON string to YAML format
1316: *
1317: * @f = Output handler
1318: * @jstr = JSON string
1319: * @toks = JSON tokens
1320: * @toksnum = Number of tokens
1321: * @indent = Start indent spaces
1322: * return: 0 done and 1 added one more item
1323: */
1324: int
1325: json_dump_yaml(FILE *f, const char *jstr, jtok_t *toks, int toksnum, int indent)
1326: {
1327: register int i, j, k;
1328:
1329: if (!toksnum || !toks)
1330: return 0;
1331:
1332: if (toks->tok_type == J_VALUE) {
1333: fprintf(f, "%.*s", (int) json_toklen(toks), json_tokstr(jstr, toks));
1334: return 1;
1335: } else if (toks->tok_type == J_STRING) {
1336: fprintf(f, "%.*s", (int) json_toklen(toks), json_tokstr(jstr, toks));
1337: return 1;
1338: } else if (toks->tok_type == J_OBJECT) {
1339: fprintf(f, "\n");
1340: for (j = i = 0; i < json_toksize(toks); i++) {
1341: for (k = 0; k < indent; k++)
1342: fprintf(f, " ");
1343: j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1344: fprintf(f, ": ");
1345: j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1346: fprintf(f, "\n");
1347: }
1348: return j + 1;
1349: } else if (toks->tok_type == J_ARRAY) {
1350: fprintf(f, "\n");
1351: for (j = i = 0; i < json_toksize(toks); i++) {
1352: for (k = 0; k < indent - 1; k++)
1353: fprintf(f, " ");
1354: fprintf(f, " - ");
1355: j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1356: fprintf(f, "\n");
1357: }
1358: return j + 1;
1359: }
1360:
1361: return 0;
1362: }
1363:
1364: /*
1365: * json_dump() - Dump parsed JSON string to structure format
1366: *
1367: * @f = Output handler
1368: * @jstr = JSON string
1369: * @toks = JSON tokens
1370: * @toksnum = Number of tokens
1371: * @indent = Start indent spaces
1372: * return: 0 done and 1 added one more item
1373: */
1374: int
1375: json_dump(FILE *f, const char *jstr, jtok_t *toks, int toksnum, int indent)
1376: {
1377: register int i, j, k;
1378:
1379: if (!toksnum)
1380: return 0;
1381:
1382: if (toks->tok_type == J_VALUE) {
1383: fprintf(f, "[idx=%ld type=VALUE start=%ld end=%ld size=%ld parent=%ld] = %.*s",
1384: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent,
1385: (int) json_toklen(toks), json_tokstr(jstr, toks));
1386: return 1;
1387: } else if (toks->tok_type == J_STRING) {
1388: fprintf(f, "[idx=%ld type=STRING start=%ld end=%ld size=%ld parent=%ld] = %.*s",
1389: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent,
1390: (int) json_toklen(toks), json_tokstr(jstr, toks));
1391: return 1;
1392: } else if (toks->tok_type == J_OBJECT) {
1393: fprintf(f, "\n");
1394: fprintf(f, "object:: [idx=%ld type=OBJECT start=%ld end=%ld size=%ld parent=%ld]\n",
1395: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent);
1396: for (j = i = 0; i < json_toksize(toks); i++) {
1397: for (k = 0; k < indent; k++)
1398: fprintf(f, " ");
1399: j += json_dump(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1400: fprintf(f, ": ");
1401: j += json_dump(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1402: fprintf(f, "\n");
1403: }
1404: return j + 1;
1405: } else if (toks->tok_type == J_ARRAY) {
1406: fprintf(f, "\n");
1407: fprintf(f, "array[] [idx=%ld type=ARRAY start=%ld end=%ld size=%ld parent=%ld]",
1408: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent);
1409: for (j = i = 0; i < json_toksize(toks); i++) {
1410: for (k = 0; k < indent - 1; k++)
1411: fprintf(f, " ");
1412: j += json_dump(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1413: fprintf(f, "\n");
1414: }
1415: return j + 1;
1416: }
1417:
1418: return 0;
1419: }
1420:
1421: /*
1422: * json_objscope() - Find object scope of key
1423: *
1424: * @key = Key of object, if it is =NULL, then return 0 (default scope)
1425: * @jstr = JSON string
1426: * @toks = JSON tokens
1427: * @toksnum = Number of tokens
1428: * return: -1 on error or >=0 scope of object
1429: */
1430: long
1431: json_objscope(const char *key, const char *jstr, jtok_t * __restrict toks, int toksnum)
1432: {
1433: long scope = 0;
1434: register int i;
1435: int klen;
1436:
1437: if (!key)
1438: return 0; /* default scope */
1439:
1440: if (!jstr || !toks)
1441: return -1;
1442: else
1443: klen = strlen(key);
1444:
1445: for (i = 1; i < toksnum; i++)
1446: if (toks[i].tok_type == J_STRING && toks[i].tok_size == 1 &&
1447: klen == toks[i].tok_end - toks[i].tok_start &&
1448: !strncmp(jstr + toks[i].tok_start, key, klen))
1449: if (toks[i + 1].tok_type == J_OBJECT) {
1450: scope = toks[i + 1].tok_idx;
1451: break;
1452: }
1453:
1454: return scope;
1455: }
1456:
1457: /*
1458: * json_validate() - Validate JSON
1459: *
1460: * @jstr = JSON string
1461: * @started = if started != NULL then here will return start position of found JSON
1462: * return: -1 error or >=0 where valid JSON ends
1463: */
1464: int
1465: json_validate(const char *jstr, int *started)
1466: {
1467: register int o = 0, a = 0, q = 0, pos = 0;
1468:
1469: if (!jstr)
1470: return -1;
1471:
1472: if (started)
1473: *started = 0;
1474:
1475: while (jstr[pos] && jstr[pos] != '{' && jstr[pos] != '[') {
1476: pos++;
1477: if (started)
1478: (*started)++;
1479: }
1480:
1481: do {
1482: switch (jstr[pos++]) {
1483: case '{':
1484: o++;
1485: break;
1486: case '}':
1487: o--;
1488: break;
1489: case '[':
1490: a++;
1491: break;
1492: case ']':
1493: a--;
1494: break;
1495: case '"':
1496: q = ~q;
1497: break;
1498: case '\\':
1499: pos++;
1500: break;
1501: case 0: /* string ends without valid JSON */
1502: if (started)
1503: *started = 0;
1504: return 0;
1505: }
1506: } while (q || a || o);
1507:
1508: return pos;
1509: }
1510:
1511: /*
1512: * json_marshaling() - Prepare JSON to one continues line
1513: *
1514: * @jstr = JSON string
1515: * @space = if it is 0 then spaces will be removed
1516: * return NULL error or !=NULL ready JSON for proceeding
1517: */
1518: char *
1519: json_marshaling(char * __restrict jstr, int space)
1520: {
1521: int started, ended, len;
1522: char *str, *pos, *js;
1523: register int q = 0;
1524:
1525: if (!jstr)
1526: return NULL;
1527: else
1528: js = jstr;
1529:
1530: ended = json_validate(jstr, &started);
1531: if (!ended)
1532: return NULL;
1533: len = ended - started + 1;
1534: str = e_malloc(len);
1535: if (!str)
1536: return NULL;
1537: else {
1538: memset(str, 0, len);
1539: pos = str;
1540: }
1541:
1542: js += started;
1543: while (*js && js < jstr + ended && --len) {
1544: if (*js < 0x20) {
1545: js++;
1546: continue;
1547: }
1548: if (space && !q && *js == 0x20) {
1549: js++;
1550: continue;
1551: }
1552: if (*js == '"')
1553: q = ~q;
1554: *pos++ = *js++;
1555: }
1556: *pos = 0;
1557:
1558: len = strlen(jstr) + 1;
1559: strlcpy(jstr, str, len);
1560: e_free(str);
1561: return jstr;
1562: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to json.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libelwix / src