dynamic_types.h

/**
 *  @file       dynamic_types.h
 *  @author     André Dietrich
 *  @date       9 April 2016
 *
 *  @copyright  Copyright 2016 André Dietrich. All rights reserved.
 *
 *  @license    This project is released under the MIT-License.
 *
 *  @brief      Definition of internal settings and applied data types.
 *
 *
 */

#include <stdint.h>

#ifndef DYNAMIC_TYPES_C_H
#define DYNAMIC_TYPES_C_H

/** @brief basic return type for truth values
 */
typedef enum {
    DYN_FALSE =  0, ///< represents boolean false
    DYN_TRUE  =  1, ///< represents boolean true
    DYN_NONE  = -1  ///< represents a third unknown state, which is not true or false
} trilean;

/** @brief Basic 8bit signed integer
 */
typedef char          dyn_char;
/** @brief Basic 8bit integer (0 - 255)
 */
typedef unsigned char dyn_byte;
/** @brief Standard dynamic C string
 */
typedef char*         dyn_str;
/** @brief Standard dynamic C const string
 */
typedef const char*   dyn_const_str;

/** @brief 16bit unsigned integer
 */
typedef uint16_t      dyn_ushort;
/** @brief 16bit signed integer
 */
typedef int16_t       dyn_short;
/** @brief 32bit signed integer, standard Integer type.
 */
typedef int32_t       dyn_int;
/** @brief 32bit unsigned integer
 */
typedef uint32_t      dyn_uint;
/** @brief basic float definition (32 bit)
 */
typedef float         dyn_float;

/**
 * @brief Basic data type definitions
 */
typedef enum {
    NONE,               ///< None type without any value
    BOOL,               ///< Boolean 0==False, 1==True
    BYTE,               ///< not used
    INTEGER,            ///< signed integer 32 bit
    FLOAT,              ///< float 32 bit
    STRING,             ///< char*
    LIST,               ///< list of type dyn_list
    SET,                ///< set of type dyn_list
    DICT,               ///< dictionary of type dyn_dict
//    TEMP,               ///< not used
    FUNCTION,           ///< function pointer of type dyn_fct
    EXTERN,             ///< void*
    REFERENCE,          ///< dyn_c* for internal usage only
    REFERENCE2,         ///< dyn_c*, explicite reference
    MISCELLANEOUS       ///< can be used for different purposes
} TYPE;

/** @brief common dynamic data type
 */
typedef struct dynamic dyn_c;
/** @brief common dynamic list data type
 */
typedef struct dynamic_list dyn_list;
/** @brief common dynamic dictionary data type
 */
typedef struct dynamic_dict dyn_dict;
/** @brief common dynamic procedure/bytecode data type
 */
typedef struct dynamic_function dyn_fct;

/**
 * @brief Basic container for dynamic data types.
 *
 * Basic container consisting of two parts, a union data for storing or
 * referencing to values. The type value contains enum TYPE in order to define
 * which value of data has to be used.
 */
struct dynamic {

    union {               /*@{*/
        dyn_char    b;    //!< boolean value
        dyn_int     i;    //!< basic integer
        dyn_float   f;    //!< float value
        dyn_str     str;  //!< pointer to character-array
        dyn_list*   list; //!< pointer to dynamic list
        dyn_dict*   dict; //!< pointer to dynamic dictionary
        dyn_fct*    fct;  //!< pointer to function
        const void* ex;   //!< external (pointer to everything)
        dyn_c*      ref;  //!< reference pointer to dynamic elements
                          /*@}*/
    } data;
    char type;            //!< type definition
} __attribute__ ((packed));

/**
 * @brief Basic container for lists.
 *
 * todo.
 */
struct dynamic_list {
     dyn_ushort length;      //!< elements in use
     dyn_ushort space;       //!< elements available
     dyn_c      *container;  //!< pointer to an array of dynamic elements
} __attribute__ ((packed));

/**
 * @brief Basic container for dictionaries.
 *
 * todo.
 */
struct dynamic_dict {
     dyn_str*   key;        //!< array to C strings used as identifiers
     dyn_c      value;      //!< dynamic element of type dyn_list
} __attribute__ ((packed));

/**
 * @brief Basic container/pointer to functions.
 *
 * todo.
 */
struct dynamic_function {
     dyn_ushort  type;      //!< 0 basic C-fct, 1 system C-fct, else procedure (length of bytecode)
     void*       ptr;       //!< pointer to function
     dyn_str     info;      //!< info string
} __attribute__ ((packed));


#endif // DYNAMIC_TYPES_C_H