Annotation of libelwix/inc/elwix/ajson.h, revision 1.6.6.1

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.6.6.1 ! misho       6: * $Id: ajson.h,v 1.6 2018/04/19 16:13:48 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.4       misho      15: Copyright 2004 - 2018
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: #ifndef __AJSON_H
                     47: #define __AJSON_H
                     48: 
                     49: 
                     50: /* JSON type identifiers */
                     51: typedef enum {
                     52:        J_UNDEF = 0,
                     53:        J_OBJECT = 1,
                     54:        J_ARRAY = 2,
                     55:        J_STRING = 3,
                     56:        J_VALUE = 4
                     57: } jtype_t;
                     58: 
                     59: /* JSON error numbers */
                     60: typedef enum {
                     61:        J_ERR_OK = 0,
                     62:        J_ERR_NOMEM = 1,
                     63:        J_ERR_INVAL = 2,
                     64:        J_ERR_PART = 3,
                     65:        J_ERR_PARAM = 4
                     66: } jerr_t;
                     67: 
                     68: typedef struct _tagHandler {
                     69:        unsigned long   h_pos;
                     70:        unsigned long   h_next;
                     71:        long            h_parent;
                     72:        void            *h_alloc;
                     73:        int             h_strict;
                     74: } json_t;
                     75: #define json_toksnum(x)                (x)->h_next
                     76: 
                     77: typedef struct _tagToken {
                     78:        long            tok_idx;
                     79:        jtype_t         tok_type;
                     80:        long            tok_start;
                     81:        long            tok_end;
                     82:        long            tok_size;
                     83:        long            tok_parent;
                     84: } jtok_t;
                     85: #define json_toktype(x)                (x)->tok_type
                     86: #define json_toksize(x)                (x)->tok_size
                     87: #define json_toklen(x)         ((x)->tok_end - (x)->tok_start)
                     88: #define json_tokstr(j, x)      ((j) + (x)->tok_start)
                     89: #define json_tokstrcpy(d, j, x)        { strncpy((d), json_tokstr((j), (x)), json_toklen(x)); \
                     90:                                        (d)[json_toklen(x)] = 0; } 
                     91: 
                     92: 
                     93: /*
                     94:  * json_init() - Initialize JSON handler
                     95:  *
                     96:  * @json = JSON handler, if there is NULL then dynamically will be allocated
                     97:  * @jstrict = JSON strict mode, when we select strict mode every unquoted value is error
                     98:  * return: =NULL error or !=NULL ready for use JSON handler and should be free with json_free()
                     99:  */
                    100: json_t *json_init(json_t * __restrict json, int jstrict);
                    101: 
                    102: /*
                    103:  * json_free() - Free JSON handler
                    104:  *
                    105:  * @json = JSON handler
                    106:  * return: none
                    107:  */
                    108: void json_free(json_t * __restrict json);
                    109: 
                    110: /*
                    111:  * json_parse() - Parse JSON string
                    112:  *
                    113:  * @json = JSON handler
                    114:  * @jstr = JSON string
                    115:  * @jlen = JSON string length
                    116:  * @jtoks = Token array
                    117:  * @toksnum = Token array size, return number of allocated tokens in array
                    118:  * return: -1 error or number of found tokens 
                    119:  */
                    120: unsigned int json_parse(json_t * __restrict json, const char *jstr, size_t jlen, 
                    121:                jtok_t * __restrict jtoks, unsigned int toksnum);
                    122: 
                    123: /*
                    124:  * json_token2val() - Return token to AIT variable
                    125:  *
                    126:  * @jstr = JSON string
                    127:  * @tok = Token for convert
                    128:  * @return =NULL error or !=NULL variable, after use should be ait_freeVar()
                    129:  */
                    130: ait_val_t *json_token2val(const char *jstr, jtok_t * __restrict tok);
                    131: /*
                    132:  * json_token2str() - Return token to string
                    133:  *
                    134:  * @jstr = JSON string
                    135:  * @tok = Token for convert
1.5       misho     136:  * @return =NULL error or !=NULL allocated str, after use should be json_freestr()|e_free()
1.2       misho     137:  */
                    138: char *json_token2str(const char *jstr, jtok_t * __restrict tok);
1.5       misho     139: #define json_freestr(x)                e_free((x))
1.2       misho     140: /*
                    141:  * json_token2num() - Return token to numeric
                    142:  *
                    143:  * @jstr = JSON string
                    144:  * @tok = Token for convert
                    145:  * @return number
                    146:  */
                    147: long json_token2num(const char *jstr, jtok_t * __restrict tok);
                    148: /*
1.5       misho     149:  * json_token2dbl() - Return token to double
                    150:  *
                    151:  * @jstr = JSON string
                    152:  * @tok = Token for convert
                    153:  * @return number
                    154:  */
                    155: double json_token2dbl(const char *jstr, jtok_t * __restrict tok);
1.6       misho     156: /*
                    157:  * json_token2bool() - Return token to bool int
                    158:  *
                    159:  * @jstr = JSON string
                    160:  * @tok = Token for convert
                    161:  * @return 0 for FALSE and !=0 for TRUE
                    162:  */
                    163: int json_token2bool(const char *jstr, jtok_t * __restrict tok);
1.5       misho     164: /*
1.2       misho     165:  * json_token2array() - Convert token to string array
                    166:  *
                    167:  * @jstr = JSON string
                    168:  * @tok = Token for convert
                    169:  * return: =NULL error or !=NULL allocated array with string variables, 
                    170:  *             after use should be ait_freeVars()
                    171:  */
                    172: array_t *json_token2array(const char *jstr, jtok_t * __restrict tok);
                    173: 
                    174: /*
1.5       misho     175:  * json_findbykey() - Find token data by key
1.2       misho     176:  *
                    177:  * @jstr = JSON string
                    178:  * @key = Search key
1.4       misho     179:  * @type = Search key for particular token type, if is J_UNDEF this mean any type
1.2       misho     180:  * @toks = Parsed tokens
                    181:  * @toksnum = Number of parsed tokens
                    182:  * return: =NULL error or !=NULL data token found 
                    183:  */
                    184: jtok_t *json_findbykey(const char *jstr, const char *key, 
1.4       misho     185:                jtype_t type, jtok_t * __restrict toks, int toksnum);
1.5       misho     186: /*
                    187:  * json_findbypos() - Find token by position on JSON string
                    188:  *
                    189:  * @pos = Offset from begin of JSON string
                    190:  * @toks = Parsed tokens
                    191:  * @toksnum = Number of parsed tokens
                    192:  * return: =NULL error or !=NULL token found 
                    193:  */
                    194: jtok_t *json_findbypos(unsigned long pos, jtok_t * __restrict toks, int toksnum);
1.3       misho     195: 
                    196: 
                    197: /*
                    198:  * json_dump_yaml() - Dump parsed JSON string to YAML format
                    199:  *
                    200:  * @f = Output handler
                    201:  * @jstr = JSON string
                    202:  * @toks = JSON tokens
                    203:  * @toksnum = Number of tokens
                    204:  * @indent = Start indent spaces
                    205:  * return: 0 done and 1 added one more item
                    206:  */
                    207: int json_dump_yaml(FILE *f, const char *jstr, jtok_t *toks, int toksnum, int indent);
1.5       misho     208: /*
                    209:  * json_dump() - Dump parsed JSON string to structure format
                    210:  *
                    211:  * @f = Output handler
                    212:  * @jstr = JSON string
                    213:  * @toks = JSON tokens
                    214:  * @toksnum = Number of tokens
                    215:  * @indent = Start indent spaces
                    216:  * return: 0 done and 1 added one more item
                    217:  */
                    218: int json_dump(FILE *f, const char *jstr, jtok_t *toks, int toksnum, int indent);
1.2       misho     219: 
                    220: 
                    221: /*
                    222:  * json_add_begin_object() - Adds begin of object {
                    223:  *
                    224:  * @jstr = JSON string
                    225:  * @jlen = JSON string length
                    226:  * @wspace = whitespace include
                    227:  * return: -1 error or !=-1 actual JSON string length
                    228:  */
                    229: int json_add_begin_object(char * __restrict jstr, int jlen, int wspace);
                    230: /*
                    231:  * json_add_end_object() - Adds end of object }
                    232:  *
                    233:  * @jstr = JSON string
                    234:  * @jlen = JSON string length
                    235:  * @wspace = whitespace include
                    236:  * return: -1 error or !=-1 actual JSON string length
                    237:  */
                    238: int json_add_end_object(char * __restrict jstr, int jlen, int wspace);
                    239: /*
                    240:  * json_add_begin_array() - Adds begin of array [
                    241:  *
                    242:  * @jstr = JSON string
                    243:  * @jlen = JSON string length
                    244:  * @wspace = whitespace include
                    245:  * return: -1 error or !=-1 actual JSON string length
                    246:  */
                    247: int json_add_begin_array(char * __restrict jstr, int jlen, int wspace);
                    248: /*
                    249:  * json_add_end_array() - Adds end of array ]
                    250:  *
                    251:  * @jstr = JSON string
                    252:  * @jlen = JSON string length
                    253:  * @wspace = whitespace include
                    254:  * return: -1 error or !=-1 actual JSON string length
                    255:  */
                    256: int json_add_end_array(char * __restrict jstr, int jlen, int wspace);
                    257: /*
                    258:  * json_add_char() - Adds character
                    259:  *
                    260:  * @jstr = JSON string
                    261:  * @jlen = JSON string length
                    262:  * @ch = Character
                    263:  * return: -1 error or !=-1 actual JSON string length
                    264:  */
                    265: int json_add_char(char * __restrict jstr, int jlen, unsigned char ch);
                    266: /*
                    267:  * json_add_colon() - Adds key/value pair delimiter colon :
                    268:  *
                    269:  * @jstr = JSON string
                    270:  * @jlen = JSON string length
                    271:  * @wspace = whitespace include
                    272:  * return: -1 error or !=-1 actual JSON string length
                    273:  */
                    274: int json_add_colon(char * __restrict jstr, int jlen, int wspace);
                    275: /*
                    276:  * json_add_comma() - Adds value delimiter comma ,
                    277:  *
                    278:  * @jstr = JSON string
                    279:  * @jlen = JSON string length
                    280:  * @wspace = whitespace include
                    281:  * return: -1 error or !=-1 actual JSON string length
                    282:  */
                    283: int json_add_comma(char * __restrict jstr, int jlen, int wspace);
                    284: /*
                    285:  * json_add_string() - Adds string
                    286:  *
                    287:  * @jstr = JSON string
                    288:  * @jlen = JSON string length
                    289:  * @unquot = Unquoted string
                    290:  * @str = String, it can't be NULL
                    291:  * return: -1 error or !=-1 actual JSON string length
                    292:  */
                    293: int json_add_string(char * __restrict jstr, int jlen, int unquot, const char *str);
                    294: /*
                    295:  * json_add_value() - Adds value
                    296:  *
                    297:  * @jstr = JSON string
                    298:  * @jlen = JSON string length
                    299:  * @unquot = Unquoted number
                    300:  * @num = Number
                    301:  * return: -1 error or !=-1 actual JSON string length
                    302:  */
                    303: int json_add_value(char * __restrict jstr, int jlen, int unquot, long num);
                    304: /*
                    305:  * json_add_pair() - Adds key/value pair
                    306:  *
                    307:  * @jstr = JSON string
                    308:  * @jlen = JSON string length
                    309:  * @wspace = whitespace include
                    310:  * @key = Key string
                    311:  * @val = Value string
                    312:  * return: -1 error or !=-1 actual JSON string length
                    313:  */
                    314: int json_add_pair(char * __restrict jstr, int jlen, int wspace, 
                    315:                const char *key, const char *val);
1.6.6.1 ! misho     316: /*
        !           317:  * json_add_pair2() - Adds key/value pair with formated args
        !           318:  *
        !           319:  * @jstr = JSON string
        !           320:  * @jlen = JSON string length
        !           321:  * @wspace = whitespace include
        !           322:  * @key = Key string
        !           323:  * @fmt = Format string for values
        !           324:  * return: -1 error or !=-1 actual JSON string length
        !           325:  */
        !           326: int json_add_pair2(char * __restrict jstr, int jlen, int wspace, 
        !           327:                const char *key, const char *fmt, ...);
1.2       misho     328: /*
                    329:  * json_add_array() - Adds array
                    330:  *
                    331:  * @jstr = JSON string
                    332:  * @jlen = JSON string length
                    333:  * @wspace = whitespace include
                    334:  * @arr = Array with variables
                    335:  * return: -1 error or !=-1 actual JSON string length
                    336:  */
                    337: int json_add_array(char * __restrict jstr, int jlen, int wspace, 
                    338:                array_t * __restrict arr);
                    339: 
                    340: 
                    341: #endif

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