json_parser.c File Reference

#include <errno.h>
#include <rz_util/rz_utf8.h>
#include <rz_util/rz_hex.h>
#include <rz_util/rz_json.h>
#include <rz_util/rz_assert.h>
#include <rz_util/rz_pj.h>

Go to the source code of this file.

Macros
#define	RZ_JSON_REPORT_ERROR(msg, p)

Functions
static RzJson *	json_new (void)
static RzJson *	create_json (RzJsonType type, const char *key, RzJson *parent)
RZ_API void	rz_json_free (RzJson *js)
static char *	unescape_string (char *s, char **end)
static char *	skip_block_comment (char *ps)
static char *	skip_whitespace (char *p)
static char *	parse_key (const char **key, char *p)
static char *	parse_value (RzJson *parent, const char *key, char *p)
RZ_API RzJson *	rz_json_parse (char *text)
static const RzJson *	rz_json_get_len (const RzJson *json, const char *key, size_t keysize)
RZ_API const RzJson *	rz_json_get (const RzJson *json, const char *key)
RZ_API const RzJson *	rz_json_item (const RzJson *json, size_t idx)
RZ_API const RzJson *	rz_json_get_path (const RzJson *json, const char *path)
static void	json_pj_recurse (const RzJson *json, PJ *pj, bool with_key)
RZ_API RZ_OWN char *	rz_json_as_string (const RzJson *json, bool with_key)

Macro Definition Documentation

RZ_JSON_REPORT_ERROR

#define RZ_JSON_REPORT_ERROR	(		msg,
			p
	)

Value:

    do { \
        (void)(msg); \
        (void)(p); \
    } while (0)

Definition at line 17 of file json_parser.c.

Function Documentation

create_json()

static RzJson* create_json ( RzJsonType  type, const char *  key, RzJson *  parent  )

static

Definition at line 28 of file json_parser.c.

                                                                             {
    RzJson *js = json_new();
    if (!js) {
        return NULL;
    }
    js->type = type;
    js->key = key;
    if (!parent->children.last) {
        parent->children.first = parent->children.last = js;
    } else {
        parent->children.last->next = js;
        parent->children.last = js;
    }
    parent->children.count++;
    return js;
}

References rz_json_t::children, json_new(), rz_json_t::key, key, NULL, type, and rz_json_t::type.

Referenced by parse_value().

json_new()

static RzJson* json_new ( void  )

static

Definition at line 24 of file json_parser.c.

                              {
    return RZ_NEW0(RzJson);
}

References RZ_NEW0.

Referenced by create_json().

json_pj_recurse()

static void json_pj_recurse ( const RzJson *  json, PJ *  pj, bool  with_key  )

static

Definition at line 470 of file json_parser.c.

                                                                       {
    rz_return_if_fail(json && pj);
    switch (json->type) {
    case RZ_JSON_NULL: {
        if (with_key && json->key) {
            pj_knull(pj, json->key);
        } else {
            pj_null(pj);
        }
        break;
    }
    case RZ_JSON_OBJECT: {
        if (with_key && json->key) {
            pj_ko(pj, json->key);
        } else {
            pj_o(pj);
        }
        RzJson *baby;
        for (baby = json->children.first; baby; baby = baby->next) {
            // Always print keys for children
            json_pj_recurse(baby, pj, true);
        }
        pj_end(pj);
        break;
    }
    case RZ_JSON_ARRAY: {
        if (with_key && json->key) {
            pj_ka(pj, json->key);
        } else {
            pj_a(pj);
        }
        RzJson *baby;
        for (baby = json->children.first; baby; baby = baby->next) {
            // Always print keys for children
            json_pj_recurse(baby, pj, true);
        }
        pj_end(pj);
        break;
    }
    case RZ_JSON_STRING: {
        if (with_key && json->key) {
            pj_ks(pj, json->key, json->str_value);
        } else {
            pj_s(pj, json->str_value);
        }
        break;
    }
    case RZ_JSON_INTEGER: {
        if (with_key && json->key) {
            pj_kN(pj, json->key, json->num.u_value);
        } else {
            pj_N(pj, json->num.u_value);
        }
        break;
    }
    case RZ_JSON_DOUBLE: {
        if (with_key && json->key) {
            pj_kd(pj, json->key, json->num.dbl_value);
        } else {
            pj_d(pj, json->num.dbl_value);
        }
        break;
    }
    case RZ_JSON_BOOLEAN: {
        if (with_key && json->key) {
            pj_kb(pj, json->key, (bool)json->num.u_value);
        } else {
            pj_b(pj, (bool)json->num.u_value);
        }
    }
    }
}

References rz_json_t::children, rz_json_t::key, rz_json_t::next, rz_json_t::num, pj_a(), pj_b(), pj_d(), pj_end(), pj_ka(), pj_kb(), pj_kd(), pj_kN(), pj_knull(), pj_ko(), pj_ks(), pj_N(), pj_null(), pj_o(), pj_s(), RZ_JSON_ARRAY, RZ_JSON_BOOLEAN, RZ_JSON_DOUBLE, RZ_JSON_INTEGER, RZ_JSON_NULL, RZ_JSON_OBJECT, RZ_JSON_STRING, rz_return_if_fail, rz_json_t::str_value, and rz_json_t::type.

Referenced by rz_json_as_string().

parse_key()

static char* parse_key ( const char **  key, char *  p  )

static

Definition at line 192 of file json_parser.c.

                                                  {
    // on '}' return with *p=='}'
    p = skip_whitespace(p);
    if (!p) {
        return NULL;
    }
    char c;
    while ((c = *p++)) {
        if (c == '"') {
            *key = unescape_string(p, &p);
            if (!*key) {
                return NULL; // propagate error
            }
            p = skip_whitespace(p);
            if (!p) {
                return NULL;
            }
            if (*p == ':') {
                return p + 1;
            }
            RZ_JSON_REPORT_ERROR("unexpected chars", p);
            return NULL;
        }
        if (c == '}') {
            return p - 1;
        }
        RZ_JSON_REPORT_ERROR("unexpected chars", p - 1);
        return NULL; // error
    }
    RZ_JSON_REPORT_ERROR("unexpected chars", p - 1);
    return NULL; // error
}

References c, key, NULL, p, RZ_JSON_REPORT_ERROR, skip_whitespace(), and unescape_string().

Referenced by parse_value().

parse_value()

static char* parse_value ( RzJson *  parent, const char *  key, char *  p  )

static

Definition at line 225 of file json_parser.c.

                                                                   {
    RzJson *js;
    p = skip_whitespace(p);
    if (!p) {
        return NULL;
    }
    switch (*p) {
    case '\0':
        RZ_JSON_REPORT_ERROR("unexpected end of text", p);
        return NULL; // error
    case '{':
        js = create_json(RZ_JSON_OBJECT, key, parent);
        p++;
        while (1) {
            const char *new_key = NULL;
            p = parse_key(&new_key, p);
            if (!p) {
                return NULL; // error
            }
            if (*p != '}') {
                p = parse_value(js, new_key, p);
                if (!p) {
                    return NULL; // error
                }
            }
            p = skip_whitespace(p);
            if (!p) {
                return NULL;
            }
            if (*p == ',') {
                char *commapos = p;
                p++;
                p = skip_whitespace(p);
                if (!p) {
                    return NULL;
                }
                if (*p == '}') {
                    RZ_JSON_REPORT_ERROR("trailing comma", commapos);
                    return NULL;
                }
            } else if (*p == '}') {
                return p + 1; // end of object
            } else {
                RZ_JSON_REPORT_ERROR("unexpected chars", p);
                return NULL;
            }
        }
    case '[':
        js = create_json(RZ_JSON_ARRAY, key, parent);
        p++;
        while (1) {
            p = parse_value(js, 0, p);
            if (!p) {
                return NULL; // error
            }
            p = skip_whitespace(p);
            if (!p) {
                return NULL;
            }
            if (*p == ',') {
                char *commapos = p;
                p++;
                p = skip_whitespace(p);
                if (!p) {
                    return NULL;
                }
                if (*p == ']') {
                    RZ_JSON_REPORT_ERROR("trailing comma", commapos);
                    return NULL;
                }
            } else if (*p == ']') {
                return p + 1; // end of array
            } else {
                RZ_JSON_REPORT_ERROR("unexpected chars", p);
                return NULL;
            }
        }
    case ']':
        return p;
    case '"':
        p++;
        js = create_json(RZ_JSON_STRING, key, parent);
        js->str_value = unescape_string(p, &p);
        if (!js->str_value) {
            return NULL; // propagate error
        }
        return p;
    case '-':
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9': {
        js = create_json(RZ_JSON_INTEGER, key, parent);
        errno = 0;
        char *pe;
        if (*p == '-') {
            js->num.s_value = (st64)strtoll(p, &pe, 10);
        } else {
            js->num.u_value = (ut64)strtoull(p, &pe, 10);
        }
        if (pe == p || errno == ERANGE) {
            RZ_JSON_REPORT_ERROR("invalid number", p);
            return NULL; // error
        }
        if (*pe == '.' || *pe == 'e' || *pe == 'E') { // double value
            js->type = RZ_JSON_DOUBLE;
            errno = 0;
            js->num.dbl_value = strtod(p, &pe);
            if (pe == p || errno == ERANGE) {
                RZ_JSON_REPORT_ERROR("invalid fractional number", p);
                return NULL; // error
            }
        } else {
            if (*p == '-') {
                js->num.dbl_value = (double)js->num.s_value;
            } else {
                js->num.dbl_value = (double)js->num.u_value;
            }
        }
        return pe;
    }
    case 't':
        if (!strncmp(p, "true", 4)) {
            js = create_json(RZ_JSON_BOOLEAN, key, parent);
            js->num.u_value = 1;
            return p + 4;
        }
        RZ_JSON_REPORT_ERROR("unexpected chars", p);
        return NULL; // error
    case 'f':
        if (!strncmp(p, "false", 5)) {
            js = create_json(RZ_JSON_BOOLEAN, key, parent);
            js->num.u_value = 0;
            return p + 5;
        }
        RZ_JSON_REPORT_ERROR("unexpected chars", p);
        return NULL; // error
    case 'n':
        if (!strncmp(p, "null", 4)) {
            create_json(RZ_JSON_NULL, key, parent);
            return p + 4;
        }
        RZ_JSON_REPORT_ERROR("unexpected chars", p);
        return NULL; // error
    default:
        RZ_JSON_REPORT_ERROR("unexpected chars", p);
        return NULL; // error
    }
    return NULL;
}

References create_json(), ERANGE, key, NULL, rz_json_t::num, p, parse_key(), RZ_JSON_ARRAY, RZ_JSON_BOOLEAN, RZ_JSON_DOUBLE, RZ_JSON_INTEGER, RZ_JSON_NULL, RZ_JSON_OBJECT, RZ_JSON_REPORT_ERROR, RZ_JSON_STRING, skip_whitespace(), st64, rz_json_t::str_value, rz_json_t::type, unescape_string(), and ut64().

Referenced by rz_json_parse().

rz_json_as_string()

RZ_API RZ_OWN char* rz_json_as_string	(	const RzJson *	json,
		bool	with_key
	)

Definition at line 546 of file json_parser.c.

                                                                         {
    rz_return_val_if_fail(json, NULL);
    PJ *pj = pj_new();
    if (json->type == RZ_JSON_STRING) {
        if (with_key && json->key) {
            pj_ks(pj, json->key, json->str_value);
        } else {
            // Printing string without surrounding quotes
            pj_S(pj, json->str_value);
        }
    } else {
        json_pj_recurse(json, pj, with_key);
    }
    char *str = pj_drain(pj);
    return str;
}

References json_pj_recurse(), rz_json_t::key, NULL, pj_drain(), pj_ks(), pj_new(), pj_S(), RZ_JSON_STRING, rz_return_val_if_fail, cmd_descs_generate::str, rz_json_t::str_value, and rz_json_t::type.

Referenced by rz_cons_grepbuf().

rz_json_free()

RZ_API void rz_json_free

(

RzJson *

js

)

Definition at line 45 of file json_parser.c.

                                     {
    if (!js) {
        return;
    }
    if (js->type == RZ_JSON_OBJECT || js->type == RZ_JSON_ARRAY) {
        RzJson *p = js->children.first;
        RzJson *p1;
        while (p) {
            p1 = p->next;
            rz_json_free(p);
            p = p1;
        }
    }
    free(js);
}

References rz_json_t::children, free(), p, RZ_JSON_ARRAY, rz_json_free(), RZ_JSON_OBJECT, and rz_json_t::type.

Referenced by deserialize_checkpoints_cb(), deserialize_memory_cb(), deserialize_registers_cb(), meta_load_cb(), rz_json_free(), rz_json_parse(), rz_load_panels_layout(), rz_serialize_spaces_load(), winkd_download_module_and_pdb(), xrefs_load_cb(), and zone_load_cb().

rz_json_get()

RZ_API const RzJson* rz_json_get	(	const RzJson *	json,
		const char *	key
	)

Definition at line 405 of file json_parser.c.

                                                                      {
    return rz_json_get_len(json, key, strlen(key));
}

References key, and rz_json_get_len().

Referenced by deserialize_checkpoints_cb(), deserialize_memory_cb(), deserialize_registers_cb(), GetHeapGlobalsOffset(), rz_serialize_analysis_var_load(), winkd_download_module_and_pdb(), and xrefs_load_cb().

rz_json_get_len()

static const RzJson* rz_json_get_len ( const RzJson *  json, const char *  key, size_t  keysize  )

static

Definition at line 395 of file json_parser.c.

                                                                                          {
    RzJson *js;
    for (js = json->children.first; js; js = js->next) {
        if (js->key && !strncmp(js->key, key, keysize)) {
            return js;
        }
    }
    return NULL;
}

References rz_json_t::children, rz_json_t::key, key, rz_json_t::next, and NULL.

Referenced by rz_json_get(), and rz_json_get_path().

rz_json_get_path()

RZ_API const RzJson* rz_json_get_path	(	const RzJson *	json,
		const char *	path
	)

Definition at line 419 of file json_parser.c.

                                                                            {
    const RzJson *js = json;
    const char *key;
    size_t keysize;
    ut64 index;
 
    while (*path) {
        switch (*path++) {
        case '\0':
            break;
        case '[':
            // we could check if js->type != RZ_JSON_ARRAY but rz_json_item will
            // fail in that case anyway
            key = path;
            index = (ut64)strtoull(key, (char **)&path, 10);
            if (key == path || *path != ']') {
                RZ_JSON_REPORT_ERROR("JSON path: expected ]", path - 1);
                return NULL;
            }
            ++path;
            js = rz_json_item(js, index);
            if (!js) {
                return NULL;
            }
            break;
        case '.':
            key = path;
            for (keysize = 0; key[keysize]; ++keysize) {
                if (strchr(".[", key[keysize])) {
                    break;
                }
            }
            if (keysize == 0) {
                RZ_JSON_REPORT_ERROR("JSON path: expected key", path - 1);
                return NULL;
            }
            js = rz_json_get_len(js, key, keysize);
            if (!js) {
                return NULL;
            }
            path = key + keysize;
            break;
        default:
            RZ_JSON_REPORT_ERROR("JSON path: unexpected char", path - 1);
            return NULL;
        }
    }
    // js == json means we've not done any access at all
    return (js == json) ? NULL : js;
}

References key, NULL, path, rz_json_get_len(), rz_json_item(), RZ_JSON_REPORT_ERROR, and ut64().

Referenced by rz_cons_grepbuf().

rz_json_item()

RZ_API const RzJson* rz_json_item	(	const RzJson *	json,
		size_t	idx
	)

Definition at line 409 of file json_parser.c.

                                                                  {
    RzJson *js;
    for (js = json->children.first; js; js = js->next) {
        if (!idx--) {
            return js;
        }
    }
    return NULL;
}

References rz_json_t::children, setup::idx, rz_json_t::next, and NULL.

Referenced by rz_json_get_path().

rz_json_parse()

RZ_API RzJson* rz_json_parse

(

char *

text

)

Definition at line 382 of file json_parser.c.

                                         {
    RzJson js = { 0 };
    if (!parse_value(&js, 0, text)) {
        if (js.children.first) {
            rz_json_free(js.children.first);
        }
        return 0;
    }
    return js.children.first;
}

References rz_json_t::children, parse_value(), rz_json_free(), and create_tags_rz::text.

Referenced by block_load_cb(), bp_load_cb(), deserialize_checkpoints_cb(), deserialize_memory_cb(), deserialize_registers_cb(), flag_load_cb(), function_load_cb(), GetHeapGlobalsOffset(), global_var_load_cb(), hints_load_cb(), meta_load_cb(), rz_cons_grepbuf(), rz_load_panels_layout(), rz_serialize_spaces_load(), winkd_download_module_and_pdb(), xrefs_load_cb(), and zone_load_cb().

skip_block_comment()

static char* skip_block_comment ( char *  ps )

static

Definition at line 142 of file json_parser.c.

                                          {
    // ps is at "/* ..."
    // caller must ensure that ps[0], ps[1] and ps[2] are valid.
    char *p = ps + 2;
    if (!*p) {
        RZ_JSON_REPORT_ERROR("endless comment", ps);
        return NULL;
    }
REPEAT:
    p = strchr(p + 1, '/');
    if (!p) {
        RZ_JSON_REPORT_ERROR("endless comment", ps);
        return NULL;
    }
    if (p[-1] != '*') {
        goto REPEAT;
    }
    return p + 1;
}

References NULL, p, REPEAT, and RZ_JSON_REPORT_ERROR.

Referenced by skip_whitespace().

skip_whitespace()

static char* skip_whitespace ( char *  p )

static

Definition at line 162 of file json_parser.c.

                                      {
    while (*p) {
        if (*p == '/') {
            if (p[1] == '/') { // line comment
                char *ps = p;
                p = strchr(p + 2, '\n');
                if (!p) {
                    RZ_JSON_REPORT_ERROR("endless comment", ps);
                    return NULL; // error
                }
                p++;
            } else if (p[1] == '*') { // block comment
                p = skip_block_comment(p);
                if (!p) {
                    return NULL;
                }
                continue;
            } else {
                RZ_JSON_REPORT_ERROR("unexpected chars", p);
                return NULL; // error
            }
            continue;
        } else if (!IS_WHITECHAR(*p)) {
            break;
        }
        p++;
    }
    return p;
}

References IS_WHITECHAR, NULL, p, RZ_JSON_REPORT_ERROR, and skip_block_comment().

Referenced by parse_key(), and parse_value().

unescape_string()

static char* unescape_string ( char *  s, char **  end  )

static

Definition at line 61 of file json_parser.c.

                                                  {
    char *p = s;
    char *d = s;
    char c;
    while ((c = *p++)) {
        if (c == '"') {
            *d = '\0';
            *end = p;
            return s;
        }
        if (c == '\\') {
            switch (*p) {
            case '\\':
            case '/':
            case '"':
                *d++ = *p++;
                break;
            case 'b':
                *d++ = '\b';
                p++;
                break;
            case 'f':
                *d++ = '\f';
                p++;
                break;
            case 'n':
                *d++ = '\n';
                p++;
                break;
            case 'r':
                *d++ = '\r';
                p++;
                break;
            case 't':
                *d++ = '\t';
                p++;
                break;
            case 'u': { // unicode
                char *ps = p - 1;
                ut8 high = 0, low = 0;
                if (rz_hex_to_byte(&high, p[1]) || rz_hex_to_byte(&high, p[2]) || rz_hex_to_byte(&low, p[3]) || rz_hex_to_byte(&low, p[4])) {
                    RZ_JSON_REPORT_ERROR("invalid unicode escape", p - 1);
                    return NULL;
                }
                RzRune codepoint = (RzRune)high << 8 | (RzRune)low;
                if ((codepoint & 0xfc00) == 0xd800) { // high surrogate; need one more unicode to succeed
                    p += 6;
                    high = low = 0;
                    if (p[-1] != '\\' || *p != 'u' || rz_hex_to_byte(&high, p[1]) || rz_hex_to_byte(&high, p[2]) || rz_hex_to_byte(&low, p[3]) || rz_hex_to_byte(&low, p[4])) {
                        RZ_JSON_REPORT_ERROR("invalid unicode surrogate", ps);
                        return NULL;
                    }
                    RzRune codepoint2 = (RzRune)high << 8 | (RzRune)low;
                    if ((codepoint2 & 0xfc00) != 0xdc00) {
                        RZ_JSON_REPORT_ERROR("invalid unicode surrogate", ps);
                        return NULL;
                    }
                    codepoint = 0x10000 + ((codepoint - 0xd800) << 10) + (codepoint2 - 0xdc00);
                }
                int sz = rz_utf8_encode((ut8 *)d, codepoint);
                if (!s) {
                    RZ_JSON_REPORT_ERROR("invalid codepoint", ps);
                    return NULL;
                }
                d += sz;
                p += 5;
                break;
            }
            default:
                // leave untouched
                *d++ = c;
                break;
            }
        } else {
            *d++ = c;
        }
    }
    RZ_JSON_REPORT_ERROR("no closing quote for string", s);
    return NULL;
}

References c, d, test_evm::end, NULL, p, rz_hex_to_byte(), RZ_JSON_REPORT_ERROR, rz_utf8_encode(), and s.

Referenced by parse_key(), and parse_value().