cfe_value.c

Go to the documentation of this file.

/* kate: indent-mode cstyle; tab-width 4; indent-width 4; */
#include "config.h"

#include "cfe_value.h"

#include <stdlib.h>
#include <string.h>

#define C_TYPE_FIELD(T) T##_value
#define C_TYPE_FIELD_DEF(T) T T##_value;
#define C_TYPE_FIELD_DEF2(T, F) T F;

#define getset(NAME, C_TYPE, CFE_TYPE) getset2(NAME, C_TYPE, C_TYPE_FIELD(C_TYPE), CFE_TYPE)
#define getset2(NAME, C_TYPE, FIELD, CFE_TYPE)  \
uint8_t cfe_value_set_##NAME (cfe_value_t *v, C_TYPE value) \
{ \
        cfe_value_empty(v); \
        v->type = CFE_TYPE; \
        v->value.FIELD = value; \
        return 1; \
} \
uint8_t cfe_value_get_##NAME (const cfe_value_t *v, C_TYPE *value) \
{ \
        if(!cfe_value_check_type(v, CFE_TYPE)) return 0; \
        *value = (C_TYPE)v->value.FIELD; \
        return 1; \
}

struct _cfe_value
{
        cfe_value_type_t type;
        union
        {
                C_TYPE_FIELD_DEF(uint8_t)
                C_TYPE_FIELD_DEF(int8_t)
                C_TYPE_FIELD_DEF(uint16_t)
                C_TYPE_FIELD_DEF(int16_t)
                C_TYPE_FIELD_DEF(uint32_t)
                C_TYPE_FIELD_DEF(int32_t)
                C_TYPE_FIELD_DEF(uint64_t)
                C_TYPE_FIELD_DEF(int64_t)
                C_TYPE_FIELD_DEF(float)
                C_TYPE_FIELD_DEF(double)
                C_TYPE_FIELD_DEF2(void *, pointer)
                C_TYPE_FIELD_DEF2(long double, ldouble)
                C_TYPE_FIELD_DEF2(char *, str)
                C_TYPE_FIELD_DEF2(signed char *, s_str)
                C_TYPE_FIELD_DEF2(unsigned char *, u_str)
        } value;
};

static void cfe_value_empty(cfe_value_t *v);

cfe_value_t *cfe_value_new(void)
{
        cfe_value_t *value = malloc(sizeof(struct _cfe_value));
        value->type = CFE_NIL;
        return value;
}

void cfe_value_free(cfe_value_t *v)
{
        cfe_value_empty(v);
        free(v);
}

getset(uint8, uint8_t, CFE_UINT8)
getset(int8, int8_t, CFE_INT8)
getset(uint16, uint16_t, CFE_UINT16)
getset(int16, int16_t, CFE_INT16)
getset(uint32, uint32_t, CFE_UINT32)
getset(int32, int32_t, CFE_INT32)
getset(uint64, uint64_t, CFE_UINT64)
getset(int64, int64_t, CFE_INT64)
getset2(signed_int, signed int, C_TYPE_FIELD(int32_t), CFE_INT32)
getset2(unsigned_int, unsigned int, C_TYPE_FIELD(uint32_t), CFE_UINT32)
getset2(signed_long, signed long, C_TYPE_FIELD(int64_t), CFE_INT64)
getset2(unsigned_long, unsigned long, C_TYPE_FIELD(uint64_t), CFE_UINT64)

getset2(schar, signed char, C_TYPE_FIELD(int8_t), CFE_INT8)
getset2(uchar, unsigned char, C_TYPE_FIELD(uint8_t), CFE_UINT8)

getset(boolean, int8_t, CFE_BOOLEAN)

getset(float, float, CFE_FLOAT)
getset(double, double, CFE_DOUBLE)
getset2(long_double, long double, ldouble, CFE_LDOUBLE)

getset2(pointer, void *, pointer, CFE_POINTER)

uint8_t cfe_value_get_string(const cfe_value_t *v, char **value)
{
        if(!cfe_value_check_type(v, CFE_STRING)) return 0;
        *value = v->value.str;
        return 1;
}

uint8_t cfe_value_set_string(cfe_value_t *v, char *value)
{
        cfe_value_empty(v);
        v->type = CFE_STRING;
        v->value.str = strdup(value);
        return 1;
}
/*
uint8_t cfe_value_get_signed_string(cfe_value_t *v, signed char **value)
{
        if(!cfe_value_check_type(v, CFE_U_STRING)) return 0;
        *value = (signed char *)v->value.s_str;
        return 1;
}

uint8_t cfe_value_set_signed_string(cfe_value_t *v, signed char *value)
{
        cfe_value_empty(v);
        v->type = CFE_S_STRING;
        v->value.s_str = strdup((const signed char *)value);
        return 1;
}

uint8_t cfe_value_get_unsigned_string(cfe_value_t *v, unsigned char **value)
{
        if(!cfe_value_check_type(v, CFE_U_STRING)) return 0;
        *value = (unsigned char *)v->value.u_str;
        return 1;
}

uint8_t cfe_value_set_unsigned_string(cfe_value_t *v, unsigned char *value)
{
        cfe_value_empty(v);
        v->type = CFE_U_STRING;
        v->value.u_str = strdup((const unsigned char *)value);
        return 1;
}
*/
uint8_t cfe_value_set_null(cfe_value_t *v)
{
        cfe_value_empty(v);
        v->type = CFE_NULL;
        v->value.pointer = NULL;
        return 1;
}

uint8_t cfe_value_is_null(const cfe_value_t *v)
{
        return cfe_value_check_type(v, CFE_NULL);
}

uint8_t cfe_value_is_nil(const cfe_value_t *v)
{
        return cfe_value_check_type(v, CFE_NIL);
}

inline uint8_t cfe_value_check_type(const cfe_value_t *v, cfe_value_type_t type)
{
        return (v->type == type);
}

cfe_value_type_t cfe_value_get_type(const cfe_value_t *v)
{
        return v->type;
}

static void cfe_value_empty(cfe_value_t *v)
{
        if(v->type == CFE_STRING) free(v->value.str);
        else if(v->type == CFE_S_STRING) free(v->value.s_str);
        else if(v->type == CFE_U_STRING) free(v->value.u_str);
        v->value.str = NULL;
        v->type = CFE_NIL;
}