sol-json.h

Go to the documentation of this file.

/*
 * This file is part of the Soletta (TM) Project
 *
 * Copyright (C) 2015 Intel Corporation. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>
#include <errno.h>
#include <stdint.h>
#include <sol-buffer.h>
#include <sol-macros.h>
#include <sol-str-slice.h>
#include <sol-buffer.h>
#include <sol-memdesc.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef struct sol_json_scanner {
    const char *mem; 
    const char *mem_end; 
    const char *current; 
} sol_json_scanner;

typedef struct sol_json_token {
    const char *start; 
    const char *end; 
} sol_json_token;

enum sol_json_type {
    SOL_JSON_TYPE_UNKNOWN = 0, 
    SOL_JSON_TYPE_OBJECT_START = '{', 
    SOL_JSON_TYPE_OBJECT_END = '}', 
    SOL_JSON_TYPE_ARRAY_START = '[', 
    SOL_JSON_TYPE_ARRAY_END = ']', 
    SOL_JSON_TYPE_ELEMENT_SEP = ',', 
    SOL_JSON_TYPE_PAIR_SEP = ':', 
    SOL_JSON_TYPE_TRUE = 't', 
    SOL_JSON_TYPE_FALSE = 'f', 
    SOL_JSON_TYPE_NULL = 'n', 
    SOL_JSON_TYPE_STRING = '"', 
    SOL_JSON_TYPE_NUMBER = '1', 
};

enum sol_json_loop_status {
    SOL_JSON_LOOP_REASON_OK = 0, 
    SOL_JSON_LOOP_REASON_INVALID 
};

#define SOL_JSON_SCANNER_ARRAY_LOOP_TYPE_NESTED(scanner_, token_, element_type_, status_) \
    for (status_ = SOL_JSON_LOOP_REASON_OK; \
        sol_json_loop_iterate_array(scanner_, token_, &status_, element_type_);)

#define SOL_JSON_SCANNER_ARRAY_LOOP_TYPE(scanner_, token_, element_type_, status_) \
    for (status_ = sol_json_loop_iterate_init(scanner_, token_, SOL_JSON_TYPE_ARRAY_START); \
        sol_json_loop_iterate_array(scanner_, token_, &status_, element_type_);)

#define SOL_JSON_SCANNER_ARRAY_LOOP_NESTED(scanner_, token_, status_) \
    for (status_ = SOL_JSON_LOOP_REASON_OK; \
        sol_json_loop_iterate_generic(scanner_, token_, SOL_JSON_TYPE_ARRAY_END, &status_);)

#define SOL_JSON_SCANNER_ARRAY_LOOP(scanner_, token_, status_) \
    for (status_ = sol_json_loop_iterate_init(scanner_, token_, SOL_JSON_TYPE_ARRAY_START); \
        sol_json_loop_iterate_generic(scanner_, token_, SOL_JSON_TYPE_ARRAY_END, &status_);)

#define SOL_JSON_SCANNER_OBJECT_LOOP_NESTED(scanner_, token_, key_, value_, status_) \
    for (status_ = SOL_JSON_LOOP_REASON_OK; \
        sol_json_loop_iterate_object(scanner_, token_, key_, value_, &status_);)

#define SOL_JSON_SCANNER_OBJECT_LOOP(scanner_, token_, key_, value_, status_) \
    for (status_ = sol_json_loop_iterate_init(scanner_, token_, SOL_JSON_TYPE_OBJECT_START); \
        sol_json_loop_iterate_object(scanner_, token_, key_, value_, &status_);)

static inline void
sol_json_scanner_init(struct sol_json_scanner *scanner, const void *mem, size_t size)
{
    scanner->mem = (const char *)mem;
    scanner->mem_end = scanner->mem + size;
    scanner->current = (const char *)mem;
}

static inline void
sol_json_scanner_init_null(struct sol_json_scanner *scanner)
{
    scanner->mem = NULL;
    scanner->mem_end = NULL;
    scanner->current = NULL;
}

static inline void
sol_json_scanner_init_from_slice(struct sol_json_scanner *scanner, const struct sol_str_slice slice)
{
    sol_json_scanner_init(scanner, slice.data, slice.len);
}

static inline void
sol_json_token_init_from_slice(struct sol_json_token *token, const struct sol_str_slice slice)
{
    token->start = slice.data;
    token->end = slice.data + slice.len;
}

static inline void
sol_json_scanner_init_from_scanner(struct sol_json_scanner *scanner,
    const struct sol_json_scanner *other)
{
    scanner->mem = other->mem;
    scanner->mem_end = other->mem_end;
    scanner->current = scanner->mem;
}

static inline void
sol_json_scanner_init_from_token(struct sol_json_scanner *scanner,
    const struct sol_json_token *token)
{
    scanner->mem = token->start;
    scanner->mem_end = token->end;
    scanner->current = scanner->mem;
}

static inline size_t
sol_json_scanner_get_size_remaining(const struct sol_json_scanner *scanner)
{
    return scanner->mem_end - scanner->current;
}

static inline size_t
sol_json_scanner_get_mem_offset(const struct sol_json_scanner *scanner, const void *mem)
{
    const char *p = (const char *)mem;

    if (p < scanner->mem || p > scanner->mem_end)
        return (size_t)-1;
    return p - scanner->mem;
}

static inline enum sol_json_type
sol_json_mem_get_type(const void *mem)
{
    const char *p = (const char *)mem;

    if (strchr("{}[],:tfn\"", *p))
        return (enum sol_json_type)*p;
    if (isdigit((uint8_t)*p) || *p == '-' || *p == '+')
        return SOL_JSON_TYPE_NUMBER;
    return SOL_JSON_TYPE_UNKNOWN;
}

static inline enum sol_json_type
sol_json_token_get_type(const struct sol_json_token *token)
{
    return sol_json_mem_get_type(token->start);
}

static inline size_t
sol_json_token_get_size(const struct sol_json_token *token)
{
    return token->end - token->start;
}

static inline bool
sol_json_token_str_eq(const struct sol_json_token *token, const char *str, size_t len)
{
    size_t size;

    assert(sol_json_token_get_type(token) == SOL_JSON_TYPE_STRING);

    size = sol_json_token_get_size(token);
    return (size == len + 2) && memcmp(token->start + 1, str, len) == 0;
}

#define SOL_JSON_TOKEN_STR_LITERAL_EQ(token_, str_) \
    sol_json_token_str_eq(token_, str_, sizeof(str_) - 1)

int sol_json_token_get_uint64(const struct sol_json_token *token, uint64_t *value)
#ifndef DOXYGEN_RUN
    SOL_ATTR_WARN_UNUSED_RESULT
#endif
    ;

int sol_json_token_get_int64(const struct sol_json_token *token, int64_t *value)
#ifndef DOXYGEN_RUN
    SOL_ATTR_WARN_UNUSED_RESULT
#endif
    ;

static inline int
sol_json_token_get_uint32(const struct sol_json_token *token, uint32_t *value)
{
    uint64_t tmp;
    int r = sol_json_token_get_uint64(token, &tmp);

    if (tmp > UINT32_MAX) {
        tmp = UINT32_MAX;
        if (r == 0)
            r = -ERANGE;
    }

    *value = tmp;
    return r;
}

static inline int
sol_json_token_get_int32(const struct sol_json_token *token, int32_t *value)
{
    int64_t tmp;
    int r = sol_json_token_get_int64(token, &tmp);

    if (tmp > INT32_MAX) {
        tmp = INT32_MAX;
        if (r == 0)
            r = -ERANGE;
    } else if (tmp < INT32_MIN) {
        tmp = INT32_MIN;
        if (r == 0)
            r = -ERANGE;
    }

    *value = tmp;
    return r;
}

int sol_json_token_get_double(const struct sol_json_token *token, double *value) SOL_ATTR_WARN_UNUSED_RESULT;

static inline struct sol_str_slice
sol_json_token_to_slice(const struct sol_json_token *token)
{
    return SOL_STR_SLICE_STR(token->start, (size_t)(token->end - token->start));
}

bool sol_json_scanner_next(struct sol_json_scanner *scanner,
    struct sol_json_token *token)
#ifndef DOXYGEN_RUN
    SOL_ATTR_WARN_UNUSED_RESULT SOL_ATTR_NON_NULL(1, 2)
#endif
    ;

bool sol_json_scanner_skip(struct sol_json_scanner *scanner,
    struct sol_json_token *token)
#ifndef DOXYGEN_RUN
    SOL_ATTR_WARN_UNUSED_RESULT SOL_ATTR_NON_NULL(1, 2)
#endif
    ;

bool sol_json_scanner_get_dict_pair(struct sol_json_scanner *scanner,
    struct sol_json_token *key, struct sol_json_token *value)
#ifndef DOXYGEN_RUN
    SOL_ATTR_WARN_UNUSED_RESULT SOL_ATTR_NON_NULL(1, 2, 3)
#endif
    ;

static inline bool
sol_json_loop_iterate_generic(struct sol_json_scanner *scanner, struct sol_json_token *token,
    enum sol_json_type end_type, enum sol_json_loop_status *reason)
{
    if (*reason != SOL_JSON_LOOP_REASON_OK)
        return false;

    if (!sol_json_scanner_next(scanner, token)) {
        *reason = SOL_JSON_LOOP_REASON_INVALID;
        return false;
    }

    if (sol_json_token_get_type(token) == end_type) {
        *reason = SOL_JSON_LOOP_REASON_OK;
        return false;
    }

    if (sol_json_token_get_type(token) == SOL_JSON_TYPE_ELEMENT_SEP) {
        if (!sol_json_scanner_next(scanner, token)) {
            *reason = SOL_JSON_LOOP_REASON_INVALID;
            return false;
        }
    }

    return true;
}

static inline bool
sol_json_loop_iterate_array(struct sol_json_scanner *scanner, struct sol_json_token *token,
    enum sol_json_loop_status *reason, enum sol_json_type element_type)
{
    if (!sol_json_loop_iterate_generic(scanner, token, SOL_JSON_TYPE_ARRAY_END, reason))
        return false;

    if (sol_json_token_get_type(token) == element_type) {
        *reason = SOL_JSON_LOOP_REASON_OK;
        return true;
    }

    *reason = SOL_JSON_LOOP_REASON_INVALID;
    return false;
}

static inline bool
sol_json_loop_iterate_object(struct sol_json_scanner *scanner, struct sol_json_token *token,
    struct sol_json_token *key, struct sol_json_token *value, enum sol_json_loop_status *reason)
{
    if (!sol_json_loop_iterate_generic(scanner, token, SOL_JSON_TYPE_OBJECT_END, reason))
        return false;

    *key = *token;
    if (!sol_json_scanner_get_dict_pair(scanner, key, value)) {
        *reason = SOL_JSON_LOOP_REASON_INVALID;
        return false;
    }

    *reason = SOL_JSON_LOOP_REASON_OK;
    return true;
}

static inline enum sol_json_loop_status
sol_json_loop_iterate_init(struct sol_json_scanner *scanner, struct sol_json_token *token,
    enum sol_json_type start_type)
{
    if (!sol_json_scanner_next(scanner, token))
        return SOL_JSON_LOOP_REASON_INVALID;
    if (sol_json_token_get_type(token) != start_type)
        return SOL_JSON_LOOP_REASON_INVALID;
    return SOL_JSON_LOOP_REASON_OK;
}

size_t sol_json_calculate_escaped_string_len(const char *str);

char *sol_json_escape_string(const char *str, struct sol_buffer *buf);

int sol_json_double_to_str(const double value, struct sol_buffer *buf);

bool sol_json_is_valid_type(struct sol_json_scanner *scanner, enum sol_json_type start_type)
#ifndef DOXYGEN_RUN
    SOL_ATTR_NON_NULL(1)
#endif
    ;

int sol_json_serialize_string(struct sol_buffer *buffer, const char *str);

int sol_json_serialize_double(struct sol_buffer *buffer, double val);

int sol_json_serialize_int32(struct sol_buffer *buffer, int32_t val);

int sol_json_serialize_uint32(struct sol_buffer *buffer, uint32_t val);

int sol_json_serialize_int64(struct sol_buffer *buffer, int64_t val);

int sol_json_serialize_uint64(struct sol_buffer *buffer, uint64_t val);

int sol_json_serialize_bool(struct sol_buffer *buffer, bool val);

static inline int
sol_json_serialize_null(struct sol_buffer *buffer)
{
    static const struct sol_str_slice null = SOL_STR_SLICE_LITERAL("null");

    return sol_buffer_append_slice(buffer, null);
}

int sol_json_serialize_memdesc(struct sol_buffer *buffer, const struct sol_memdesc *desc, const void *memory, bool detailed_structures);

int sol_json_load_memdesc(const struct sol_json_token *token, const struct sol_memdesc *desc, void *memory);

int sol_json_token_get_unescaped_string(const struct sol_json_token *token, struct sol_buffer *buffer);

char *sol_json_token_get_unescaped_string_copy(const struct sol_json_token *value);

int sol_json_object_get_value_by_key(struct sol_json_scanner *scanner, const struct sol_str_slice key_slice, struct sol_json_token *value);

int sol_json_array_get_at_index(struct sol_json_scanner *scanner, uint16_t i, struct sol_json_token *value);

typedef struct sol_json_path_scanner {
    const char *path; 
    const char *end; 
    const char *current;
} sol_json_path_scanner;

int sol_json_get_value_by_path(struct sol_json_scanner *scanner, struct sol_str_slice path, struct sol_json_token *value);

int sol_json_path_scanner_init(struct sol_json_path_scanner *scanner, struct sol_str_slice path)
#ifndef DOXYGEN_RUN
    SOL_ATTR_NON_NULL(1)
#endif
    ;

bool sol_json_path_get_next_segment(struct sol_json_path_scanner *scanner, struct sol_str_slice *slice, enum sol_json_loop_status *status)
#ifndef DOXYGEN_RUN
    SOL_ATTR_NON_NULL(1, 2, 3)
#endif
    ;

int32_t sol_json_path_array_get_segment_index(struct sol_str_slice key);

static inline bool
sol_json_path_is_array_key(struct sol_str_slice slice)
{
    return slice.data && slice.len >= 2 &&
           slice.data[0] == '[' &&  //is between brackets or
           slice.data[1] != '\''; //index is not a string
}

#define SOL_JSON_PATH_FOREACH(scanner, key, status) \
    for (status = SOL_JSON_LOOP_REASON_OK; \
        sol_json_path_get_next_segment(&scanner, &key_slice, &status);)

#ifdef __cplusplus
}
#endif