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.4.6.3 2018/04/18 14:55:45 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 - 2018
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 || 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: strncpy(AIT_GET_STR(v), json_tokstr(jstr, tok), AIT_LEN(v) - 1);
431:
432: return v;
433: }
434:
435: /*
436: * json_token2str() - Return token to string
437: *
438: * @jstr = JSON string
439: * @tok = Token for convert
440: * @return =NULL error or !=NULL allocated str, after use should be json_freestr()|e_free()
441: */
442: char *
443: json_token2str(const char *jstr, jtok_t * __restrict tok)
444: {
445: char *str = NULL;
446: size_t len;
447:
448: if (!jstr || !tok)
449: return NULL;
450:
451: len = json_toklen(tok);
452: str = e_malloc(len + 1);
453: if (!str)
454: return NULL;
455: else {
456: strncpy(str, json_tokstr(jstr, tok), len);
457: str[len] = 0;
458: }
459:
460: return str;
461: }
462:
463: /*
464: * json_token2num() - Return token to numeric
465: *
466: * @jstr = JSON string
467: * @tok = Token for convert
468: * @return number
469: */
470: long
471: json_token2num(const char *jstr, jtok_t * __restrict tok)
472: {
473: long ret = 0;
474: char *str;
475:
476: str = json_token2str(jstr, tok);
477: if (!str)
478: return 0;
479:
480: ret = strtol(str, NULL, 0);
481: e_free(str);
482: return ret;
483: }
484:
485: /*
486: * json_token2dbl() - Return token to double
487: *
488: * @jstr = JSON string
489: * @tok = Token for convert
490: * @return number
491: */
492: double
493: json_token2dbl(const char *jstr, jtok_t * __restrict tok)
494: {
495: double ret = 0;
496: char *str;
497:
498: str = json_token2str(jstr, tok);
499: if (!str)
500: return 0;
501:
502: ret = strtod(str, NULL);
503: e_free(str);
504: return ret;
505: }
506:
507: /*
508: * json_findbykey() - Find token data by key
509: *
510: * @jstr = JSON string
511: * @key = Search key
512: * @type = Search key for particular token type, if is J_UNDEF this mean any type
513: * @toks = Parsed tokens
514: * @toksnum = Number of parsed tokens
515: * return: =NULL error or !=NULL data token found
516: */
517: jtok_t *
518: json_findbykey(const char *jstr, const char *key, jtype_t type, jtok_t * __restrict toks, int toksnum)
519: {
520: jtok_t *tok = NULL;
521: register int i;
522: int klen;
523:
524: if (!jstr || !key || !toks)
525: return NULL;
526: else
527: klen = strlen(key);
528:
529: for (i = 1; i < toksnum; i++) {
530: if (toks[i].tok_type == J_STRING &&
531: klen == toks[i].tok_end - toks[i].tok_start &&
532: !strncmp(jstr + toks[i].tok_start, key, klen)) {
533: if (type != J_UNDEF) {
534: if (toks[i + 1].tok_type == type) {
535: tok = toks + i + 1;
536: break;
537: }
538: } else {
539: tok = toks + i + 1;
540: break;
541: }
542: }
543: }
544:
545: return tok;
546: }
547:
548: /*
549: * json_findbypos() - Find token by position on JSON string
550: *
551: * @pos = Offset from begin of JSON string
552: * @toks = Parsed tokens
553: * @toksnum = Number of parsed tokens
554: * return: =NULL error or !=NULL token found
555: */
556: jtok_t *
557: json_findbypos(u_long pos, jtok_t * __restrict toks, int toksnum)
558: {
559: jtok_t *tok = NULL;
560: register int i;
561:
562: if (toks)
563: return NULL;
564:
565: for (i = 1; i < toksnum; i++)
566: if (pos <= toks[i].tok_end && pos >= toks[i].tok_start) {
567: tok = toks + i;
568: break;
569: }
570:
571: return tok;
572: }
573:
574: /*
575: * json_token2array() - Convert token to string array
576: *
577: * @jstr = JSON string
578: * @tok = Token for convert
579: * return: =NULL error or !=NULL allocated array with string variables,
580: * after use should be ait_freeVars()
581: */
582: array_t *
583: json_token2array(const char *jstr, jtok_t * __restrict tok)
584: {
585: array_t *arr = NULL;
586: register int i, j;
587: int siz;
588: ait_val_t *v;
589: jtok_t *t;
590:
591: if (!jstr || !tok)
592: return NULL;
593:
594: siz = tok->tok_size;
595: if (!siz && json_toktype(tok) != J_ARRAY && json_toktype(tok) != J_OBJECT)
596: siz++;
597:
598: arr = ait_allocVars(siz);
599: if (!arr)
600: return NULL;
601:
602: if (tok->tok_type == J_STRING || tok->tok_type == J_VALUE) {
603: v = ait_getVars(&arr, 0);
604: AIT_SET_STRSIZ(v, json_toklen(tok) + 1);
605: json_tokstrcpy(AIT_GET_STR(v), jstr, tok);
606: } else if (tok->tok_type == J_ARRAY) {
607: for (i = 0, j = 1; i < tok->tok_size; i++) {
608: t = &tok[i + j];
609: v = ait_getVars(&arr, i);
610: AIT_SET_STRSIZ(v, json_toklen(t) + 1);
611: json_tokstrcpy(AIT_GET_STR(v), jstr, t);
612:
613: /* if there we have array from objects should parse all object tokens */
614: while (i < tok->tok_size - 1 && tok->tok_idx != tok[i + j + 1].tok_parent)
615: j++;
616: }
617: } else if (tok->tok_type == J_OBJECT) {
618: for (i = 0; tok->tok_idx <= tok[i + 1].tok_parent; i++) {
619: t = &tok[i + 1];
620: v = ait_getVars(&arr, i);
621: AIT_SET_STRSIZ(v, json_toklen(t) + 1);
622: json_tokstrcpy(AIT_GET_STR(v), jstr, t);
623: }
624: } else {
625: elwix_SetErr(J_ERR_PARAM, "%s", jerrstr[J_ERR_PARAM]);
626: ait_freeVars(&arr);
627: return NULL;
628: }
629:
630: return arr;
631: }
632:
633:
634:
635: /*
636: * json_add_begin_object() - Adds begin of object {
637: *
638: * @jstr = JSON string
639: * @jlen = JSON string length
640: * @wspace = whitespace include
641: * return: -1 error or !=-1 actual JSON string length
642: */
643: int
644: json_add_begin_object(char * __restrict jstr, int jlen, int wspace)
645: {
646: int len;
647: size_t eos;
648:
649: if (!jstr)
650: return -1;
651: else
652: eos = strlen(jstr);
653:
654:
655: if (wspace)
656: len = strlcat(jstr, "{ ", jlen);
657: else
658: len = strlcat(jstr, "{", jlen);
659:
660: if (len >= jlen) {
661: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
662: jstr[eos] = 0;
663: return -1;
664: }
665:
666: return len;
667: }
668:
669: /*
670: * json_add_end_object() - Adds end of object }
671: *
672: * @jstr = JSON string
673: * @jlen = JSON string length
674: * @wspace = whitespace include
675: * return: -1 error or !=-1 actual JSON string length
676: */
677: int
678: json_add_end_object(char * __restrict jstr, int jlen, int wspace)
679: {
680: int len;
681: size_t eos;
682:
683: if (!jstr)
684: return -1;
685: else
686: eos = strlen(jstr);
687:
688: if (wspace)
689: len = strlcat(jstr, " }", jlen);
690: else
691: len = strlcat(jstr, "}", jlen);
692:
693: if (len >= jlen) {
694: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
695: jstr[eos] = 0;
696: return -1;
697: }
698:
699: return len;
700: }
701:
702: /*
703: * json_add_begin_array() - Adds begin of array [
704: *
705: * @jstr = JSON string
706: * @jlen = JSON string length
707: * @wspace = whitespace include
708: * return: -1 error or !=-1 actual JSON string length
709: */
710: int
711: json_add_begin_array(char * __restrict jstr, int jlen, int wspace)
712: {
713: int len;
714: size_t eos;
715:
716: if (!jstr)
717: return -1;
718: else
719: eos = strlen(jstr);
720:
721: if (wspace)
722: len = strlcat(jstr, "[ ", jlen);
723: else
724: len = strlcat(jstr, "[", jlen);
725:
726: if (len >= jlen) {
727: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
728: jstr[eos] = 0;
729: return -1;
730: }
731:
732: return len;
733: }
734:
735: /*
736: * json_add_end_array() - Adds end of array ]
737: *
738: * @jstr = JSON string
739: * @jlen = JSON string length
740: * @wspace = whitespace include
741: * return: -1 error or !=-1 actual JSON string length
742: */
743: int
744: json_add_end_array(char * __restrict jstr, int jlen, int wspace)
745: {
746: int len;
747: size_t eos;
748:
749: if (!jstr)
750: return -1;
751: else
752: eos = strlen(jstr);
753:
754: if (wspace)
755: len = strlcat(jstr, " ]", jlen);
756: else
757: len = strlcat(jstr, "]", jlen);
758:
759: if (len >= jlen) {
760: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
761: jstr[eos] = 0;
762: return -1;
763: }
764:
765: return len;
766: }
767:
768: /*
769: * json_add_char() - Adds character
770: *
771: * @jstr = JSON string
772: * @jlen = JSON string length
773: * @ch = Character
774: * return: -1 error or !=-1 actual JSON string length
775: */
776: int
777: json_add_char(char * __restrict jstr, int jlen, u_char ch)
778: {
779: int len;
780:
781: if (!jstr)
782: return -1;
783:
784: len = strlen(jstr) + 1;
785: if (len >= jlen) {
786: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
787: return -1;
788: } else {
789: jstr[len++] = (char) ch;
790: jstr[len] = 0;
791: }
792:
793: return len;
794: }
795:
796: /*
797: * json_add_colon() - Adds key/value pair delimiter colon :
798: *
799: * @jstr = JSON string
800: * @jlen = JSON string length
801: * @wspace = whitespace include
802: * return: -1 error or !=-1 actual JSON string length
803: */
804: int
805: json_add_colon(char * __restrict jstr, int jlen, int wspace)
806: {
807: int len;
808: size_t eos;
809:
810: if (!jstr)
811: return -1;
812: else
813: eos = strlen(jstr);
814:
815: if (wspace)
816: len = strlcat(jstr, ": ", jlen);
817: else
818: len = strlcat(jstr, ":", jlen);
819:
820: if (len >= jlen) {
821: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
822: jstr[eos] = 0;
823: return -1;
824: }
825:
826: return len;
827: }
828:
829: /*
830: * json_add_comma() - Adds value delimiter comma ,
831: *
832: * @jstr = JSON string
833: * @jlen = JSON string length
834: * @wspace = whitespace include
835: * return: -1 error or !=-1 actual JSON string length
836: */
837: int
838: json_add_comma(char * __restrict jstr, int jlen, int wspace)
839: {
840: int len;
841: size_t eos;
842:
843: if (!jstr)
844: return -1;
845: else
846: eos = strlen(jstr);
847:
848: if (wspace)
849: len = strlcat(jstr, ", ", jlen);
850: else
851: len = strlcat(jstr, ",", jlen);
852:
853: if (len >= jlen) {
854: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
855: jstr[eos] = 0;
856: return -1;
857: }
858:
859: return len;
860: }
861:
862: /*
863: * json_add_string() - Adds string
864: *
865: * @jstr = JSON string
866: * @jlen = JSON string length
867: * @unquot = Unquoted string
868: * @str = String, it can't be NULL
869: * return: -1 error or !=-1 actual JSON string length
870: */
871: int
872: json_add_string(char * __restrict jstr, int jlen, int unquot, const char *str)
873: {
874: int len;
875: size_t eos;
876:
877: if (!jstr || !str)
878: return -1;
879: else
880: eos = strlen(jstr);
881:
882: if (!unquot) {
883: len = strlcat(jstr, "\"", jlen);
884: if (len >= jlen) {
885: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
886: jstr[eos] = 0;
887: return -1;
888: }
889: }
890: len = strlcat(jstr, str, jlen);
891: if (len >= jlen) {
892: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
893: jstr[eos] = 0;
894: return -1;
895: }
896: if (!unquot) {
897: len = strlcat(jstr, "\"", jlen);
898: if (len >= jlen) {
899: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
900: jstr[eos] = 0;
901: return -1;
902: }
903: }
904:
905: return len;
906: }
907:
908: /*
909: * json_add_value() - Adds value
910: *
911: * @jstr = JSON string
912: * @jlen = JSON string length
913: * @unquot = Unquoted number
914: * @num = Number
915: * return: -1 error or !=-1 actual JSON string length
916: */
917: int
918: json_add_value(char * __restrict jstr, int jlen, int unquot, long num)
919: {
920: int len;
921: char wrk[STRSIZ] = { [0 ... STRSIZ - 1] = 0 };
922: size_t eos;
923:
924: if (!jstr)
925: return -1;
926: else
927: eos = strlen(jstr);
928:
929: if (!unquot) {
930: len = strlcat(jstr, "\"", jlen);
931: if (len >= jlen) {
932: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
933: jstr[eos] = 0;
934: return -1;
935: }
936: }
937: snprintf(wrk, sizeof wrk, "%ld", num);
938: len = strlcat(jstr, wrk, jlen);
939: if (len >= jlen) {
940: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
941: jstr[eos] = 0;
942: return -1;
943: }
944: if (!unquot) {
945: len = strlcat(jstr, "\"", jlen);
946: if (len >= jlen) {
947: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
948: jstr[eos] = 0;
949: return -1;
950: }
951: }
952:
953: return len;
954: }
955:
956: /*
957: * json_add_pair() - Adds key/value pair
958: *
959: * @jstr = JSON string
960: * @jlen = JSON string length
961: * @wspace = whitespace include
962: * @key = Key string
963: * @val = Value string
964: * return: -1 error or !=-1 actual JSON string length
965: */
966: int
967: json_add_pair(char * __restrict jstr, int jlen, int wspace, const char *key, const char *val)
968: {
969: int len = -1;
970: size_t eos;
971:
972: if (!jstr || !key || !val)
973: return -1;
974: else
975: eos = strlen(jstr);
976:
977: if (json_add_string(jstr, jlen, 0, key) == -1) {
978: jstr[eos] = 0;
979: return -1;
980: }
981: if (json_add_colon(jstr, jlen, wspace) == -1) {
982: jstr[eos] = 0;
983: return -1;
984: }
985: if ((len = json_add_string(jstr, jlen, 0, val)) == -1) {
986: jstr[eos] = 0;
987: return -1;
988: }
989:
990: return len;
991: }
992:
993: /*
994: * json_add_array() - Adds array
995: *
996: * @jstr = JSON string
997: * @jlen = JSON string length
998: * @wspace = whitespace include
999: * @arr = Array with variables
1000: * return: -1 error or !=-1 actual JSON string length
1001: */
1002: int
1003: json_add_array(char * __restrict jstr, int jlen, int wspace, array_t * __restrict arr)
1004: {
1005: int len = -1;
1006: register int i;
1007: ait_val_t *v;
1008: size_t eos;
1009:
1010: if (!jstr || !arr)
1011: return -1;
1012: else
1013: eos = strlen(jstr);
1014:
1015: if (json_add_begin_array(jstr, jlen, wspace) == -1) {
1016: jstr[eos] = 0;
1017: return -1;
1018: }
1019: for (i = 0; i < array_Size(arr); i++) {
1020: v = array(arr, i, ait_val_t*);
1021: if (v) {
1022: if (AIT_TYPE(v) == string) {
1023: if (json_add_string(jstr, jlen, 0, AIT_GET_STR(v)) == -1) {
1024: jstr[eos] = 0;
1025: return -1;
1026: }
1027: } else {
1028: if (json_add_value(jstr, jlen, 0, AIT_GET_LIKE(v, long)) == -1) {
1029: jstr[eos] = 0;
1030: return -1;
1031: }
1032: }
1033: if (i < array_Size(arr) - 1 && json_add_comma(jstr, jlen, wspace) == -1) {
1034: jstr[eos] = 0;
1035: return -1;
1036: }
1037: }
1038: }
1039: if ((len = json_add_end_array(jstr, jlen, wspace)) == -1) {
1040: jstr[eos] = 0;
1041: return -1;
1042: }
1043:
1044: return len;
1045: }
1046:
1047: /*
1048: * json_dump_yaml() - Dump parsed JSON string to YAML format
1049: *
1050: * @f = Output handler
1051: * @jstr = JSON string
1052: * @toks = JSON tokens
1053: * @toksnum = Number of tokens
1054: * @indent = Start indent spaces
1055: * return: 0 done and 1 added one more item
1056: */
1057: int
1058: json_dump_yaml(FILE *f, const char *jstr, jtok_t *toks, int toksnum, int indent)
1059: {
1060: register int i, j, k;
1061:
1062: if (!toksnum)
1063: return 0;
1064:
1065: if (toks->tok_type == J_VALUE) {
1066: fprintf(f, "%.*s", (int) json_toklen(toks), json_tokstr(jstr, toks));
1067: return 1;
1068: } else if (toks->tok_type == J_STRING) {
1069: fprintf(f, "%.*s", (int) json_toklen(toks), json_tokstr(jstr, toks));
1070: return 1;
1071: } else if (toks->tok_type == J_OBJECT) {
1072: fprintf(f, "\n");
1073: for (j = i = 0; i < json_toksize(toks); i++) {
1074: for (k = 0; k < indent; k++)
1075: fprintf(f, " ");
1076: j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1077: fprintf(f, ": ");
1078: j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1079: fprintf(f, "\n");
1080: }
1081: return j + 1;
1082: } else if (toks->tok_type == J_ARRAY) {
1083: fprintf(f, "\n");
1084: for (j = i = 0; i < json_toksize(toks); i++) {
1085: for (k = 0; k < indent - 1; k++)
1086: fprintf(f, " ");
1087: fprintf(f, " - ");
1088: j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1089: fprintf(f, "\n");
1090: }
1091: return j + 1;
1092: }
1093:
1094: return 0;
1095: }
1096:
1097: /*
1098: * json_dump() - Dump parsed JSON string to structure format
1099: *
1100: * @f = Output handler
1101: * @jstr = JSON string
1102: * @toks = JSON tokens
1103: * @toksnum = Number of tokens
1104: * @indent = Start indent spaces
1105: * return: 0 done and 1 added one more item
1106: */
1107: int
1108: json_dump(FILE *f, const char *jstr, jtok_t *toks, int toksnum, int indent)
1109: {
1110: register int i, j, k;
1111:
1112: if (!toksnum)
1113: return 0;
1114:
1115: if (toks->tok_type == J_VALUE) {
1116: fprintf(f, "[idx=%ld type=VALUE start=%ld end=%ld size=%ld parent=%ld] = %.*s",
1117: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent,
1118: (int) json_toklen(toks), json_tokstr(jstr, toks));
1119: return 1;
1120: } else if (toks->tok_type == J_STRING) {
1121: fprintf(f, "[idx=%ld type=STRING start=%ld end=%ld size=%ld parent=%ld] = %.*s",
1122: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent,
1123: (int) json_toklen(toks), json_tokstr(jstr, toks));
1124: return 1;
1125: } else if (toks->tok_type == J_OBJECT) {
1126: fprintf(f, "\n");
1127: fprintf(f, "object:: [idx=%ld type=OBJECT start=%ld end=%ld size=%ld parent=%ld]\n",
1128: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent);
1129: for (j = i = 0; i < json_toksize(toks); i++) {
1130: for (k = 0; k < indent; k++)
1131: fprintf(f, " ");
1132: j += json_dump(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1133: fprintf(f, ": ");
1134: j += json_dump(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1135: fprintf(f, "\n");
1136: }
1137: return j + 1;
1138: } else if (toks->tok_type == J_ARRAY) {
1139: fprintf(f, "\n");
1140: fprintf(f, "array[] [idx=%ld type=ARRAY start=%ld end=%ld size=%ld parent=%ld]",
1141: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent);
1142: for (j = i = 0; i < json_toksize(toks); i++) {
1143: for (k = 0; k < indent - 1; k++)
1144: fprintf(f, " ");
1145: j += json_dump(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1146: fprintf(f, "\n");
1147: }
1148: return j + 1;
1149: }
1150:
1151: return 0;
1152: }
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