rz_cf_dict.h File Reference

Go to the source code of this file.

Classes
struct	_CFValue
struct	_CFKeyValue
struct	_CFValueDict
struct	_CFValueArray
struct	_CFValueString
struct	_CFValueInteger
struct	_CFValueData
struct	_CFValueBool
struct	_CFValueNULL

Macros
#define	RZ_CF_OPTION_NONE   0
#define	RZ_CF_OPTION_SKIP_NSDATA   1

Typedefs
typedef struct _CFValue	RCFValue
typedef struct _CFKeyValue	RCFKeyValue
typedef struct _CFValueDict	RCFValueDict
typedef struct _CFValueArray	RCFValueArray
typedef struct _CFValueString	RCFValueString
typedef struct _CFValueInteger	RCFValueInteger
typedef struct _CFValueData	RCFValueData
typedef struct _CFValueBool	RCFValueBool
typedef struct _CFValueNULL	RCFValueNULL

Enumerations
enum	RCFValueType {   RZ_CF_INVALID , RZ_CF_DICT , RZ_CF_ARRAY , RZ_CF_STRING ,   RZ_CF_INTEGER , RZ_CF_DATA , RZ_CF_NULL , RZ_CF_TRUE ,   RZ_CF_FALSE }

Functions
RZ_API RCFValueDict *	rz_cf_value_dict_parse (RzBuffer *file_buf, ut64 offset, ut64 size, int options)
RZ_API void	rz_cf_value_dict_free (RCFValueDict *dict)
RZ_API void	rz_cf_value_print (RCFValue *value)

Macro Definition Documentation

RZ_CF_OPTION_NONE

#define RZ_CF_OPTION_NONE   0

Definition at line 7 of file rz_cf_dict.h.

RZ_CF_OPTION_SKIP_NSDATA

#define RZ_CF_OPTION_SKIP_NSDATA   1

Definition at line 8 of file rz_cf_dict.h.

Typedef Documentation

RCFKeyValue

typedef struct _CFKeyValue RCFKeyValue

RCFValue

typedef struct _CFValue RCFValue

RCFValueArray

typedef struct _CFValueArray RCFValueArray

RCFValueBool

typedef struct _CFValueBool RCFValueBool

RCFValueData

typedef struct _CFValueData RCFValueData

RCFValueDict

typedef struct _CFValueDict RCFValueDict

RCFValueInteger

typedef struct _CFValueInteger RCFValueInteger

RCFValueNULL

typedef struct _CFValueNULL RCFValueNULL

RCFValueString

typedef struct _CFValueString RCFValueString

Enumeration Type Documentation

RCFValueType

enum RCFValueType

Enumerator
RZ_CF_INVALID
RZ_CF_DICT
RZ_CF_ARRAY
RZ_CF_STRING
RZ_CF_INTEGER
RZ_CF_DATA
RZ_CF_NULL
RZ_CF_TRUE
RZ_CF_FALSE

Definition at line 10 of file rz_cf_dict.h.

             {
    RZ_CF_INVALID,
    RZ_CF_DICT,
    RZ_CF_ARRAY,
    RZ_CF_STRING,
    RZ_CF_INTEGER,
    RZ_CF_DATA,
    RZ_CF_NULL,
    RZ_CF_TRUE,
    RZ_CF_FALSE
} RCFValueType;

Function Documentation

rz_cf_value_dict_free()

RZ_API void rz_cf_value_dict_free

(

RCFValueDict *

dict

)

Definition at line 352 of file rz_cf_dict.c.

                                                      {
    rz_return_if_fail(dict);
 
    if (dict->pairs) {
        rz_list_free(dict->pairs);
        dict->pairs = NULL;
    }
    dict->type = RZ_CF_INVALID;
    RZ_FREE(dict);
}

References NULL, _CFValueDict::pairs, RZ_CF_INVALID, RZ_FREE, rz_list_free(), rz_return_if_fail, and _CFValueDict::type.

Referenced by rz_cf_value_free(), and rz_kernel_cache_free().

rz_cf_value_dict_parse()

RZ_API RCFValueDict* rz_cf_value_dict_parse	(	RzBuffer *	file_buf,
		ut64	offset,
		ut64	size,
		int	options
	)

Definition at line 68 of file rz_cf_dict.c.

                                                                                                     {
    RCFValueDict *result = NULL;
    yxml_t x;
    int i, depth = 0;
    char *content = NULL;
 
    void *xml_buf = malloc(XMLBUFSIZE);
    if (!xml_buf) {
        return NULL;
    }
 
    yxml_init(&x, xml_buf, XMLBUFSIZE);
 
    RzList *stack = rz_list_newf((RzListFree)&rz_cf_parse_state_free);
    if (!stack) {
        goto beach;
    }
 
    rz_list_push(stack, rz_cf_parse_state_new(RZ_CF_STATE_ROOT));
 
    for (i = 0; i < size; i++) {
        ut8 doc = 0;
        rz_buf_read_at(file_buf, offset + i, &doc, 1);
        if (!doc) {
            break;
        }
 
        yxml_ret_t r = yxml_parse(&x, doc);
        if (r < 0) {
            RZ_LOG_ERROR("Parsing error at :%" PRIu32 ":%" PRIu64 " byte offset %" PRIu64 "\n",
                x.line, x.byte, x.total);
            goto beach;
        }
 
        switch (r) {
        case YXML_ELEMSTART: {
            RCFParseState *state = (RCFParseState *)rz_list_get_top(stack);
            RCFParseState *next_state = NULL;
 
            if (!strcmp(x.elem, "dict")) {
                next_state = rz_cf_parse_state_new(RZ_CF_STATE_IN_DICT);
                if (!next_state) {
                    goto beach;
                }
                next_state->dict = rz_cf_value_dict_new();
            } else if (!strcmp(x.elem, "array")) {
                next_state = rz_cf_parse_state_new(RZ_CF_STATE_IN_ARRAY);
                if (!next_state) {
                    goto beach;
                }
                next_state->array = rz_cf_value_array_new();
            } else if (!strcmp(x.elem, "key") && state->phase == RZ_CF_STATE_IN_DICT) {
                next_state = rz_cf_parse_state_new(RZ_CF_STATE_IN_KEY);
                if (!next_state) {
                    goto beach;
                }
                next_state->dict = state->dict;
            } else if (!strcmp(x.elem, "string")) {
                next_state = rz_cf_parse_state_new(RZ_CF_STATE_IN_SCALAR);
                if (!next_state) {
                    goto beach;
                }
                next_state->value_type = RZ_CF_STRING;
            } else if (!strcmp(x.elem, "integer")) {
                next_state = rz_cf_parse_state_new(RZ_CF_STATE_IN_SCALAR);
                if (!next_state) {
                    goto beach;
                }
                next_state->value_type = RZ_CF_INTEGER;
            } else if (!strcmp(x.elem, "data")) {
                if (options & RZ_CF_OPTION_SKIP_NSDATA) {
                    next_state = rz_cf_parse_state_new(RZ_CF_STATE_IN_IGNORE);
                } else {
                    next_state = rz_cf_parse_state_new(RZ_CF_STATE_IN_SCALAR);
                    if (!next_state) {
                        goto beach;
                    }
                    next_state->value_type = RZ_CF_DATA;
                }
            } else if (!strcmp(x.elem, "true")) {
                next_state = rz_cf_parse_state_new(RZ_CF_STATE_IN_SCALAR);
                if (!next_state) {
                    goto beach;
                }
                next_state->value_type = RZ_CF_TRUE;
            } else if (!strcmp(x.elem, "false")) {
                next_state = rz_cf_parse_state_new(RZ_CF_STATE_IN_SCALAR);
                if (!next_state) {
                    goto beach;
                }
                next_state->value_type = RZ_CF_FALSE;
            }
 
            if (next_state) {
                rz_list_push(stack, next_state);
            } else {
                RZ_LOG_ERROR("Missing next state for elem: %s phase: %d\n", x.elem, state->phase);
                break;
            }
            depth++;
 
            break;
        }
        case YXML_ELEMEND: {
            RCFParseState *state = (RCFParseState *)rz_list_pop(stack);
            RCFParseState *next_state = (RCFParseState *)rz_list_get_top(stack);
            if (!state || !next_state) {
                goto beach;
            }
 
            if (next_state->phase == RZ_CF_STATE_ROOT) {
                if (state->phase == RZ_CF_STATE_IN_DICT) {
                    result = state->dict;
                    rz_cf_parse_state_free(state);
                    break;
                } else {
                    RZ_LOG_ERROR("Root element is not a dict\n");
                    goto beach;
                }
            }
 
            if (next_state->phase == RZ_CF_STATE_IN_DICT && state->phase == RZ_CF_STATE_IN_KEY) {
                if (!content) {
                    RZ_LOG_ERROR("NULL key is not supported");
                    goto beach;
                }
                next_state->key = content;
            }
 
            if (state->phase != RZ_CF_STATE_IN_KEY) {
                RCFValue *value = NULL;
 
                switch (state->phase) {
                case RZ_CF_STATE_IN_DICT:
                    value = (RCFValue *)state->dict;
                    break;
                case RZ_CF_STATE_IN_ARRAY:
                    value = (RCFValue *)state->array;
                    break;
                case RZ_CF_STATE_IN_SCALAR:
                    if (!content && state->value_type != RZ_CF_FALSE && state->value_type != RZ_CF_TRUE) {
                        value = (RCFValue *)rz_cf_value_null_new();
                    } else {
                        switch (state->value_type) {
                        case RZ_CF_STRING:
                            value = (RCFValue *)rz_cf_value_string_new(content);
                            break;
                        case RZ_CF_INTEGER:
                            value = (RCFValue *)rz_cf_value_integer_new(content);
                            RZ_FREE(content);
                            break;
                        case RZ_CF_DATA:
                            value = (RCFValue *)rz_cf_value_data_new(content);
                            RZ_FREE(content);
                            break;
                        case RZ_CF_TRUE:
                            value = (RCFValue *)rz_cf_value_bool_new(true);
                            break;
                        case RZ_CF_FALSE:
                            value = (RCFValue *)rz_cf_value_bool_new(false);
                            break;
                        default:
                            break;
                        }
                    }
                    break;
                default:
                    break;
                }
 
                if (next_state->phase == RZ_CF_STATE_IN_DICT) {
                    if (value) {
                        RCFKeyValue *key_value = rz_cf_key_value_new(next_state->key, value);
                        rz_cf_value_dict_add(next_state->dict, key_value);
                    } else if (state->phase != RZ_CF_STATE_IN_IGNORE) {
                        RZ_LOG_ERROR("Missing value for key %s\n", next_state->key);
                        rz_cf_value_free((RCFValue *)value);
                        goto beach;
                    }
                } else if (next_state->phase == RZ_CF_STATE_IN_ARRAY) {
                    if (value) {
                        rz_cf_value_array_add(next_state->array, value);
                    } else if (state->phase != RZ_CF_STATE_IN_IGNORE) {
                        RZ_LOG_ERROR("Missing value for array\n");
                        rz_cf_value_free((RCFValue *)value);
                        goto beach;
                    }
                }
            }
 
            depth--;
            content = NULL;
            rz_cf_parse_state_free(state);
            break;
        }
        case YXML_CONTENT: {
            RCFParseState *state = (RCFParseState *)rz_list_get_top(stack);
            if (state->phase == RZ_CF_STATE_IN_IGNORE) {
                break;
            }
            if (!content) {
                content = rz_str_new(x.data);
            } else {
                content = rz_str_append(content, x.data);
            }
            break;
        }
        default:
            break;
        }
 
        if (result) {
            break;
        }
    }
 
    yxml_ret_t r = yxml_eof(&x);
    if (r < 0) {
        RZ_LOG_ERROR("Invalid xml\n");
    }
 
beach:
    RZ_FREE(xml_buf);
    if (stack) {
        rz_list_free(stack);
    }
 
    return result;
}

References _RCFParseState::array, _RCFParseState::dict, i, _RCFParseState::key, malloc(), NULL, options, _RCFParseState::phase, PRIu32, PRIu64, r, rz_buf_read_at(), RZ_CF_DATA, RZ_CF_FALSE, RZ_CF_INTEGER, rz_cf_key_value_new(), RZ_CF_OPTION_SKIP_NSDATA, rz_cf_parse_state_free(), rz_cf_parse_state_new(), RZ_CF_STATE_IN_ARRAY, RZ_CF_STATE_IN_DICT, RZ_CF_STATE_IN_IGNORE, RZ_CF_STATE_IN_KEY, RZ_CF_STATE_IN_SCALAR, RZ_CF_STATE_ROOT, RZ_CF_STRING, RZ_CF_TRUE, rz_cf_value_array_add(), rz_cf_value_array_new(), rz_cf_value_bool_new(), rz_cf_value_data_new(), rz_cf_value_dict_add(), rz_cf_value_dict_new(), rz_cf_value_free(), rz_cf_value_integer_new(), rz_cf_value_null_new(), rz_cf_value_string_new(), RZ_FREE, rz_list_free(), rz_list_get_top(), rz_list_newf(), rz_list_pop(), rz_list_push(), RZ_LOG_ERROR, rz_str_append(), rz_str_new(), value, _RCFParseState::value_type, x, XMLBUFSIZE, YXML_CONTENT, YXML_ELEMEND, YXML_ELEMSTART, yxml_eof(), yxml_init(), and yxml_parse().

rz_cf_value_print()

RZ_API void rz_cf_value_print

(

RCFValue *

value

)

Definition at line 613 of file rz_cf_dict.c.

                                               {
    if (!value) {
        return;
    }
 
    switch (value->type) {
    case RZ_CF_DICT:
        rz_cf_value_dict_print((RCFValueDict *)value);
        break;
    case RZ_CF_ARRAY:
        rz_cf_value_array_print((RCFValueArray *)value);
        break;
    case RZ_CF_STRING:
        rz_cf_value_string_print((RCFValueString *)value);
        break;
    case RZ_CF_INTEGER:
        rz_cf_value_integer_print((RCFValueInteger *)value);
        break;
    case RZ_CF_DATA:
        rz_cf_value_data_print((RCFValueData *)value);
        break;
    case RZ_CF_NULL:
        rz_cf_value_null_print((RCFValueNULL *)value);
        break;
    case RZ_CF_TRUE:
    case RZ_CF_FALSE:
        rz_cf_value_bool_print((RCFValueBool *)value);
        break;
    default:
        break;
    }
}

References RZ_CF_ARRAY, RZ_CF_DATA, RZ_CF_DICT, RZ_CF_FALSE, RZ_CF_INTEGER, RZ_CF_NULL, RZ_CF_STRING, RZ_CF_TRUE, rz_cf_value_array_print(), rz_cf_value_bool_print(), rz_cf_value_data_print(), rz_cf_value_dict_print(), rz_cf_value_integer_print(), rz_cf_value_null_print(), rz_cf_value_string_print(), and value.

Referenced by rz_cf_value_array_print(), and rz_cf_value_dict_print().