![[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|
Return to json.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / libelwix / src |
1.2 misho 1: /*************************************************************************
2: * (C) 2017 AITNET ltd - Sofia/Bulgaria - <misho@aitnet.org>
3: * by Michael Pounov <misho@elwix.org>
4: *
5: * $Author: misho $
1.12.2.2! misho 6: * $Id: json.c,v 1.12.2.1 2025/08/25 10:05:52 misho Exp $
1.2 misho 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:
1.12 misho 15: Copyright 2004 - 2025
1.2 misho 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: }
1.8 misho 227: if (jstr[json->h_pos] < 32 || (u_char) jstr[json->h_pos] > 127) {
1.2 misho 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));
1.10 misho 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);
1.2 misho 434:
435: return v;
436: }
437:
438: /*
439: * json_token2str() - Return token to string
440: *
441: * @jstr = JSON string
442: * @tok = Token for convert
1.5 misho 443: * @return =NULL error or !=NULL allocated str, after use should be json_freestr()|e_free()
1.2 misho 444: */
445: char *
446: json_token2str(const char *jstr, jtok_t * __restrict tok)
447: {
1.8 misho 448: char *s, *s2, *wrk, *str = NULL;
1.2 misho 449: size_t len;
450:
451: if (!jstr || !tok)
452: return NULL;
453:
1.8 misho 454:
1.2 misho 455: len = json_toklen(tok);
456: str = e_malloc(len + 1);
457: if (!str)
458: return NULL;
459: else {
1.8 misho 460: memset(str, 0, len + 1);
461:
462: wrk = e_strdup(json_tokstr(jstr, tok));
463: wrk[len] = 0;
464: for (s = wrk, s2 = str; *s; s++)
465: *s2++ = (*s != '\\') ? *s : *++s;
466: e_free(wrk);
1.2 misho 467: }
468:
469: return str;
470: }
471:
472: /*
473: * json_token2num() - Return token to numeric
474: *
475: * @jstr = JSON string
476: * @tok = Token for convert
477: * @return number
478: */
479: long
480: json_token2num(const char *jstr, jtok_t * __restrict tok)
481: {
482: long ret = 0;
483: char *str;
484:
485: str = json_token2str(jstr, tok);
486: if (!str)
487: return 0;
488:
489: ret = strtol(str, NULL, 0);
490: e_free(str);
491: return ret;
492: }
493:
494: /*
1.5 misho 495: * json_token2dbl() - Return token to double
496: *
497: * @jstr = JSON string
498: * @tok = Token for convert
499: * @return number
500: */
501: double
502: json_token2dbl(const char *jstr, jtok_t * __restrict tok)
503: {
504: double ret = 0;
505: char *str;
506:
507: str = json_token2str(jstr, tok);
508: if (!str)
509: return 0;
510:
511: ret = strtod(str, NULL);
1.6 misho 512: e_free(str);
513: return ret;
514: }
515:
516: /*
517: * json_token2bool() - Return token to bool int
518: *
519: * @jstr = JSON string
520: * @tok = Token for convert
521: * @return 0 for FALSE and !=0 for TRUE
522: */
523: int
524: json_token2bool(const char *jstr, jtok_t * __restrict tok)
525: {
526: double ret = 0;
527: char *str;
528:
529: str = json_token2str(jstr, tok);
530: if (!str)
531: return 0;
532:
533: switch (*str) {
534: case 't':
535: case 'T':
536: ret = 1;
537: break;
538: case 'f':
539: case 'F':
540: ret = 0;
541: break;
542: default:
543: ret = (int) strtol(str, NULL, 10);
544: break;
545: }
1.5 misho 546: e_free(str);
547: return ret;
548: }
549:
550: /*
551: * json_findbykey() - Find token data by key
1.2 misho 552: *
553: * @jstr = JSON string
554: * @key = Search key
1.4 misho 555: * @type = Search key for particular token type, if is J_UNDEF this mean any type
1.2 misho 556: * @toks = Parsed tokens
557: * @toksnum = Number of parsed tokens
558: * return: =NULL error or !=NULL data token found
559: */
560: jtok_t *
1.4 misho 561: json_findbykey(const char *jstr, const char *key, jtype_t type, jtok_t * __restrict toks, int toksnum)
1.2 misho 562: {
563: jtok_t *tok = NULL;
564: register int i;
565: int klen;
566:
567: if (!jstr || !key || !toks)
568: return NULL;
569: else
570: klen = strlen(key);
571:
572: for (i = 1; i < toksnum; i++) {
1.9 misho 573: if (toks[i].tok_type == J_STRING && toks[i].tok_size == 1 &&
1.2 misho 574: klen == toks[i].tok_end - toks[i].tok_start &&
575: !strncmp(jstr + toks[i].tok_start, key, klen)) {
1.4 misho 576: if (type != J_UNDEF) {
577: if (toks[i + 1].tok_type == type) {
578: tok = toks + i + 1;
579: break;
580: }
581: } else {
582: tok = toks + i + 1;
583: break;
584: }
1.2 misho 585: }
586: }
587:
588: return tok;
589: }
590:
591: /*
1.11 misho 592: * json_findbykeyatscope() - Find token data by key at particular scope
593: *
594: * @scope = Search at object scope, =0 main object scope
595: * @jstr = JSON string
596: * @key = Search key
597: * @type = Search key for particular token type, if is J_UNDEF this mean any type
598: * @toks = Parsed tokens
599: * @toksnum = Number of parsed tokens
1.12 misho 600: * return: =NULL error or !=NULL data token found
1.11 misho 601: */
602: jtok_t *
603: json_findbykeyatscope(long scope, const char *jstr, const char *key, jtype_t type, jtok_t * __restrict toks, int toksnum)
604: {
605: jtok_t *tok = NULL;
606: register int i;
607: int klen;
608:
609: if (!jstr || !key || !toks)
610: return NULL;
611: else
612: klen = strlen(key);
613:
614: for (i = 1; i < toksnum; i++) {
615: if (toks[i].tok_type == J_STRING && toks[i].tok_size == 1 &&
616: toks[i].tok_parent == scope &&
617: klen == toks[i].tok_end - toks[i].tok_start &&
618: !strncmp(jstr + toks[i].tok_start, key, klen)) {
619: if (type != J_UNDEF) {
620: if (toks[i + 1].tok_type == type) {
621: tok = toks + i + 1;
622: break;
623: }
624: } else {
625: tok = toks + i + 1;
626: break;
627: }
628: }
629: }
630:
631: return tok;
632: }
633:
634: /*
1.5 misho 635: * json_findbypos() - Find token by position on JSON string
636: *
637: * @pos = Offset from begin of JSON string
638: * @toks = Parsed tokens
639: * @toksnum = Number of parsed tokens
640: * return: =NULL error or !=NULL token found
641: */
642: jtok_t *
643: json_findbypos(u_long pos, jtok_t * __restrict toks, int toksnum)
644: {
645: jtok_t *tok = NULL;
646: register int i;
647:
1.10 misho 648: if (!toks)
1.5 misho 649: return NULL;
650:
651: for (i = 1; i < toksnum; i++)
652: if (pos <= toks[i].tok_end && pos >= toks[i].tok_start) {
653: tok = toks + i;
654: break;
655: }
656:
657: return tok;
658: }
659:
660: /*
1.12.2.1 misho 661: * json_token2vars() - Convert token to string variable array
1.2 misho 662: *
663: * @jstr = JSON string
664: * @tok = Token for convert
665: * return: =NULL error or !=NULL allocated array with string variables,
666: * after use should be ait_freeVars()
667: */
668: array_t *
1.12.2.1 misho 669: json_token2vars(const char *jstr, jtok_t * __restrict tok)
1.2 misho 670: {
671: array_t *arr = NULL;
1.5 misho 672: register int i, j;
1.2 misho 673: int siz;
674: ait_val_t *v;
675: jtok_t *t;
676:
677: if (!jstr || !tok)
678: return NULL;
679:
680: siz = tok->tok_size;
681: if (!siz && json_toktype(tok) != J_ARRAY && json_toktype(tok) != J_OBJECT)
682: siz++;
683:
684: arr = ait_allocVars(siz);
685: if (!arr)
686: return NULL;
687:
688: if (tok->tok_type == J_STRING || tok->tok_type == J_VALUE) {
689: v = ait_getVars(&arr, 0);
690: AIT_SET_STRSIZ(v, json_toklen(tok) + 1);
1.10 misho 691: if (AIT_GET_STR(v)) {
692: json_tokstrcpy(AIT_GET_STR(v), jstr, tok);
693: } else {
694: ait_freeVar(&v);
695: }
1.2 misho 696: } else if (tok->tok_type == J_ARRAY) {
1.5 misho 697: for (i = 0, j = 1; i < tok->tok_size; i++) {
698: t = &tok[i + j];
1.2 misho 699: v = ait_getVars(&arr, i);
700: AIT_SET_STRSIZ(v, json_toklen(t) + 1);
1.10 misho 701: if (AIT_GET_STR(v)) {
702: json_tokstrcpy(AIT_GET_STR(v), jstr, t);
703: } else {
704: ait_freeVar(&v);
705: }
1.5 misho 706:
707: /* if there we have array from objects should parse all object tokens */
708: while (i < tok->tok_size - 1 && tok->tok_idx != tok[i + j + 1].tok_parent)
709: j++;
1.2 misho 710: }
711: } else if (tok->tok_type == J_OBJECT) {
712: for (i = 0; tok->tok_idx <= tok[i + 1].tok_parent; i++) {
713: t = &tok[i + 1];
714: v = ait_getVars(&arr, i);
715: AIT_SET_STRSIZ(v, json_toklen(t) + 1);
1.10 misho 716: if (AIT_GET_STR(v)) {
717: json_tokstrcpy(AIT_GET_STR(v), jstr, t);
718: } else {
719: ait_freeVar(&v);
720: }
1.2 misho 721: }
722: } else {
723: elwix_SetErr(J_ERR_PARAM, "%s", jerrstr[J_ERR_PARAM]);
724: ait_freeVars(&arr);
725: return NULL;
726: }
727:
728: return arr;
729: }
730:
1.12.2.1 misho 731: /*
732: * json_token2array() - Convert token to string array
733: *
734: * @jstr = JSON string
735: * @tok = Token for convert
736: * return: =NULL error or !=NULL allocated array with strings,
737: * after use should be ait_freearray()
738: */
739: array_t *
740: json_token2array(const char *jstr, jtok_t * __restrict tok)
741: {
742: array_t *arr = NULL;
743: register int i, j;
744: int siz;
745: char *str;
746: jtok_t *t;
747:
748: if (!jstr || !tok)
749: return NULL;
750:
751: siz = tok->tok_size;
752: if (!siz && json_toktype(tok) != J_ARRAY && json_toktype(tok) != J_OBJECT)
753: siz++;
754:
755: arr = array_Init(siz);
756: if (!arr)
757: return NULL;
758:
759: if (tok->tok_type == J_STRING || tok->tok_type == J_VALUE) {
760: str = e_malloc(json_toklen(tok) + 1);
761: if (!str) {
762: array_Destroy(&arr);
763: return NULL;
764: } else
765: json_tokstrcpy(str, jstr, tok);
766: if (array_Push(arr, str, 0) == -1) {
767: e_free(str);
768: array_Destroy(&arr);
769: return NULL;
770: }
771: } else if (tok->tok_type == J_ARRAY) {
772: for (i = 0, j = 1; i < tok->tok_size; i++) {
773: t = &tok[i + j];
774: str = e_malloc(json_toklen(t) + 1);
775: if (!str) {
776: json_freearray(&arr);
777: return NULL;
778: } else
779: json_tokstrcpy(str, jstr, t);
780: if (array_Push(arr, str, 0) == -1) {
781: e_free(str);
782: json_freearray(&arr);
783: return NULL;
784: }
785:
786: /* if there we have array from objects should parse all object tokens */
787: while (i < tok->tok_size - 1 && tok->tok_idx != tok[i + j + 1].tok_parent)
788: j++;
789: }
790: } else if (tok->tok_type == J_OBJECT) {
791: for (i = 0; tok->tok_idx <= tok[i + 1].tok_parent; i++) {
792: t = &tok[i + 1];
793: str = e_malloc(json_toklen(t) + 1);
794: if (!str) {
795: json_freearray(&arr);
796: return NULL;
797: } else
798: json_tokstrcpy(str, jstr, t);
799: if (array_Push(arr, str, 0) == -1) {
800: e_free(str);
801: json_freearray(&arr);
802: return NULL;
803: }
804: }
805: } else {
806: elwix_SetErr(J_ERR_PARAM, "%s", jerrstr[J_ERR_PARAM]);
807: array_Destroy(&arr);
808: return NULL;
809: }
810:
811: return arr;
812: }
1.2 misho 813:
814:
815: /*
816: * json_add_begin_object() - Adds begin of object {
817: *
818: * @jstr = JSON string
819: * @jlen = JSON string length
820: * @wspace = whitespace include
821: * return: -1 error or !=-1 actual JSON string length
822: */
823: int
824: json_add_begin_object(char * __restrict jstr, int jlen, int wspace)
825: {
826: int len;
827: size_t eos;
828:
829: if (!jstr)
830: return -1;
831: else
832: eos = strlen(jstr);
833:
834:
835: if (wspace)
836: len = strlcat(jstr, "{ ", jlen);
837: else
838: len = strlcat(jstr, "{", jlen);
839:
840: if (len >= jlen) {
841: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
842: jstr[eos] = 0;
843: return -1;
844: }
845:
846: return len;
847: }
848:
849: /*
850: * json_add_end_object() - Adds end of object }
851: *
852: * @jstr = JSON string
853: * @jlen = JSON string length
854: * @wspace = whitespace include
855: * return: -1 error or !=-1 actual JSON string length
856: */
857: int
858: json_add_end_object(char * __restrict jstr, int jlen, int wspace)
859: {
860: int len;
861: size_t eos;
862:
863: if (!jstr)
864: return -1;
865: else
866: eos = strlen(jstr);
867:
868: if (wspace)
869: len = strlcat(jstr, " }", jlen);
870: else
871: len = strlcat(jstr, "}", jlen);
872:
873: if (len >= jlen) {
874: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
875: jstr[eos] = 0;
876: return -1;
877: }
878:
879: return len;
880: }
881:
882: /*
883: * json_add_begin_array() - Adds begin of array [
884: *
885: * @jstr = JSON string
886: * @jlen = JSON string length
887: * @wspace = whitespace include
888: * return: -1 error or !=-1 actual JSON string length
889: */
890: int
891: json_add_begin_array(char * __restrict jstr, int jlen, int wspace)
892: {
893: int len;
894: size_t eos;
895:
896: if (!jstr)
897: return -1;
898: else
899: eos = strlen(jstr);
900:
901: if (wspace)
902: len = strlcat(jstr, "[ ", jlen);
903: else
904: len = strlcat(jstr, "[", jlen);
905:
906: if (len >= jlen) {
907: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
908: jstr[eos] = 0;
909: return -1;
910: }
911:
912: return len;
913: }
914:
915: /*
916: * json_add_end_array() - Adds end of array ]
917: *
918: * @jstr = JSON string
919: * @jlen = JSON string length
920: * @wspace = whitespace include
921: * return: -1 error or !=-1 actual JSON string length
922: */
923: int
924: json_add_end_array(char * __restrict jstr, int jlen, int wspace)
925: {
926: int len;
927: size_t eos;
928:
929: if (!jstr)
930: return -1;
931: else
932: eos = strlen(jstr);
933:
934: if (wspace)
935: len = strlcat(jstr, " ]", jlen);
936: else
937: len = strlcat(jstr, "]", jlen);
938:
939: if (len >= jlen) {
940: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
941: jstr[eos] = 0;
942: return -1;
943: }
944:
945: return len;
946: }
947:
948: /*
949: * json_add_char() - Adds character
950: *
951: * @jstr = JSON string
952: * @jlen = JSON string length
953: * @ch = Character
954: * return: -1 error or !=-1 actual JSON string length
955: */
956: int
957: json_add_char(char * __restrict jstr, int jlen, u_char ch)
958: {
959: int len;
960:
961: if (!jstr)
962: return -1;
963:
964: len = strlen(jstr) + 1;
965: if (len >= jlen) {
966: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
967: return -1;
968: } else {
969: jstr[len++] = (char) ch;
970: jstr[len] = 0;
971: }
972:
973: return len;
974: }
975:
976: /*
977: * json_add_colon() - Adds key/value pair delimiter colon :
978: *
979: * @jstr = JSON string
980: * @jlen = JSON string length
981: * @wspace = whitespace include
982: * return: -1 error or !=-1 actual JSON string length
983: */
984: int
985: json_add_colon(char * __restrict jstr, int jlen, int wspace)
986: {
987: int len;
988: size_t eos;
989:
990: if (!jstr)
991: return -1;
992: else
993: eos = strlen(jstr);
994:
995: if (wspace)
996: len = strlcat(jstr, ": ", jlen);
997: else
998: len = strlcat(jstr, ":", jlen);
999:
1000: if (len >= jlen) {
1001: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1002: jstr[eos] = 0;
1003: return -1;
1004: }
1005:
1006: return len;
1007: }
1008:
1009: /*
1010: * json_add_comma() - Adds value delimiter comma ,
1011: *
1012: * @jstr = JSON string
1013: * @jlen = JSON string length
1014: * @wspace = whitespace include
1015: * return: -1 error or !=-1 actual JSON string length
1016: */
1017: int
1018: json_add_comma(char * __restrict jstr, int jlen, int wspace)
1019: {
1020: int len;
1021: size_t eos;
1022:
1023: if (!jstr)
1024: return -1;
1025: else
1026: eos = strlen(jstr);
1027:
1028: if (wspace)
1029: len = strlcat(jstr, ", ", jlen);
1030: else
1031: len = strlcat(jstr, ",", jlen);
1032:
1033: if (len >= jlen) {
1034: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1035: jstr[eos] = 0;
1036: return -1;
1037: }
1038:
1039: return len;
1040: }
1041:
1042: /*
1043: * json_add_string() - Adds string
1044: *
1045: * @jstr = JSON string
1046: * @jlen = JSON string length
1047: * @unquot = Unquoted string
1048: * @str = String, it can't be NULL
1049: * return: -1 error or !=-1 actual JSON string length
1050: */
1051: int
1052: json_add_string(char * __restrict jstr, int jlen, int unquot, const char *str)
1053: {
1054: int len;
1055: size_t eos;
1056:
1057: if (!jstr || !str)
1058: return -1;
1059: else
1060: eos = strlen(jstr);
1061:
1062: if (!unquot) {
1063: len = strlcat(jstr, "\"", jlen);
1064: if (len >= jlen) {
1065: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1066: jstr[eos] = 0;
1067: return -1;
1068: }
1069: }
1070: len = strlcat(jstr, str, jlen);
1071: if (len >= jlen) {
1072: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1073: jstr[eos] = 0;
1074: return -1;
1075: }
1076: if (!unquot) {
1077: len = strlcat(jstr, "\"", jlen);
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:
1085: return len;
1086: }
1087:
1088: /*
1089: * json_add_value() - Adds value
1090: *
1091: * @jstr = JSON string
1092: * @jlen = JSON string length
1093: * @unquot = Unquoted number
1094: * @num = Number
1095: * return: -1 error or !=-1 actual JSON string length
1096: */
1097: int
1098: json_add_value(char * __restrict jstr, int jlen, int unquot, long num)
1099: {
1100: int len;
1101: char wrk[STRSIZ] = { [0 ... STRSIZ - 1] = 0 };
1102: size_t eos;
1103:
1104: if (!jstr)
1105: return -1;
1106: else
1107: eos = strlen(jstr);
1108:
1109: if (!unquot) {
1110: len = strlcat(jstr, "\"", jlen);
1111: if (len >= jlen) {
1112: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1113: jstr[eos] = 0;
1114: return -1;
1115: }
1116: }
1117: snprintf(wrk, sizeof wrk, "%ld", num);
1118: len = strlcat(jstr, wrk, jlen);
1119: if (len >= jlen) {
1120: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1121: jstr[eos] = 0;
1122: return -1;
1123: }
1124: if (!unquot) {
1125: len = strlcat(jstr, "\"", jlen);
1126: if (len >= jlen) {
1127: elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
1128: jstr[eos] = 0;
1129: return -1;
1130: }
1131: }
1132:
1133: return len;
1134: }
1135:
1136: /*
1137: * json_add_pair() - Adds key/value pair
1138: *
1139: * @jstr = JSON string
1140: * @jlen = JSON string length
1141: * @wspace = whitespace include
1142: * @key = Key string
1143: * @val = Value string
1144: * return: -1 error or !=-1 actual JSON string length
1145: */
1146: int
1147: json_add_pair(char * __restrict jstr, int jlen, int wspace, const char *key, const char *val)
1148: {
1149: int len = -1;
1150: size_t eos;
1151:
1152: if (!jstr || !key || !val)
1153: return -1;
1154: else
1155: eos = strlen(jstr);
1156:
1157: if (json_add_string(jstr, jlen, 0, key) == -1) {
1158: jstr[eos] = 0;
1159: return -1;
1160: }
1161: if (json_add_colon(jstr, jlen, wspace) == -1) {
1162: jstr[eos] = 0;
1163: return -1;
1164: }
1165: if ((len = json_add_string(jstr, jlen, 0, val)) == -1) {
1.7 misho 1166: jstr[eos] = 0;
1167: return -1;
1168: }
1169:
1170: return len;
1171: }
1172:
1173: /*
1174: * json_add_pair2() - Adds key/value pair with formated args
1175: *
1176: * @jstr = JSON string
1177: * @jlen = JSON string length
1178: * @wspace = whitespace include
1179: * @key = Key string
1180: * @fmt = Format string for values
1181: * return: -1 error or !=-1 actual JSON string length
1182: */
1183: int
1184: json_add_pair2(char * __restrict jstr, int jlen, int wspace, const char *key, const char *fmt, ...)
1185: {
1186: int len = -1;
1187: size_t eos;
1188: va_list lst;
1189: char szStr[BUFSIZ] = { [0 ... BUFSIZ - 1] = 0 };
1190:
1191: if (!jstr || !key || !fmt)
1192: return -1;
1193: else
1194: eos = strlen(jstr);
1195:
1196: if (json_add_string(jstr, jlen, 0, key) == -1) {
1197: jstr[eos] = 0;
1198: return -1;
1199: }
1200: if (json_add_colon(jstr, jlen, wspace) == -1) {
1201: jstr[eos] = 0;
1202: return -1;
1203: }
1204: va_start(lst, fmt);
1205: vsnprintf(szStr, sizeof szStr, fmt, lst);
1206: va_end(lst);
1207: if ((len = json_add_string(jstr, jlen, 0, szStr)) == -1) {
1.2 misho 1208: jstr[eos] = 0;
1209: return -1;
1210: }
1211:
1212: return len;
1213: }
1214:
1215: /*
1216: * json_add_array() - Adds array
1217: *
1218: * @jstr = JSON string
1219: * @jlen = JSON string length
1220: * @wspace = whitespace include
1221: * @arr = Array with variables
1222: * return: -1 error or !=-1 actual JSON string length
1223: */
1224: int
1225: json_add_array(char * __restrict jstr, int jlen, int wspace, array_t * __restrict arr)
1226: {
1227: int len = -1;
1228: register int i;
1229: ait_val_t *v;
1230: size_t eos;
1231:
1232: if (!jstr || !arr)
1233: return -1;
1234: else
1235: eos = strlen(jstr);
1236:
1237: if (json_add_begin_array(jstr, jlen, wspace) == -1) {
1238: jstr[eos] = 0;
1239: return -1;
1240: }
1241: for (i = 0; i < array_Size(arr); i++) {
1242: v = array(arr, i, ait_val_t*);
1243: if (v) {
1244: if (AIT_TYPE(v) == string) {
1245: if (json_add_string(jstr, jlen, 0, AIT_GET_STR(v)) == -1) {
1246: jstr[eos] = 0;
1247: return -1;
1248: }
1249: } else {
1250: if (json_add_value(jstr, jlen, 0, AIT_GET_LIKE(v, long)) == -1) {
1251: jstr[eos] = 0;
1252: return -1;
1253: }
1254: }
1255: if (i < array_Size(arr) - 1 && json_add_comma(jstr, jlen, wspace) == -1) {
1256: jstr[eos] = 0;
1257: return -1;
1258: }
1259: }
1260: }
1261: if ((len = json_add_end_array(jstr, jlen, wspace)) == -1) {
1262: jstr[eos] = 0;
1263: return -1;
1264: }
1265:
1266: return len;
1.3 misho 1267: }
1268:
1269: /*
1270: * json_dump_yaml() - Dump parsed JSON string to YAML format
1271: *
1272: * @f = Output handler
1273: * @jstr = JSON string
1274: * @toks = JSON tokens
1275: * @toksnum = Number of tokens
1276: * @indent = Start indent spaces
1277: * return: 0 done and 1 added one more item
1278: */
1279: int
1280: json_dump_yaml(FILE *f, const char *jstr, jtok_t *toks, int toksnum, int indent)
1281: {
1282: register int i, j, k;
1283:
1.10 misho 1284: if (!toksnum || !toks)
1.3 misho 1285: return 0;
1286:
1287: if (toks->tok_type == J_VALUE) {
1288: fprintf(f, "%.*s", (int) json_toklen(toks), json_tokstr(jstr, toks));
1289: return 1;
1290: } else if (toks->tok_type == J_STRING) {
1291: fprintf(f, "%.*s", (int) json_toklen(toks), json_tokstr(jstr, toks));
1292: return 1;
1293: } else if (toks->tok_type == J_OBJECT) {
1294: fprintf(f, "\n");
1295: for (j = i = 0; i < json_toksize(toks); i++) {
1296: for (k = 0; k < indent; k++)
1297: fprintf(f, " ");
1298: j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1299: fprintf(f, ": ");
1300: j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1301: fprintf(f, "\n");
1302: }
1303: return j + 1;
1304: } else if (toks->tok_type == J_ARRAY) {
1305: fprintf(f, "\n");
1306: for (j = i = 0; i < json_toksize(toks); i++) {
1307: for (k = 0; k < indent - 1; k++)
1308: fprintf(f, " ");
1309: fprintf(f, " - ");
1310: j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1.5 misho 1311: fprintf(f, "\n");
1312: }
1313: return j + 1;
1314: }
1315:
1316: return 0;
1317: }
1318:
1319: /*
1320: * json_dump() - Dump parsed JSON string to structure format
1321: *
1322: * @f = Output handler
1323: * @jstr = JSON string
1324: * @toks = JSON tokens
1325: * @toksnum = Number of tokens
1326: * @indent = Start indent spaces
1327: * return: 0 done and 1 added one more item
1328: */
1329: int
1330: json_dump(FILE *f, const char *jstr, jtok_t *toks, int toksnum, int indent)
1331: {
1332: register int i, j, k;
1333:
1334: if (!toksnum)
1335: return 0;
1336:
1337: if (toks->tok_type == J_VALUE) {
1338: fprintf(f, "[idx=%ld type=VALUE start=%ld end=%ld size=%ld parent=%ld] = %.*s",
1339: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent,
1340: (int) json_toklen(toks), json_tokstr(jstr, toks));
1341: return 1;
1342: } else if (toks->tok_type == J_STRING) {
1343: fprintf(f, "[idx=%ld type=STRING start=%ld end=%ld size=%ld parent=%ld] = %.*s",
1344: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent,
1345: (int) json_toklen(toks), json_tokstr(jstr, toks));
1346: return 1;
1347: } else if (toks->tok_type == J_OBJECT) {
1348: fprintf(f, "\n");
1349: fprintf(f, "object:: [idx=%ld type=OBJECT start=%ld end=%ld size=%ld parent=%ld]\n",
1350: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent);
1351: for (j = i = 0; i < json_toksize(toks); i++) {
1352: for (k = 0; k < indent; k++)
1353: fprintf(f, " ");
1354: j += json_dump(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1355: fprintf(f, ": ");
1356: j += json_dump(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1357: fprintf(f, "\n");
1358: }
1359: return j + 1;
1360: } else if (toks->tok_type == J_ARRAY) {
1361: fprintf(f, "\n");
1362: fprintf(f, "array[] [idx=%ld type=ARRAY start=%ld end=%ld size=%ld parent=%ld]",
1363: toks->tok_idx, toks->tok_start, toks->tok_end, toks->tok_size, toks->tok_parent);
1364: for (j = i = 0; i < json_toksize(toks); i++) {
1365: for (k = 0; k < indent - 1; k++)
1366: fprintf(f, " ");
1367: j += json_dump(f, jstr, toks + j + 1, toksnum - j, indent + 1);
1.3 misho 1368: fprintf(f, "\n");
1369: }
1370: return j + 1;
1371: }
1372:
1373: return 0;
1.2 misho 1374: }
1.11 misho 1375:
1376: /*
1377: * json_objscope() - Find object scope of key
1378: *
1379: * @key = Key of object, if it is =NULL, then return 0 (default scope)
1380: * @jstr = JSON string
1381: * @toks = JSON tokens
1382: * @toksnum = Number of tokens
1383: * return: -1 on error or >=0 scope of object
1384: */
1385: long
1386: json_objscope(const char *key, const char *jstr, jtok_t * __restrict toks, int toksnum)
1387: {
1388: long scope = 0;
1389: register int i;
1390: int klen;
1391:
1392: if (!key)
1393: return 0; /* default scope */
1394:
1395: if (!jstr || !toks)
1396: return -1;
1397: else
1398: klen = strlen(key);
1399:
1400: for (i = 1; i < toksnum; i++)
1401: if (toks[i].tok_type == J_STRING && toks[i].tok_size == 1 &&
1402: klen == toks[i].tok_end - toks[i].tok_start &&
1403: !strncmp(jstr + toks[i].tok_start, key, klen))
1404: if (toks[i + 1].tok_type == J_OBJECT) {
1405: scope = toks[i + 1].tok_idx;
1406: break;
1407: }
1408:
1409: return scope;
1410: }
1.12 misho 1411:
1412: /*
1413: * json_validate() - Validate JSON
1414: *
1415: * @jstr = JSON string
1.12.2.1 misho 1416: * @started = if started != NULL then here will return start position of found JSON
1.12 misho 1417: * return: -1 error or >=0 where valid JSON ends
1418: */
1419: int
1.12.2.1 misho 1420: json_validate(const char *jstr, int *started)
1.12 misho 1421: {
1.12.2.1 misho 1422: register int o = 0, a = 0, q = 0, pos = 0;
1423:
1.12.2.2! misho 1424: if (!jstr)
! 1425: return -1;
! 1426:
1.12.2.1 misho 1427: if (started)
1428: *started = 0;
1.12 misho 1429:
1.12.2.1 misho 1430: while (jstr[pos] && jstr[pos] != '{' && jstr[pos] != '[') {
1.12 misho 1431: pos++;
1.12.2.1 misho 1432: if (started)
1433: (*started)++;
1434: }
1.12 misho 1435:
1436: do {
1437: switch (jstr[pos++]) {
1438: case '{':
1439: o++;
1440: break;
1441: case '}':
1442: o--;
1443: break;
1444: case '[':
1445: a++;
1446: break;
1447: case ']':
1448: a--;
1449: break;
1.12.2.1 misho 1450: case '"':
1451: q = ~q;
1452: break;
1453: case '\\':
1454: pos++;
1455: break;
1.12 misho 1456: case 0: /* string ends without valid JSON */
1.12.2.1 misho 1457: if (started)
1458: *started = 0;
1.12 misho 1459: return 0;
1460: }
1.12.2.1 misho 1461: } while (q || a || o);
1.12 misho 1462:
1463: return pos;
1464: }
1.12.2.2! misho 1465:
! 1466: /*
! 1467: * json_marshaling() - Prepare JSON to one continues line
! 1468: *
! 1469: * @jstr = JSON string
! 1470: * @space = if it is 0 then spaces will be removed
! 1471: * return NULL error or !=NULL ready JSON for proceeding
! 1472: */
! 1473: char *
! 1474: json_marshaling(char * __restrict jstr, int space)
! 1475: {
! 1476: int started, ended, len;
! 1477: char *str, *pos, *js;
! 1478: register int q = 0;
! 1479:
! 1480: if (!jstr)
! 1481: return NULL;
! 1482: else
! 1483: js = jstr;
! 1484:
! 1485: ended = json_validate(jstr, &started);
! 1486: if (!ended)
! 1487: return NULL;
! 1488: len = ended - started + 1;
! 1489: str = e_malloc(len);
! 1490: if (!str)
! 1491: return NULL;
! 1492: else {
! 1493: memset(str, 0, len);
! 1494: pos = str;
! 1495: }
! 1496:
! 1497: js += started;
! 1498: while (*js && js < jstr + ended && --len) {
! 1499: if (*js < 0x20) {
! 1500: js++;
! 1501: continue;
! 1502: }
! 1503: if (space && !q && *js == 0x20) {
! 1504: js++;
! 1505: continue;
! 1506: }
! 1507: if (*js == '"')
! 1508: q = ~q;
! 1509: *pos++ = *js++;
! 1510: }
! 1511: *pos = 0;
! 1512:
! 1513: len = strlen(jstr) + 1;
! 1514: strlcpy(jstr, str, len);
! 1515: e_free(str);
! 1516: return jstr;
! 1517: }