json.h

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DATA_JSON_H_
#define ZEPHYR_INCLUDE_DATA_JSON_H_
 
#include <zephyr/sys/util.h>
#include <stddef.h>
#include <zephyr/toolchain.h>
#include <zephyr/types.h>
#include <sys/types.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum json_tokens {
        /* Before changing this enum, ensure that its maximum
         * value is still within 7 bits. See comment next to the
         * declaration of `type` in struct json_obj_descr.
         */
 
        JSON_TOK_NONE = '_',
        JSON_TOK_OBJECT_START = '{',
        JSON_TOK_OBJECT_END = '}',
        /* JSON_TOK_LIST_START will be removed use JSON_TOK_ARRAY_START */
        JSON_TOK_LIST_START __deprecated = '[',
        JSON_TOK_ARRAY_START = '[',
        /* JSON_TOK_LIST_END will be removed use JSON_TOK_ARRAY_END */
        JSON_TOK_LIST_END __deprecated = ']',
        JSON_TOK_ARRAY_END = ']',
        JSON_TOK_STRING = '"',
        JSON_TOK_COLON = ':',
        JSON_TOK_COMMA = ',',
        JSON_TOK_NUMBER = '0',
        JSON_TOK_FLOAT = '1',
        JSON_TOK_OPAQUE = '2',
        JSON_TOK_OBJ_ARRAY = '3',
        JSON_TOK_TRUE = 't',
        JSON_TOK_FALSE = 'f',
        JSON_TOK_NULL = 'n',
        JSON_TOK_ERROR = '!',
        JSON_TOK_EOF = '\0',
};
 
struct json_token {
        enum json_tokens type;
        char *start;
        char *end;
};
 
struct json_lexer {
        void *(*state)(struct json_lexer *lex);
        char *start;
        char *pos;
        char *end;
        struct json_token tok;
};
 
struct json_obj {
        struct json_lexer lex;
};
 
struct json_obj_token {
        char *start;
        size_t length;
};
 
 
struct json_obj_descr {
        const char *field_name;
 
        /* Alignment can be 1, 2, 4, or 8.  The macros to create
         * a struct json_obj_descr will store the alignment's
         * power of 2 in order to keep this value in the 0-3 range
         * and thus use only 2 bits.
         */
        uint32_t align_shift : 2;
 
        /* 127 characters is more than enough for a field name. */
        uint32_t field_name_len : 7;
 
        /* Valid values here (enum json_tokens): JSON_TOK_STRING,
         * JSON_TOK_NUMBER, JSON_TOK_TRUE, JSON_TOK_FALSE,
         * JSON_TOK_OBJECT_START, JSON_TOK_ARRAY_START.  (All others
         * ignored.) Maximum value is '}' (125), so this has to be 7 bits
         * long.
         */
        uint32_t type : 7;
 
        /* 65535 bytes is more than enough for many JSON payloads. */
        uint32_t offset : 16;
 
        union {
                struct {
                        const struct json_obj_descr *sub_descr;
                        size_t sub_descr_len;
                } object;
                struct {
                        const struct json_obj_descr *element_descr;
                        size_t n_elements;
                } array;
        };
};
 
typedef int (*json_append_bytes_t)(const char *bytes, size_t len,
                                   void *data);
 
#define Z_ALIGN_SHIFT(type)     (__alignof__(type) == 1 ? 0 : \
                                 __alignof__(type) == 2 ? 1 : \
                                 __alignof__(type) == 4 ? 2 : 3)
 
#define JSON_OBJ_DESCR_PRIM(struct_, field_name_, type_) \
        { \
                .field_name = (#field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(#field_name_) - 1, \
                .type = type_, \
                .offset = offsetof(struct_, field_name_), \
        }
 
#define JSON_OBJ_DESCR_OBJECT(struct_, field_name_, sub_descr_) \
        { \
                .field_name = (#field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = (sizeof(#field_name_) - 1), \
                .type = JSON_TOK_OBJECT_START, \
                .offset = offsetof(struct_, field_name_), \
                { \
                        .object = { \
                                .sub_descr = sub_descr_, \
                                .sub_descr_len = ARRAY_SIZE(sub_descr_), \
                        }, \
                }, \
        }
 
#define Z_JSON_ELEMENT_DESCR(struct_, len_field_, elem_type_, union_) \
        (const struct json_obj_descr[]) \
        { \
                { \
                        .align_shift = Z_ALIGN_SHIFT(struct_), \
                        .type = elem_type_, \
                        .offset = offsetof(struct_, len_field_), \
                        union_ \
                } \
        }
 
#define Z_JSON_DESCR_ARRAY(elem_descr_, elem_descr_len_) \
        { \
                .array = { \
                        .element_descr = elem_descr_, \
                        .n_elements = elem_descr_len_, \
                }, \
        }
 
#define Z_JSON_DESCR_OBJ(elem_descr_, elem_descr_len_) \
        { \
                .object = { \
                        .sub_descr = elem_descr_, \
                        .sub_descr_len = elem_descr_len_, \
                }, \
        }
 
#define JSON_OBJ_DESCR_ARRAY(struct_, field_name_, max_len_, \
                             len_field_, elem_type_) \
        { \
                .field_name = (#field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(#field_name_) - 1, \
                .type = JSON_TOK_ARRAY_START, \
                .offset = offsetof(struct_, field_name_), \
                { \
                        .array = { \
                                .element_descr = Z_JSON_ELEMENT_DESCR(struct_, len_field_, \
                                        elem_type_,), \
                                .n_elements = (max_len_), \
                        }, \
                }, \
        }
 
#define JSON_OBJ_DESCR_OBJ_ARRAY(struct_, field_name_, max_len_, \
                                 len_field_, elem_descr_, elem_descr_len_) \
        { \
                .field_name = (#field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(#field_name_) - 1, \
                .type = JSON_TOK_ARRAY_START, \
                .offset = offsetof(struct_, field_name_), \
                { \
                        .array = { \
                                .element_descr = Z_JSON_ELEMENT_DESCR(struct_, len_field_, \
                                        JSON_TOK_OBJECT_START, \
                                        Z_JSON_DESCR_OBJ(elem_descr_, elem_descr_len_)), \
                                .n_elements = (max_len_), \
                        }, \
                }, \
        }
 
#define JSON_OBJ_DESCR_ARRAY_ARRAY(struct_, field_name_, max_len_, len_field_, \
                                   elem_descr_, elem_descr_len_) \
        { \
                .field_name = (#field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(#field_name_) - 1, \
                .type = JSON_TOK_ARRAY_START, \
                .offset = offsetof(struct_, field_name_), \
                { \
                        .array = { \
                                .element_descr = Z_JSON_ELEMENT_DESCR( \
                                        struct_, len_field_, JSON_TOK_ARRAY_START, \
                                        Z_JSON_DESCR_ARRAY( \
                                                elem_descr_, \
                                                1 + ZERO_OR_COMPILE_ERROR(elem_descr_len_ == 1))), \
                                .n_elements = (max_len_), \
                        }, \
                }, \
        }
 
#define JSON_OBJ_DESCR_PRIM_NAMED(struct_, json_field_name_, \
                                  struct_field_name_, type_) \
        { \
                .field_name = (json_field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(json_field_name_) - 1, \
                .type = type_, \
                .offset = offsetof(struct_, struct_field_name_), \
        }
 
#define JSON_OBJ_DESCR_OBJECT_NAMED(struct_, json_field_name_, \
                                    struct_field_name_, sub_descr_) \
        { \
                .field_name = (json_field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = (sizeof(json_field_name_) - 1), \
                .type = JSON_TOK_OBJECT_START, \
                .offset = offsetof(struct_, struct_field_name_), \
                { \
                        .object = { \
                                .sub_descr = sub_descr_, \
                                .sub_descr_len = ARRAY_SIZE(sub_descr_), \
                        }, \
                }, \
        }
 
#define JSON_OBJ_DESCR_ARRAY_NAMED(struct_, json_field_name_,\
                                   struct_field_name_, max_len_, len_field_, \
                                   elem_type_) \
        { \
                .field_name = (json_field_name_), \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(json_field_name_) - 1, \
                .type = JSON_TOK_ARRAY_START, \
                .offset = offsetof(struct_, struct_field_name_), \
                { \
                        .array = { \
                                .element_descr = \
                                        Z_JSON_ELEMENT_DESCR(struct_, len_field_, elem_type_,), \
                                .n_elements = (max_len_), \
                        }, \
                }, \
        }
 
#define JSON_OBJ_DESCR_OBJ_ARRAY_NAMED(struct_, json_field_name_, \
                                       struct_field_name_, max_len_, \
                                       len_field_, elem_descr_, \
                                       elem_descr_len_) \
        { \
                .field_name = json_field_name_, \
                .align_shift = Z_ALIGN_SHIFT(struct_), \
                .field_name_len = sizeof(json_field_name_) - 1, \
                .type = JSON_TOK_ARRAY_START, \
                .offset = offsetof(struct_, struct_field_name_), \
                { \
                        .array = { \
                                .element_descr = Z_JSON_ELEMENT_DESCR(struct_, len_field_, \
                                        JSON_TOK_OBJECT_START, \
                                        Z_JSON_DESCR_OBJ(elem_descr_, elem_descr_len_)), \
                                .n_elements = (max_len_), \
                        }, \
                }, \
        }
 
int64_t json_obj_parse(char *json, size_t len,
        const struct json_obj_descr *descr, size_t descr_len,
        void *val);
 
int json_arr_parse(char *json, size_t len,
        const struct json_obj_descr *descr, void *val);
 
int json_arr_separate_object_parse_init(struct json_obj *json, char *payload, size_t len);
 
int json_arr_separate_parse_object(struct json_obj *json, const struct json_obj_descr *descr,
                                   size_t descr_len, void *val);
 
ssize_t json_escape(char *str, size_t *len, size_t buf_size);
 
size_t json_calc_escaped_len(const char *str, size_t len);
 
ssize_t json_calc_encoded_len(const struct json_obj_descr *descr,
                              size_t descr_len, const void *val);
 
int json_obj_encode_buf(const struct json_obj_descr *descr, size_t descr_len,
                        const void *val, char *buffer, size_t buf_size);
 
int json_arr_encode_buf(const struct json_obj_descr *descr, const void *val,
                        char *buffer, size_t buf_size);
 
int json_obj_encode(const struct json_obj_descr *descr, size_t descr_len,
                    const void *val, json_append_bytes_t append_bytes,
                    void *data);
 
int json_arr_encode(const struct json_obj_descr *descr, const void *val,
                    json_append_bytes_t append_bytes, void *data);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_DATA_JSON_H_ */