ujson_reader.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later
/*
 * Copyright (C) 2021-2024 Cyril Hrubis <metan@ucw.cz>
 */
 
#ifndef UJSON_READER_H
#define UJSON_READER_H
 
#include <stdio.h>
#include <ujson_common.h>
 
#define UJSON_READER_INIT(buf, buf_len, rflags) { \
        .max_depth = UJSON_RECURSION_MAX, \
        .err_print = UJSON_ERR_PRINT, \
        .err_print_priv = UJSON_ERR_PRINT_PRIV, \
        .json = buf, \
        .len = buf_len, \
        .flags = rflags \
}
 
enum ujson_reader_flags {
        UJSON_READER_STRICT = 0x01,
};
 
struct ujson_reader {
        const char *json;
        size_t len;
        size_t off;
        size_t sub_off;
        unsigned int depth;
        unsigned int max_depth;
 
        enum ujson_reader_flags flags;
 
        void (*err_print)(void *err_print_priv, const char *line);
        void *err_print_priv;
 
        char err[UJSON_ERR_MAX];
        char buf[];
};
 
#define UJSON_VAL_INIT(sbuf, sbuf_size) { \
        .buf = sbuf, \
        .buf_size = sbuf_size, \
}
 
struct ujson_val {
        enum ujson_type type;
 
        char *buf;
        size_t buf_size;
 
        size_t idx;
 
        union {
                int val_bool;
                long long val_int;
                const char *val_str;
        };
 
        double val_float;
 
        char id[UJSON_ID_MAX];
 
        char buf__[];
};
 
ujson_val *ujson_val_alloc(size_t buf_size);
 
void ujson_val_free(ujson_val *self);
 
static inline int ujson_val_valid(struct ujson_val *res)
{
        return !!res->type;
}
 
void ujson_err(ujson_reader *self, const char *fmt, ...)
               __attribute__((format(printf, 2, 3)));
 
void ujson_err_print(ujson_reader *self);
 
void ujson_warn(ujson_reader *self, const char *fmt, ...)
               __attribute__((format(printf, 2, 3)));
 
static inline int ujson_reader_err(ujson_reader *self)
{
        return !!self->err[0];
}
 
enum ujson_type ujson_next_type(ujson_reader *self);
 
enum ujson_type ujson_reader_start(ujson_reader *self);
 
int ujson_obj_first(ujson_reader *self, struct ujson_val *res);
 
int ujson_obj_next(ujson_reader *self, struct ujson_val *res);
 
#define UJSON_OBJ_FOREACH(self, res) \
        for (ujson_obj_first(self, res); ujson_val_valid(res); ujson_obj_next(self, res))
 
size_t ujson_lookup(const void *arr, size_t memb_size, size_t list_len,
                    const char *key);
 
typedef struct ujson_obj_attr {
        const char *key;
        enum ujson_type type;
} ujson_obj_attr;
 
typedef struct ujson_obj {
        const ujson_obj_attr *attrs;
        size_t attr_cnt;
} ujson_obj;
 
static inline size_t ujson_obj_lookup(const ujson_obj *obj, const char *key)
{
        return ujson_lookup(obj->attrs, sizeof(*obj->attrs), obj->attr_cnt, key);
}
 
#define UJSON_OBJ_ATTR(keyv, typev) \
        {.key = keyv, .type = typev}
 
#define UJSON_OBJ_ATTR_IDX(key_idx, keyv, typev) \
        [key_idx] = {.key = keyv, .type = typev}
 
int ujson_obj_first_filter(ujson_reader *self, struct ujson_val *res,
                           const struct ujson_obj *obj, const struct ujson_obj *ign);
 
extern const struct ujson_obj *ujson_empty_obj;
 
int ujson_obj_next_filter(ujson_reader *self, struct ujson_val *res,
                          const struct ujson_obj *obj, const struct ujson_obj *ign);
 
#define UJSON_OBJ_FOREACH_FILTER(self, res, obj, ign) \
        for (ujson_obj_first_filter(self, res, obj, ign); \
             ujson_val_valid(res); \
             ujson_obj_next_filter(self, res, obj, ign))
 
int ujson_obj_skip(ujson_reader *self);
 
int ujson_arr_first(ujson_reader *self, struct ujson_val *res);
 
int ujson_arr_next(ujson_reader *self, struct ujson_val *res);
 
#define UJSON_ARR_FOREACH(self, res) \
        for (ujson_arr_first(self, res); ujson_val_valid(res); ujson_arr_next(self, res))
 
int ujson_arr_skip(ujson_reader *self);
 
typedef struct ujson_reader_state {
        size_t off;
        unsigned int depth;
} ujson_reader_state;
 
static inline ujson_reader_state ujson_reader_state_save(ujson_reader *self)
{
        struct ujson_reader_state ret = {
                .off = self->sub_off,
                .depth = self->depth,
        };
 
        return ret;
}
 
static inline void ujson_reader_state_load(ujson_reader *self, ujson_reader_state state)
{
        if (ujson_reader_err(self))
                return;
 
        self->off = state.off;
        self->sub_off = state.off;
        self->depth = state.depth;
}
 
static inline void ujson_reader_reset(ujson_reader *self)
{
        self->off = 0;
        self->sub_off = 0;
        self->depth = 0;
        self->err[0] = 0;
}
 
ujson_reader *ujson_reader_load(const char *path);
 
void ujson_reader_free(ujson_reader *self);
 
void ujson_reader_finish(ujson_reader *self);
 
static inline int ujson_reader_consumed(ujson_reader *self)
{
        return self->off >= self->len;
}
 
#endif /* UJSON_H */