File:  [ELWIX - Embedded LightWeight unIX -] / libelwix / src / json.c
Revision 1.4.6.1: download - view: text, annotated - select for diffs - revision graph
Mon Apr 16 14:02:35 2018 UTC (6 years, 2 months ago) by misho
Branches: elwix4_11
Diff to: branchpoint 1.4: preferred, unified
adds new function json_token2dbl() and helper macro json_freestr()

    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.1 2018/04/16 14:02:35 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: 	long 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 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_token2array() - Convert token to string array
  550:  *
  551:  * @jstr = JSON string
  552:  * @tok = Token for convert
  553:  * return: =NULL error or !=NULL allocated array with string variables, 
  554:  * 		after use should be ait_freeVars()
  555:  */
  556: array_t *
  557: json_token2array(const char *jstr, jtok_t * __restrict tok)
  558: {
  559: 	array_t *arr = NULL;
  560: 	register int i;
  561: 	int siz;
  562: 	ait_val_t *v;
  563: 	jtok_t *t;
  564: 
  565: 	if (!jstr || !tok)
  566: 		return NULL;
  567: 
  568: 	siz = tok->tok_size;
  569: 	if (!siz && json_toktype(tok) != J_ARRAY && json_toktype(tok) != J_OBJECT)
  570: 		siz++;
  571: 
  572: 	arr = ait_allocVars(siz);
  573: 	if (!arr)
  574: 		return NULL;
  575: 
  576: 	if (tok->tok_type == J_STRING || tok->tok_type == J_VALUE) {
  577: 		v = ait_getVars(&arr, 0);
  578: 		AIT_SET_STRSIZ(v, json_toklen(tok) + 1);
  579: 		json_tokstrcpy(AIT_GET_STR(v), jstr, tok);
  580: 	} else if (tok->tok_type == J_ARRAY) {
  581: 		for (i = 0; i < tok->tok_size; i++) {
  582: 			t = &tok[i + 1];
  583: 			v = ait_getVars(&arr, i);
  584: 			AIT_SET_STRSIZ(v, json_toklen(t) + 1);
  585: 			json_tokstrcpy(AIT_GET_STR(v), jstr, t);
  586: 		}
  587: 	} else if (tok->tok_type == J_OBJECT) {
  588: 		for (i = 0; tok->tok_idx <= tok[i + 1].tok_parent; i++) {
  589: 			t = &tok[i + 1];
  590: 			v = ait_getVars(&arr, i);
  591: 			AIT_SET_STRSIZ(v, json_toklen(t) + 1);
  592: 			json_tokstrcpy(AIT_GET_STR(v), jstr, t);
  593: 		}
  594: 	} else {
  595: 		elwix_SetErr(J_ERR_PARAM, "%s", jerrstr[J_ERR_PARAM]);
  596: 		ait_freeVars(&arr);
  597: 		return NULL;
  598: 	}
  599: 
  600: 	return arr;
  601: }
  602: 
  603: 
  604: 
  605: /*
  606:  * json_add_begin_object() - Adds begin of object {
  607:  *
  608:  * @jstr = JSON string
  609:  * @jlen = JSON string length
  610:  * @wspace = whitespace include
  611:  * return: -1 error or !=-1 actual JSON string length
  612:  */
  613: int
  614: json_add_begin_object(char * __restrict jstr, int jlen, int wspace)
  615: {
  616: 	int len;
  617: 	size_t eos;
  618: 
  619: 	if (!jstr)
  620: 		return -1;
  621: 	else
  622: 		eos = strlen(jstr);
  623: 
  624: 
  625: 	if (wspace)
  626: 		len = strlcat(jstr, "{ ", jlen);
  627: 	else
  628: 		len = strlcat(jstr, "{", jlen);
  629: 
  630: 	if (len >= jlen) {
  631: 		elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
  632: 		jstr[eos] = 0;
  633: 		return -1;
  634: 	}
  635: 
  636: 	return len;
  637: }
  638: 
  639: /*
  640:  * json_add_end_object() - Adds end of object }
  641:  *
  642:  * @jstr = JSON string
  643:  * @jlen = JSON string length
  644:  * @wspace = whitespace include
  645:  * return: -1 error or !=-1 actual JSON string length
  646:  */
  647: int
  648: json_add_end_object(char * __restrict jstr, int jlen, int wspace)
  649: {
  650: 	int len;
  651: 	size_t eos;
  652: 
  653: 	if (!jstr)
  654: 		return -1;
  655: 	else
  656: 		eos = strlen(jstr);
  657: 
  658: 	if (wspace)
  659: 		len = strlcat(jstr, " }", jlen);
  660: 	else
  661: 		len = strlcat(jstr, "}", jlen);
  662: 
  663: 	if (len >= jlen) {
  664: 		elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
  665: 		jstr[eos] = 0;
  666: 		return -1;
  667: 	}
  668: 
  669: 	return len;
  670: }
  671: 
  672: /*
  673:  * json_add_begin_array() - Adds begin of array [
  674:  *
  675:  * @jstr = JSON string
  676:  * @jlen = JSON string length
  677:  * @wspace = whitespace include
  678:  * return: -1 error or !=-1 actual JSON string length
  679:  */
  680: int
  681: json_add_begin_array(char * __restrict jstr, int jlen, int wspace)
  682: {
  683: 	int len;
  684: 	size_t eos;
  685: 
  686: 	if (!jstr)
  687: 		return -1;
  688: 	else
  689: 		eos = strlen(jstr);
  690: 
  691: 	if (wspace)
  692: 		len = strlcat(jstr, "[ ", jlen);
  693: 	else
  694: 		len = strlcat(jstr, "[", jlen);
  695: 
  696: 	if (len >= jlen) {
  697: 		elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
  698: 		jstr[eos] = 0;
  699: 		return -1;
  700: 	}
  701: 
  702: 	return len;
  703: }
  704: 
  705: /*
  706:  * json_add_end_array() - Adds end of array ]
  707:  *
  708:  * @jstr = JSON string
  709:  * @jlen = JSON string length
  710:  * @wspace = whitespace include
  711:  * return: -1 error or !=-1 actual JSON string length
  712:  */
  713: int
  714: json_add_end_array(char * __restrict jstr, int jlen, int wspace)
  715: {
  716: 	int len;
  717: 	size_t eos;
  718: 
  719: 	if (!jstr)
  720: 		return -1;
  721: 	else
  722: 		eos = strlen(jstr);
  723: 
  724: 	if (wspace)
  725: 		len = strlcat(jstr, " ]", jlen);
  726: 	else
  727: 		len = strlcat(jstr, "]", jlen);
  728: 
  729: 	if (len >= jlen) {
  730: 		elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
  731: 		jstr[eos] = 0;
  732: 		return -1;
  733: 	}
  734: 
  735: 	return len;
  736: }
  737: 
  738: /*
  739:  * json_add_char() - Adds character
  740:  *
  741:  * @jstr = JSON string
  742:  * @jlen = JSON string length
  743:  * @ch = Character
  744:  * return: -1 error or !=-1 actual JSON string length
  745:  */
  746: int
  747: json_add_char(char * __restrict jstr, int jlen, u_char ch)
  748: {
  749: 	int len;
  750: 
  751: 	if (!jstr)
  752: 		return -1;
  753: 
  754: 	len = strlen(jstr) + 1;
  755: 	if (len >= jlen) {
  756: 		elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
  757: 		return -1;
  758: 	} else {
  759: 		jstr[len++] = (char) ch;
  760: 		jstr[len] = 0;
  761: 	}
  762: 
  763: 	return len;
  764: }
  765: 
  766: /*
  767:  * json_add_colon() - Adds key/value pair delimiter colon :
  768:  *
  769:  * @jstr = JSON string
  770:  * @jlen = JSON string length
  771:  * @wspace = whitespace include
  772:  * return: -1 error or !=-1 actual JSON string length
  773:  */
  774: int
  775: json_add_colon(char * __restrict jstr, int jlen, int wspace)
  776: {
  777: 	int len;
  778: 	size_t eos;
  779: 
  780: 	if (!jstr)
  781: 		return -1;
  782: 	else
  783: 		eos = strlen(jstr);
  784: 
  785: 	if (wspace)
  786: 		len = strlcat(jstr, ": ", jlen);
  787: 	else
  788: 		len = strlcat(jstr, ":", jlen);
  789: 
  790: 	if (len >= jlen) {
  791: 		elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
  792: 		jstr[eos] = 0;
  793: 		return -1;
  794: 	}
  795: 
  796: 	return len;
  797: }
  798: 
  799: /*
  800:  * json_add_comma() - Adds value delimiter comma ,
  801:  *
  802:  * @jstr = JSON string
  803:  * @jlen = JSON string length
  804:  * @wspace = whitespace include
  805:  * return: -1 error or !=-1 actual JSON string length
  806:  */
  807: int
  808: json_add_comma(char * __restrict jstr, int jlen, int wspace)
  809: {
  810: 	int len;
  811: 	size_t eos;
  812: 
  813: 	if (!jstr)
  814: 		return -1;
  815: 	else
  816: 		eos = strlen(jstr);
  817: 
  818: 	if (wspace)
  819: 		len = strlcat(jstr, ", ", jlen);
  820: 	else
  821: 		len = strlcat(jstr, ",", jlen);
  822: 
  823: 	if (len >= jlen) {
  824: 		elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
  825: 		jstr[eos] = 0;
  826: 		return -1;
  827: 	}
  828: 
  829: 	return len;
  830: }
  831: 
  832: /*
  833:  * json_add_string() - Adds string
  834:  *
  835:  * @jstr = JSON string
  836:  * @jlen = JSON string length
  837:  * @unquot = Unquoted string
  838:  * @str = String, it can't be NULL
  839:  * return: -1 error or !=-1 actual JSON string length
  840:  */
  841: int
  842: json_add_string(char * __restrict jstr, int jlen, int unquot, const char *str)
  843: {
  844: 	int len;
  845: 	size_t eos;
  846: 
  847: 	if (!jstr || !str)
  848: 		return -1;
  849: 	else
  850: 		eos = strlen(jstr);
  851: 
  852: 	if (!unquot) {
  853: 		len = strlcat(jstr, "\"", jlen);
  854: 		if (len >= jlen) {
  855: 			elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
  856: 			jstr[eos] = 0;
  857: 			return -1;
  858: 		}
  859: 	}
  860: 	len = strlcat(jstr, str, jlen);
  861: 	if (len >= jlen) {
  862: 		elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
  863: 		jstr[eos] = 0;
  864: 		return -1;
  865: 	}
  866: 	if (!unquot) {
  867: 		len = strlcat(jstr, "\"", jlen);
  868: 		if (len >= jlen) {
  869: 			elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
  870: 			jstr[eos] = 0;
  871: 			return -1;
  872: 		}
  873: 	}
  874: 
  875: 	return len;
  876: }
  877: 
  878: /*
  879:  * json_add_value() - Adds value
  880:  *
  881:  * @jstr = JSON string
  882:  * @jlen = JSON string length
  883:  * @unquot = Unquoted number
  884:  * @num = Number
  885:  * return: -1 error or !=-1 actual JSON string length
  886:  */
  887: int
  888: json_add_value(char * __restrict jstr, int jlen, int unquot, long num)
  889: {
  890: 	int len;
  891: 	char wrk[STRSIZ] = { [0 ... STRSIZ - 1] = 0 };
  892: 	size_t eos;
  893: 
  894: 	if (!jstr)
  895: 		return -1;
  896: 	else
  897: 		eos = strlen(jstr);
  898: 
  899: 	if (!unquot) {
  900: 		len = strlcat(jstr, "\"", jlen);
  901: 		if (len >= jlen) {
  902: 			elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
  903: 			jstr[eos] = 0;
  904: 			return -1;
  905: 		}
  906: 	}
  907: 	snprintf(wrk, sizeof wrk, "%ld", num);
  908: 	len = strlcat(jstr, wrk, jlen);
  909: 	if (len >= jlen) {
  910: 		elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
  911: 		jstr[eos] = 0;
  912: 		return -1;
  913: 	}
  914: 	if (!unquot) {
  915: 		len = strlcat(jstr, "\"", jlen);
  916: 		if (len >= jlen) {
  917: 			elwix_SetErr(J_ERR_NOMEM, "%s", jerrstr[J_ERR_NOMEM]);
  918: 			jstr[eos] = 0;
  919: 			return -1;
  920: 		}
  921: 	}
  922: 
  923: 	return len;
  924: }
  925: 
  926: /*
  927:  * json_add_pair() - Adds key/value pair
  928:  *
  929:  * @jstr = JSON string
  930:  * @jlen = JSON string length
  931:  * @wspace = whitespace include
  932:  * @key = Key string
  933:  * @val = Value string
  934:  * return: -1 error or !=-1 actual JSON string length
  935:  */
  936: int
  937: json_add_pair(char * __restrict jstr, int jlen, int wspace, const char *key, const char *val)
  938: {
  939: 	int len = -1;
  940: 	size_t eos;
  941: 
  942: 	if (!jstr || !key || !val)
  943: 		return -1;
  944: 	else
  945: 		eos = strlen(jstr);
  946: 
  947: 	if (json_add_string(jstr, jlen, 0, key) == -1) {
  948: 		jstr[eos] = 0;
  949: 		return -1;
  950: 	}
  951: 	if (json_add_colon(jstr, jlen, wspace) == -1) {
  952: 		jstr[eos] = 0;
  953: 		return -1;
  954: 	}
  955: 	if ((len = json_add_string(jstr, jlen, 0, val)) == -1) {
  956: 		jstr[eos] = 0;
  957: 		return -1;
  958: 	}
  959: 
  960: 	return len;
  961: }
  962: 
  963: /*
  964:  * json_add_array() - Adds array
  965:  *
  966:  * @jstr = JSON string
  967:  * @jlen = JSON string length
  968:  * @wspace = whitespace include
  969:  * @arr = Array with variables
  970:  * return: -1 error or !=-1 actual JSON string length
  971:  */
  972: int
  973: json_add_array(char * __restrict jstr, int jlen, int wspace, array_t * __restrict arr)
  974: {
  975: 	int len = -1;
  976: 	register int i;
  977: 	ait_val_t *v;
  978: 	size_t eos;
  979: 
  980: 	if (!jstr || !arr)
  981: 		return -1;
  982: 	else
  983: 		eos = strlen(jstr);
  984: 
  985: 	if (json_add_begin_array(jstr, jlen, wspace) == -1) {
  986: 		jstr[eos] = 0;
  987: 		return -1;
  988: 	}
  989: 	for (i = 0; i < array_Size(arr); i++) {
  990: 		v = array(arr, i, ait_val_t*);
  991: 		if (v) {
  992: 			if (AIT_TYPE(v) == string) {
  993: 				if (json_add_string(jstr, jlen, 0, AIT_GET_STR(v)) == -1) {
  994: 					jstr[eos] = 0;
  995: 					return -1;
  996: 				}
  997: 			} else {
  998: 				if (json_add_value(jstr, jlen, 0, AIT_GET_LIKE(v, long)) == -1) {
  999: 					jstr[eos] = 0;
 1000: 					return -1;
 1001: 				}
 1002: 			}
 1003: 			if (i < array_Size(arr) - 1 && json_add_comma(jstr, jlen, wspace) == -1) {
 1004: 				jstr[eos] = 0;
 1005: 				return -1;
 1006: 			}
 1007: 		}
 1008: 	}
 1009: 	if ((len = json_add_end_array(jstr, jlen, wspace)) == -1) {
 1010: 		jstr[eos] = 0;
 1011: 		return -1;
 1012: 	}
 1013: 
 1014: 	return len;
 1015: }
 1016: 
 1017: /*
 1018:  * json_dump_yaml() - Dump parsed JSON string to YAML format
 1019:  *
 1020:  * @f = Output handler
 1021:  * @jstr = JSON string
 1022:  * @toks = JSON tokens
 1023:  * @toksnum = Number of tokens
 1024:  * @indent = Start indent spaces
 1025:  * return: 0 done and 1 added one more item
 1026:  */
 1027: int
 1028: json_dump_yaml(FILE *f, const char *jstr, jtok_t *toks, int toksnum, int indent)
 1029: {
 1030: 	register int i, j, k;
 1031: 
 1032: 	if (!toksnum)
 1033: 		return 0;
 1034: 
 1035: 	if (toks->tok_type == J_VALUE) {
 1036: 		fprintf(f, "%.*s", (int) json_toklen(toks), json_tokstr(jstr, toks));
 1037: 		return 1;
 1038: 	} else if (toks->tok_type == J_STRING) {
 1039: 		fprintf(f, "%.*s", (int) json_toklen(toks), json_tokstr(jstr, toks));
 1040: 		return 1;
 1041: 	} else if (toks->tok_type == J_OBJECT) {
 1042: 		fprintf(f, "\n");
 1043: 		for (j = i = 0; i < json_toksize(toks); i++) {
 1044: 			for (k = 0; k < indent; k++)
 1045: 				fprintf(f, "  ");
 1046: 			j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
 1047: 			fprintf(f, ": ");
 1048: 			j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
 1049: 			fprintf(f, "\n");
 1050: 		}
 1051: 		return j + 1;
 1052: 	} else if (toks->tok_type == J_ARRAY) {
 1053: 		fprintf(f, "\n");
 1054: 		for (j = i = 0; i < json_toksize(toks); i++) {
 1055: 			for (k = 0; k < indent - 1; k++)
 1056: 				fprintf(f, "  ");
 1057: 			fprintf(f, "   - ");
 1058: 			j += json_dump_yaml(f, jstr, toks + j + 1, toksnum - j, indent + 1);
 1059: 			fprintf(f, "\n");
 1060: 		}
 1061: 		return j + 1;
 1062: 	}
 1063: 
 1064: 	return 0;
 1065: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>