dynamic.c

Go to the documentation of this file.

#include "dynamic.h"
#include <stdio.h>


void dyn_free (dyn_c* dyn)
{
    switch (DYN_TYPE(dyn)) {
        case STRING:    free(dyn->data.str);
                        break;
#ifdef S2_SET
        case SET:
#endif
        case LIST:      dyn_list_free(dyn);
                        break;
        case DICT:      dyn_dict_free(dyn);
                        break;
        case FUNCTION:  dyn_fct_free(dyn);
    }
    dyn->type=NONE;
}

TYPE dyn_type (const dyn_c* dyn)
{
    return (TYPE)DYN_TYPE(dyn);
}

void dyn_set_none (dyn_c* dyn)
{
    dyn_free(dyn);
    dyn->data.i = 0;
}

void dyn_set_bool (dyn_c* dyn, const dyn_char v)
{
    dyn_free(dyn);
    dyn->type = BOOL;
    dyn->data.b = v;
}

void dyn_set_int (dyn_c* dyn, const dyn_int v)
{
    dyn_free(dyn);
    dyn->type = INTEGER;
    dyn->data.i = v;
}

void dyn_set_float (dyn_c* dyn, const dyn_float v)
{
    dyn_free(dyn);
    dyn->type = FLOAT;
    dyn->data.f = v;
}

void dyn_set_extern (dyn_c* dyn, const void * v)
{
    dyn_free(dyn);
    dyn->type = EXTERN;
    dyn->data.ex = v;
}

trilean dyn_set_string (dyn_c* dyn, dyn_const_str v)
{
    dyn_free(dyn);

    dyn->data.str = (dyn_str) malloc(dyn_strlen((dyn_str)v)+1);

    if (dyn->data.str) {
        dyn->type = STRING;
        dyn_strcpy(dyn->data.str, (dyn_str)v);
        return DYN_TRUE;
    }
    return DYN_FALSE;
}

void dyn_set_ref (dyn_c* ref, dyn_c* orig)
{
    dyn_free(ref);

    ref->type = REFERENCE;
    ref->data.ref = DYN_IS_REFERENCE(orig) ? orig->data.ref : orig;
}

dyn_uint dyn_size (const dyn_c* dyn)
{
    dyn_uint bytes = sizeof(dyn_c);

    dyn_ushort len, i = 0;

    switch (DYN_TYPE(dyn)) {
        case STRING:
            bytes += dyn_strlen(dyn->data.str)+1;
            break;
#ifdef S2_SET
        case SET:
#endif
        case LIST: {
            bytes += sizeof(dyn_list);

            len = dyn->data.list->space;
            for (; i<len; ++i)
                bytes += dyn_size( DYN_LIST_GET_REF(dyn, i) );

            break;
        }
        case DICT: {
            bytes += sizeof(dyn_dict);
            bytes += dyn_size(&dyn->data.dict->value);

            len = dyn->data.dict->value.data.list->space;
            for (; i<len; ++i) {
                if (dyn->data.dict->key[i])
                    bytes += dyn_strlen(dyn->data.dict->key[i]);
                bytes++;
            }

            break;
        }
        case FUNCTION: {
            bytes += sizeof(dyn_fct);
            bytes += dyn_strlen(dyn->data.fct->info) + 1;
            break;
        }
    }

    return bytes;
}

trilean dyn_get_bool (const dyn_c* dyn)
{
START:
    switch (DYN_TYPE(dyn)) {
        case BOOL:      return dyn->data.b ? DYN_TRUE : DYN_FALSE;
        case INTEGER:   return dyn->data.i ? DYN_TRUE : DYN_FALSE;
        case FLOAT:     return dyn->data.f ? DYN_TRUE : DYN_FALSE;

        case STRING:
#ifdef S2_SET
        case SET:
#endif
        case LIST:
        case DICT:
                        return dyn_length(dyn);// ? DYN_TRUE : DYN_FALSE;
        case REFERENCE2:
        case REFERENCE: dyn=dyn->data.ref;
                        goto START;
    }

    return DYN_FALSE;
}

dyn_int dyn_get_int (const dyn_c* dyn)
{
START:
    switch (DYN_TYPE(dyn)) {
        case BOOL:      return (dyn_int)dyn->data.b;
        case INTEGER:   return dyn->data.i;
        case FLOAT:     return (dyn_int)dyn->data.f;
        case REFERENCE2:
        case REFERENCE: dyn=dyn->data.ref;
                        goto START;
    }
    return DYN_FALSE;
}

dyn_float dyn_get_float (const dyn_c* dyn)
{
START:
    switch (DYN_TYPE(dyn)) {
        case BOOL:      return (dyn_float)dyn->data.b;
        case INTEGER:   return (dyn_float)dyn->data.i;
        case FLOAT:     return dyn->data.f;
        case REFERENCE2:
        case REFERENCE: dyn=dyn->data.ref;
                        goto START;
    }
    return 0.0/0.0; // Not a Number
}

const void* dyn_get_extern (const dyn_c* dyn)
{
    if (DYN_IS_REFERENCE(dyn))
        dyn = dyn->data.ref;

    if(DYN_TYPE(dyn) == EXTERN)
        return dyn->data.ex;

    return NULL;
}

dyn_str dyn_get_string (const dyn_c* dyn)
{
    if (DYN_IS_REFERENCE(dyn))
        dyn = dyn->data.ref;

    dyn_str string = (dyn_str) malloc(dyn_string_len(dyn) + 1);
    if (string) {
        string[0] = '\0';
        /*if (DYN_TYPE(dyn) == STRING)
            dyn_strcpy(string, dyn->data.str);
        else*/
        dyn_string_add(dyn, string);
    }

    return string;
}

void dyn_string_add (const dyn_c* dyn, dyn_str string)
{
START:
    switch (DYN_TYPE(dyn)) {
        case BOOL:
            dyn_strcat(string, dyn->data.b ? "1": "0");
            return;
        case INTEGER:
            dyn_itoa(&string[dyn_strlen(string)], dyn->data.i);
            return;
        case FLOAT:
            dyn_ftoa(&string[dyn_strlen(string)], dyn->data.f);
            return;
        case STRING:
            dyn_strcat(string, dyn->data.str);
            return;
        case EXTERN:
            dyn_strcat(string, "ex");
            return;
        case FUNCTION:
            dyn_strcat(string, "FCT");
            return;
        case LIST:
            dyn_list_string_add(dyn, string);
            return;
#ifdef S2_SET
        case SET: {
            dyn_uint i = dyn_strlen(string);
            dyn_list_string_add(dyn, string);
            string[i] = '{';
            string[dyn_strlen(string)-1] = '}';
            return;
        }
#endif
        case DICT:
            dyn_dict_string_add (dyn, string);
            return;
        case REFERENCE2:
        case REFERENCE:
            dyn=dyn->data.ref;
            goto START;
        case MISCELLANEOUS:
            dyn_strcat(string, "$");
    }
}

dyn_ushort dyn_string_len (const dyn_c* dyn)
{
START:
    switch (DYN_TYPE(dyn)) {
        case REFERENCE2:
        case REFERENCE: dyn=dyn->data.ref;
                        goto START;
        case MISCELLANEOUS:
        case BOOL:      return 1;
        case INTEGER:   return dyn_itoa_len(dyn->data.i);
        case FLOAT:     return dyn_ftoa_len(dyn->data.f);
        case EXTERN:    return 2;
        case FUNCTION:  return 3;
        case STRING:    return dyn_strlen(dyn->data.str);
#ifdef S2_SET
        case SET:
#endif
        case LIST:      return dyn_list_string_len(dyn);
        case DICT:      return dyn_dict_string_len(dyn);
    }
    return 0;
}

trilean dyn_copy (const dyn_c* dyn, dyn_c* copy)
{
    switch (DYN_TYPE(dyn)) {
        case STRING:    return dyn_set_string( copy, dyn->data.str );
        case LIST:      return dyn_list_copy ( dyn, copy );
#ifdef S2_SET
        case SET:       if ( !dyn_list_copy(dyn, copy) )
                            return DYN_FALSE;
                        copy->type = SET;
                        break;
#endif
        case DICT:      return dyn_dict_copy( dyn, copy );
        case FUNCTION:  return dyn_fct_copy  ( dyn, copy );
        case REFERENCE: return dyn_copy ( dyn->data.ref, copy );
        default: *copy = *dyn;
    }

    return DYN_TRUE;
}

void dyn_move (dyn_c* from, dyn_c* to)
{
    dyn_free(to);

    if (DYN_TYPE(from) == REFERENCE)
        dyn_copy(from->data.ref, to);
    else
        *to = *from;

    DYN_INIT(from);
}

dyn_ushort dyn_length (const dyn_c* dyn)
{
START:
    switch (DYN_TYPE(dyn)) {
        case STRING:    return dyn_strlen(dyn->data.str);
#ifdef S2_SET
        case SET:
#endif
        case LIST:      return DYN_LIST_LEN(dyn);
        case DICT:      return DYN_DICT_LEN(dyn);
        case REFERENCE2:
        case REFERENCE: dyn=dyn->data.ref;
                        goto START;
    }

    return 0;
}