rz_cf_dict.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <rz_util.h>
#include <rz_list.h>
#include <yxml.h>
#include "rz_cf_dict.h"

Go to the source code of this file.

Classes
struct	_RCFParseState

Macros
#define	XMLBUFSIZE   4096

Typedefs
typedef struct _RCFParseState	RCFParseState

Enumerations
enum	RCFParsePhase {   RZ_CF_STATE_ROOT , RZ_CF_STATE_IN_DICT , RZ_CF_STATE_IN_ARRAY , RZ_CF_STATE_IN_KEY ,   RZ_CF_STATE_IN_SCALAR , RZ_CF_STATE_IN_IGNORE }

Functions
static RCFParseState *	rz_cf_parse_state_new (RCFParsePhase phase)
static void	rz_cf_parse_state_free (RCFParseState *state)
static RCFKeyValue *	rz_cf_key_value_new (char *key, RCFValue *value)
static void	rz_cf_key_value_free (RCFKeyValue *key_value)
static RCFValueDict *	rz_cf_value_dict_new (void)
static void	rz_cf_value_dict_add (RCFValueDict *dict, RCFKeyValue *key_value)
static void	rz_cf_value_dict_print (RCFValueDict *dict)
static RCFValueArray *	rz_cf_value_array_new (void)
static void	rz_cf_value_array_free (RCFValueArray *array)
static void	rz_cf_value_array_add (RCFValueArray *array, RCFValue *value)
static void	rz_cf_value_array_print (RCFValueArray *dict)
static RCFValueString *	rz_cf_value_string_new (char *string)
static void	rz_cf_value_string_free (RCFValueString *string)
static void	rz_cf_value_string_print (RCFValueString *string)
static RCFValueInteger *	rz_cf_value_integer_new (char *string)
static void	rz_cf_value_integer_free (RCFValueInteger *integer)
static void	rz_cf_value_integer_print (RCFValueInteger *integer)
static RCFValueData *	rz_cf_value_data_new (char *string)
static void	rz_cf_value_data_free (RCFValueData *data)
static void	rz_cf_value_data_print (RCFValueData *data)
static RCFValueNULL *	rz_cf_value_null_new (void)
static void	rz_cf_value_null_free (RCFValueNULL *null)
static void	rz_cf_value_null_print (RCFValueNULL *null)
static RCFValueBool *	rz_cf_value_bool_new (bool value)
static void	rz_cf_value_bool_free (RCFValueBool *bool_value)
static void	rz_cf_value_bool_print (RCFValueBool *bool_value)
static void	rz_cf_value_free (RCFValue *value)
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

XMLBUFSIZE

#define XMLBUFSIZE   4096

Definition at line 12 of file rz_cf_dict.c.

Typedef Documentation

RCFParseState

typedef struct _RCFParseState RCFParseState

Enumeration Type Documentation

RCFParsePhase

enum RCFParsePhase

Enumerator
RZ_CF_STATE_ROOT
RZ_CF_STATE_IN_DICT
RZ_CF_STATE_IN_ARRAY
RZ_CF_STATE_IN_KEY
RZ_CF_STATE_IN_SCALAR
RZ_CF_STATE_IN_IGNORE

Definition at line 14 of file rz_cf_dict.c.

             {
    RZ_CF_STATE_ROOT,
    RZ_CF_STATE_IN_DICT,
    RZ_CF_STATE_IN_ARRAY,
    RZ_CF_STATE_IN_KEY,
    RZ_CF_STATE_IN_SCALAR,
    RZ_CF_STATE_IN_IGNORE,
} RCFParsePhase;

Function Documentation

rz_cf_key_value_free()

static void rz_cf_key_value_free ( RCFKeyValue *  key_value )

static

Definition at line 324 of file rz_cf_dict.c.

                                                         {
    if (!key_value) {
        return;
    }
 
    if (key_value->key) {
        RZ_FREE(key_value->key);
    }
    if (key_value->value) {
        rz_cf_value_free(key_value->value);
        key_value->value = NULL;
    }
 
    RZ_FREE(key_value);
}

References _CFKeyValue::key, NULL, rz_cf_value_free(), RZ_FREE, and _CFKeyValue::value.

Referenced by rz_cf_value_dict_new().

rz_cf_key_value_new()

static RCFKeyValue * rz_cf_key_value_new ( char *  key, RCFValue *  value  )

static

Definition at line 312 of file rz_cf_dict.c.

                                                                    {
    RCFKeyValue *key_value = RZ_NEW0(RCFKeyValue);
    if (!key_value) {
        return NULL;
    }
 
    key_value->key = key;
    key_value->value = value;
 
    return key_value;
}

References _CFKeyValue::key, key, NULL, RZ_NEW0, _CFKeyValue::value, and value.

Referenced by rz_cf_value_dict_parse().

rz_cf_parse_state_free()

static void rz_cf_parse_state_free ( RCFParseState *  state )

static

Definition at line 306 of file rz_cf_dict.c.

                                                         {
    if (state) {
        RZ_FREE(state);
    }
}

References RZ_FREE.

Referenced by rz_cf_value_dict_parse().

rz_cf_parse_state_new()

static RCFParseState * rz_cf_parse_state_new ( RCFParsePhase  phase )

static

Definition at line 298 of file rz_cf_dict.c.

                                                                 {
    RCFParseState *state = RZ_NEW0(RCFParseState);
    if (state) {
        state->phase = phase;
    }
    return state;
}

References RZ_NEW0.

Referenced by rz_cf_value_dict_parse().

rz_cf_value_array_add()

static void rz_cf_value_array_add ( RCFValueArray *  array, RCFValue *  value  )

static

Definition at line 413 of file rz_cf_dict.c.

                                                                         {
    if (!array || !array->values) {
        return;
    }
 
    rz_list_push(array->values, value);
}

References rz_list_push(), value, and _CFValueArray::values.

Referenced by rz_cf_value_dict_parse().

rz_cf_value_array_free()

static void rz_cf_value_array_free ( RCFValueArray *  array )

static

Definition at line 399 of file rz_cf_dict.c.

                                                         {
    if (!array) {
        return;
    }
 
    if (array->values) {
        rz_list_free(array->values);
        array->values = NULL;
    }
 
    array->type = RZ_CF_INVALID;
    RZ_FREE(array);
}

References NULL, RZ_CF_INVALID, RZ_FREE, rz_list_free(), _CFValueArray::type, and _CFValueArray::values.

Referenced by rz_cf_value_free().

rz_cf_value_array_new()

static RCFValueArray * rz_cf_value_array_new ( void  )

static

Definition at line 387 of file rz_cf_dict.c.

                                                  {
    RCFValueArray *array = RZ_NEW0(RCFValueArray);
    if (!array) {
        return NULL;
    }
 
    array->type = RZ_CF_ARRAY;
    array->values = rz_list_newf((RzListFree)&rz_cf_value_free);
 
    return array;
}

References NULL, RZ_CF_ARRAY, rz_cf_value_free(), rz_list_newf(), RZ_NEW0, _CFValueArray::type, and _CFValueArray::values.

Referenced by rz_cf_value_dict_parse().

rz_cf_value_array_print()

static void rz_cf_value_array_print ( RCFValueArray *  dict )

static

Definition at line 421 of file rz_cf_dict.c.

                                                          {
    RzListIter *iter;
    RCFValue *value;
    int length = rz_list_length(array->values);
    int i = 0;
    printf("[");
    rz_list_foreach (array->values, iter, value) {
        rz_cf_value_print(value);
        if (i++ < length - 1) {
            printf(",");
        }
    }
    printf("]");
}

References i, length, printf(), rz_cf_value_print(), rz_list_length(), value, and _CFValueArray::values.

Referenced by rz_cf_value_print().

rz_cf_value_bool_free()

static void rz_cf_value_bool_free ( RCFValueBool *  bool_value )

static

Definition at line 566 of file rz_cf_dict.c.

                                                            {
    if (bool_value) {
        bool_value->type = RZ_CF_INVALID;
        RZ_FREE(bool_value);
    }
}

References RZ_CF_INVALID, RZ_FREE, and _CFValueBool::type.

Referenced by rz_cf_value_free().

rz_cf_value_bool_new()

static RCFValueBool * rz_cf_value_bool_new ( bool  value )

static

Definition at line 556 of file rz_cf_dict.c.

                                                      {
    RCFValueBool *bool_value = RZ_NEW0(RCFValueBool);
    if (!bool_value) {
        return NULL;
    }
 
    bool_value->type = value ? RZ_CF_TRUE : RZ_CF_FALSE;
    return bool_value;
}

References NULL, RZ_CF_FALSE, RZ_CF_TRUE, RZ_NEW0, _CFValueBool::type, and value.

Referenced by rz_cf_value_dict_parse().

rz_cf_value_bool_print()

static void rz_cf_value_bool_print ( RCFValueBool *  bool_value )

static

Definition at line 573 of file rz_cf_dict.c.

                                                             {
    if (bool_value->type == RZ_CF_TRUE) {
        printf("true");
    } else {
        printf("false");
    }
}

References printf(), RZ_CF_TRUE, and _CFValueBool::type.

Referenced by rz_cf_value_print().

rz_cf_value_data_free()

static void rz_cf_value_data_free ( RCFValueData *  data )

static

Definition at line 514 of file rz_cf_dict.c.

                                                      {
    if (!data) {
        return;
    }
 
    data->type = RZ_CF_INVALID;
    if (data->value) {
        rz_buf_free(data->value);
        data->value = NULL;
    }
 
    RZ_FREE(data);
}

References NULL, rz_buf_free(), RZ_CF_INVALID, RZ_FREE, _CFValueData::type, and _CFValueData::value.

Referenced by rz_cf_value_free().

rz_cf_value_data_new()

static RCFValueData * rz_cf_value_data_new ( char *  string )

static

Definition at line 493 of file rz_cf_dict.c.

                                                        {
    RCFValueData *data = RZ_NEW0(RCFValueData);
    if (!data) {
        return NULL;
    }
 
    const int len = strlen(string);
    const int out_len = len / 4 * 3 + 1;
    ut8 *out = calloc(sizeof(ut8), out_len);
    if (!out) {
        RZ_FREE(data);
        return NULL;
    }
    rz_base64_decode(out, string, len);
 
    data->type = RZ_CF_DATA;
    data->value = rz_buf_new_with_pointers(out, out_len, true);
 
    return data;
}

References calloc(), len, NULL, out, rz_base64_decode(), rz_buf_new_with_pointers(), RZ_CF_DATA, RZ_FREE, RZ_NEW0, _CFValueData::type, and _CFValueData::value.

Referenced by rz_cf_value_dict_parse().

rz_cf_value_data_print()

static void rz_cf_value_data_print ( RCFValueData *  data )

static

Definition at line 528 of file rz_cf_dict.c.

                                                       {
    printf("\"...\"");
}

References printf().

Referenced by rz_cf_value_print().

rz_cf_value_dict_add()

static void rz_cf_value_dict_add ( RCFValueDict *  dict, RCFKeyValue *  key_value  )

static

Definition at line 363 of file rz_cf_dict.c.

                                                                             {
    if (!dict || !dict->pairs) {
        return;
    }
 
    rz_list_push(dict->pairs, key_value);
}

References _CFValueDict::pairs, and rz_list_push().

Referenced by rz_cf_value_dict_parse().

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_new()

static RCFValueDict * rz_cf_value_dict_new ( void  )

static

Definition at line 340 of file rz_cf_dict.c.

                                                {
    RCFValueDict *dict = RZ_NEW0(RCFValueDict);
    if (!dict) {
        return NULL;
    }
 
    dict->type = RZ_CF_DICT;
    dict->pairs = rz_list_newf((RzListFree)&rz_cf_key_value_free);
 
    return dict;
}

References NULL, _CFValueDict::pairs, RZ_CF_DICT, rz_cf_key_value_free(), rz_list_newf(), RZ_NEW0, and _CFValueDict::type.

Referenced by rz_cf_value_dict_parse().

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_dict_print()

static void rz_cf_value_dict_print ( RCFValueDict *  dict )

static

Definition at line 371 of file rz_cf_dict.c.

                                                       {
    RzListIter *iter;
    RCFKeyValue *key_value;
    int length = rz_list_length(dict->pairs);
    int i = 0;
    printf("{");
    rz_list_foreach (dict->pairs, iter, key_value) {
        printf("\"%s\":", key_value->key);
        rz_cf_value_print(key_value->value);
        if (i++ < length - 1) {
            printf(",");
        }
    }
    printf("}");
}

References i, _CFKeyValue::key, length, _CFValueDict::pairs, printf(), rz_cf_value_print(), rz_list_length(), and _CFKeyValue::value.

Referenced by rz_cf_value_print().

rz_cf_value_free()

static void rz_cf_value_free ( RCFValue *  value )

static

Definition at line 580 of file rz_cf_dict.c.

                                              {
    if (!value) {
        return;
    }
 
    switch (value->type) {
    case RZ_CF_DICT:
        rz_cf_value_dict_free((RCFValueDict *)value);
        break;
    case RZ_CF_ARRAY:
        rz_cf_value_array_free((RCFValueArray *)value);
        break;
    case RZ_CF_STRING:
        rz_cf_value_string_free((RCFValueString *)value);
        break;
    case RZ_CF_INTEGER:
        rz_cf_value_integer_free((RCFValueInteger *)value);
        break;
    case RZ_CF_DATA:
        rz_cf_value_data_free((RCFValueData *)value);
        break;
    case RZ_CF_NULL:
        rz_cf_value_null_free((RCFValueNULL *)value);
        break;
    case RZ_CF_TRUE:
    case RZ_CF_FALSE:
        rz_cf_value_bool_free((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_free(), rz_cf_value_bool_free(), rz_cf_value_data_free(), rz_cf_value_dict_free(), rz_cf_value_integer_free(), rz_cf_value_null_free(), rz_cf_value_string_free(), and value.

Referenced by rz_cf_key_value_free(), rz_cf_value_array_new(), and rz_cf_value_dict_parse().

rz_cf_value_integer_free()

static void rz_cf_value_integer_free ( RCFValueInteger *  integer )

static

Definition at line 480 of file rz_cf_dict.c.

                                                               {
    if (!integer) {
        return;
    }
 
    integer->type = RZ_CF_INVALID;
    RZ_FREE(integer);
}

References RZ_CF_INVALID, RZ_FREE, and _CFValueInteger::type.

Referenced by rz_cf_value_free().

rz_cf_value_integer_new()

static RCFValueInteger * rz_cf_value_integer_new ( char *  string )

static

Definition at line 468 of file rz_cf_dict.c.

                                                              {
    RCFValueInteger *integer = RZ_NEW0(RCFValueInteger);
    if (!integer) {
        return NULL;
    }
 
    integer->type = RZ_CF_INTEGER;
    integer->value = rz_num_get(NULL, string);
 
    return integer;
}

References NULL, RZ_CF_INTEGER, RZ_NEW0, rz_num_get(), _CFValueInteger::type, and _CFValueInteger::value.

Referenced by rz_cf_value_dict_parse().

rz_cf_value_integer_print()

static void rz_cf_value_integer_print ( RCFValueInteger *  integer )

static

Definition at line 489 of file rz_cf_dict.c.

                                                                {
    printf("%llu", integer->value);
}

References printf(), and _CFValueInteger::value.

Referenced by rz_cf_value_print().

rz_cf_value_null_free()

static void rz_cf_value_null_free ( RCFValueNULL *  null )

static

Definition at line 543 of file rz_cf_dict.c.

                                                      {
    if (!null) {
        return;
    }
 
    null->type = RZ_CF_INVALID;
    RZ_FREE(null);
}

References RZ_CF_INVALID, and RZ_FREE.

Referenced by rz_cf_value_free().

rz_cf_value_null_new()

static RCFValueNULL * rz_cf_value_null_new ( void  )

static

Definition at line 532 of file rz_cf_dict.c.

                                                {
    RCFValueNULL *null = RZ_NEW0(RCFValueNULL);
    if (!null) {
        return NULL;
    }
 
    null->type = RZ_CF_NULL;
 
    return null;
}

References NULL, RZ_CF_NULL, and RZ_NEW0.

Referenced by rz_cf_value_dict_parse().

rz_cf_value_null_print()

static void rz_cf_value_null_print ( RCFValueNULL *  null )

static

Definition at line 552 of file rz_cf_dict.c.

                                                       {
    printf("null");
}

References printf().

Referenced by rz_cf_value_print().

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().

rz_cf_value_string_free()

static void rz_cf_value_string_free ( RCFValueString *  string )

static

Definition at line 448 of file rz_cf_dict.c.

                                                            {
    if (!string) {
        return;
    }
 
    if (string->value) {
        RZ_FREE(string->value);
    }
 
    string->type = RZ_CF_INVALID;
    RZ_FREE(string);
}

References RZ_CF_INVALID, RZ_FREE, and _CFValueString::value.

Referenced by rz_cf_value_free().

rz_cf_value_string_new()

static RCFValueString * rz_cf_value_string_new ( char *  string )

static

Definition at line 436 of file rz_cf_dict.c.

                                                            {
    RCFValueString *value_string = RZ_NEW0(RCFValueString);
    if (!value_string) {
        return NULL;
    }
 
    value_string->type = RZ_CF_STRING;
    value_string->value = string;
 
    return value_string;
}

References NULL, RZ_CF_STRING, RZ_NEW0, _CFValueString::type, and _CFValueString::value.

Referenced by rz_cf_value_dict_parse().

rz_cf_value_string_print()

static void rz_cf_value_string_print ( RCFValueString *  string )

static

Definition at line 461 of file rz_cf_dict.c.

                                                             {
    char *escaped = strdup(string->value);
    escaped = rz_str_replace(escaped, "\"", "\\\"", 1);
    printf("\"%s\"", escaped);
    RZ_FREE(escaped);
}

References printf(), RZ_FREE, rz_str_replace(), strdup(), and _CFValueString::value.

Referenced by rz_cf_value_print().