KEValue.h

Go to the documentation of this file.

#ifndef KEVALUE_H
#define KEVALUE_H

#include <Coconut/Coconut.h>
#include "KEForwarders.h"

typedef enum {
    KENilValue,
    KEBooleanValue,
    KESignedIntegerValue,
    KEUnsignedIntegerValue,
    KEFloatValue,
    KEStringValue,
    KEObjectValue
} KEValueType ;

static inline CNBoolean
KEIsObjectValueType(KEValueType type)
{
    return type >= KEStringValue ;
}

struct KEValue {
    KEValueType             type ;
    union {
        CNBoolean           booleanValue ;
        int64_t             intValue ;
        uint64_t            uIntValue ;
        double              floatValue ;
        struct CNString *       stringValue ;
        struct KEObject *       objectValue ;
    } ;
} ;

static inline void
KEInitValue(struct KEValue * dst)
{
    dst->type = KENilValue ;
}

static inline void
KEDestroyValue(struct KEValue * dst)
{
    if(KEIsObjectValueType(dst->type)){
        extern void KEDestroyObjectValue(struct KEValue *) ;
        KEDestroyObjectValue(dst) ;
    }
    dst->type = KENilValue ;
}

static inline KEValueType
KETypeOfValue(const struct KEValue * src)
{
    return src->type ;
}

static inline struct KEValue
KEMakeValue(const struct KEValue * src)
{
    struct KEValue newval ;
    if(KEIsObjectValueType(src->type)){
        extern struct KEValue KEMakeObjectValueBody(const struct KEValue * src) ;
        newval = KEMakeObjectValueBody(src) ;
    } else {
        newval = *src ;
    }
    return newval ;
}

static inline void
KEUpdateValue(struct KEValue * dst, const struct KEValue * src)
{
    struct KEValue newval = KEMakeValue(src) ;
    KEDestroyValue(dst) ;
    *dst = newval ;
}

static inline struct KEValue
KEMakeBooleanValue(CNBoolean src)
{
    struct KEValue val = {
        .type           = KEBooleanValue,
        .booleanValue   = src
    } ;
    return val ;
}

static inline void
KEUpdateBooleanValue(struct KEValue * dst, CNBoolean src)
{
    KEDestroyValue(dst) ;
    *dst = KEMakeBooleanValue(src) ;
}

static inline struct KEValue
KEMakeSignedIntegerValue(int64_t src)
{
    struct KEValue val = {
        .type       = KESignedIntegerValue,
        .intValue   = src
    } ;
    return val ;
}

static inline void
KEUpdateSignedIntegerValue(struct KEValue * dst, int64_t src)
{
    KEDestroyValue(dst) ;
    *dst = KEMakeSignedIntegerValue(src) ;
}

static inline struct KEValue
KEMakeUnsignedIntegerValue(uint64_t src)
{
    struct KEValue val = {
        .type       = KEUnsignedIntegerValue,
        .uIntValue  = src
    } ;
    return val ;
}

static inline void
KEUpdateUnsignedIntegerValue(struct KEValue * dst, uint64_t src)
{
    KEDestroyValue(dst) ;
    *dst = KEMakeUnsignedIntegerValue(src) ;
}

static inline struct KEValue
KEMakeFloatValue(double src)
{
    struct KEValue val = {
        .type       = KEFloatValue,
        .floatValue = src
    } ;
    return val ;
}

static inline void
KEUpdateFloatValue(struct KEValue * dst, double src)
{
    KEDestroyValue(dst) ;
    *dst = KEMakeFloatValue(src) ;
}

static inline struct KEValue
KEMakeStringValue(struct CNString * src)
{
    struct KEValue val = {
        .type           = KEStringValue,
        .stringValue    = src
    } ;
    CNRetainString(val.stringValue) ;
    return val ;
}

static inline void
KEUpdateStringValue(struct KEValue * dst, struct CNString * src)
{
    CNRetainString(src) ;
    KEDestroyValue(dst) ;
    dst->type       = KEStringValue ;
    dst->stringValue    = src ;
}

struct KEFrame *
KEFrameInValue(const struct KEValue * src) ;

static inline CNBoolean
KEIsFrameValue(const struct KEValue * src)
{
    return KEFrameInValue(src) != NULL ;
}

struct KEValue
KEMakeFrameValue(struct KEFrame * src) ;

void
KEUpdateFrameValue(struct KEValue * dst, struct KEFrame * src) ;

struct KEArray *
KEArrayInValue(const struct KEValue * src) ;

static inline CNBoolean
KEIsArrayValue(const struct KEValue * src)
{
    return KEArrayInValue(src) != NULL ;
}

struct KEValue
KEMakeArrayValue(struct KEArray * src) ;

void
KEUpdateArrayValue(struct KEValue * dst, struct KEArray * src) ;

struct KEDictionary *
KEDictionaryInValue(const struct KEValue * src) ;

static inline CNBoolean
KEIsDictionaryValue(const struct KEValue * src)
{
    return KEDictionaryInValue(src) != NULL ;
}

struct KEValue
KEMakeDictionaryValue(struct KEDictionary * src) ;

void
KEUpdateDictionaryValue(struct KEValue * dst, struct KEDictionary * src) ;

struct KEPath *
KEPathInValue(const struct KEValue * src) ;

static inline CNBoolean
KEIsPathValue(const struct KEValue * src)
{
    return KEPathInValue(src) != NULL ;
}

struct KEValue
KEMakePathValue(struct KEPath * src) ;

void
KEUpdatePathValue(struct KEValue * dst, struct KEPath * src) ;

struct KEFunction *
KEFunctionInValue(const struct KEValue * src) ;

static inline CNBoolean
KEIsFunctionValue(const struct KEValue * src)
{
    return KEFunctionInValue(src) != NULL ;
}

struct KEValue
KEMakeFunctionValue(struct KEFunction * src) ;

void
KEUpdateFunctionValue(struct KEValue * dst, struct KEFunction * src) ;

struct KEBuiltinFunc *
KEBuiltinFuncInValue(const struct KEValue * src) ;

static inline CNBoolean
KEIsBuiltinFuncValue(const struct KEValue * src)
{
    return KEBuiltinFuncInValue(src) != NULL ;
}

struct KEValue
KEMakeBuiltinFuncValue(struct KEBuiltinFunc * src) ;

void
KEUpdateBuiltinFuncValue(struct KEValue * dst, struct KEBuiltinFunc * src) ;

static inline CNBoolean
KEHasValidValue(struct KEValue * src)
{
    return KETypeOfValue(src) != KENilValue ;
}

const char *
KEStringOfValueType(struct KEValue * src) ;

void
KEDumpValue(struct CNText * outbuf, const struct KEValue * src) ;

#endif  /* KEVALUE_H */