dynamic.h

Go to the documentation of this file.

#ifndef DYN_C_H
#define DYN_C_H

#include <stdlib.h>

#include "dynamic_types.h"
#include "dynamic_defines.h"
#include "dynamic_string.h"
#include "dynamic_encoding.h"


#define   DYN_INIT(dyn)       (dyn)->type=NONE
#define   DYN_TYPE(dyn)       (dyn)->type
#define   DYN_IS_NONE(dyn)    !DYN_TYPE(dyn)
#define   DYN_NOT_NONE(dyn)   DYN_TYPE(dyn)
#define   DYN_IS_REFERENCE(dyn) \
          DYN_TYPE(dyn)==REFERENCE || DYN_TYPE(dyn)==REFERENCE2

TYPE       dyn_type            (const dyn_c* dyn);
void       dyn_free            (dyn_c* dyn);
trilean    dyn_copy            (const dyn_c* dyn,  dyn_c* copy);
void       dyn_move            (dyn_c* from, dyn_c* to);
#define    DYN_MOVE(from, to)  *to = *from; DYN_INIT(from)

dyn_ushort dyn_length          (const dyn_c* dyn);
dyn_uint   dyn_size            (const dyn_c* dyn);

void       dyn_set_none        (dyn_c* dyn);
void       dyn_set_bool        (dyn_c* dyn, const dyn_char  v);
void       dyn_set_int         (dyn_c* dyn, const dyn_int   v);
void       dyn_set_float       (dyn_c* dyn, const dyn_float v);
void       dyn_set_extern      (dyn_c* dyn, const void*     v);
trilean    dyn_set_string      (dyn_c* dyn, dyn_const_str   v);
void       dyn_set_ref         (dyn_c* ref, dyn_c* orig);

trilean    dyn_get_bool        (const dyn_c* dyn);
trilean    dyn_get_bool_3      (const dyn_c* dyn);
dyn_int    dyn_get_int         (const dyn_c* dyn);
dyn_float  dyn_get_float       (const dyn_c* dyn);
dyn_str    dyn_get_string      (const dyn_c* dyn);
const void* dyn_get_extern     (const dyn_c* dyn);
void       dyn_string_add      (const dyn_c* dyn, dyn_str string);
dyn_ushort dyn_string_len      (const dyn_c* dyn);
#define    DYN_SET_LIST(dyn)           dyn_set_list_len(dyn, LIST_DEFAULT)
#define    DYN_LIST_LEN(dyn)           (dyn)->data.list->length
#define    DYN_LIST_GET_REF(dyn,i)     &(dyn)->data.list->container[i]
#define    DYN_LIST_GET_END(dyn) \
           &(dyn)->data.list->container[DYN_LIST_LEN(dyn)-1]
#define    DYN_LIST_GET_REF_END(dyn,i) \
           &(dyn)->data.list->container[DYN_LIST_LEN(dyn)-i]

trilean    dyn_set_list_len    (dyn_c* dyn, dyn_ushort len);
dyn_c*     dyn_list_push       (dyn_c* list, const dyn_c* element);
dyn_c*     dyn_list_push_none  (dyn_c* list);
trilean    dyn_list_pop        (dyn_c* list, dyn_c* element);
trilean    dyn_list_get        (const dyn_c* list, dyn_c* element, const dyn_short i);
dyn_c*     dyn_list_get_ref    (const dyn_c* list, const dyn_short i);
trilean    dyn_list_popi       (dyn_c* list, const dyn_short i);
void       dyn_list_free       (dyn_c* list);
trilean    dyn_list_copy       (const dyn_c* list, dyn_c* copy);
trilean    dyn_list_remove     (dyn_c* list, dyn_ushort i);
trilean    dyn_list_insert     (dyn_c* list, dyn_c* element, const dyn_ushort i);
trilean    dyn_list_resize     (dyn_c* list, const dyn_ushort size);
dyn_ushort dyn_list_string_len (const dyn_c* list);
void       dyn_list_string_add (const dyn_c* list, dyn_str str);
#ifdef S2_SET
trilean    dyn_set_set_len     (dyn_c* set, const dyn_ushort len);
trilean    dyn_set_insert      (dyn_c* set, dyn_c* element);
// Delete element from a set
//dyn_char   dyn_set_remove      (dyn_c* set, dyn_c* element);
#endif

#define    DYN_DICT_LEN(dyn) \
           dyn->data.dict->value.data.list->length
#define    DYN_DICT_GET_I_REF(dyn,i) \
           &(dyn)->data.dict->value.data.list->container[i]
#define    DYN_DICT_GET_I_KEY(dyn,i)  (dyn)->data.dict->key[i]
#define    DYN_DICT_SPACE(dyn)         dyn->value.data.list->space
#define    DYN_DICT_LENGTH(dyn)        dyn->value.data.list->length

trilean    dyn_set_dict        (dyn_c* dyn,  const dyn_ushort length);
trilean    dyn_dict_change     (dyn_c* dict, const dyn_ushort i, const dyn_c *value);
dyn_c*     dyn_dict_insert     (dyn_c* dict, dyn_const_str key, dyn_c *value);
trilean    dyn_dict_remove     (dyn_c* dict, dyn_const_str key);
dyn_c*     dyn_dict_get        (const dyn_c* dict, dyn_const_str key);
trilean    dyn_dict_resize     (dyn_c* dict, const dyn_ushort size);

dyn_c*     dyn_dict_get_i_ref (const dyn_c* dict, const dyn_ushort i);
dyn_str    dyn_dict_get_i_key (const dyn_c* dict, const dyn_ushort i);

dyn_ushort dyn_dict_has_key   (const dyn_c* dict, dyn_const_str key);
void       dyn_dict_empty     (dyn_c* dict);
void       dyn_dict_free      (dyn_c* dict);
trilean    dyn_dict_copy      (const dyn_c* dict, dyn_c* copy);

dyn_ushort dyn_dict_string_len(const dyn_c* dict);
void       dyn_dict_string_add(const dyn_c* dict, dyn_str string);
#define   DYN_FCT_C     0
#define   DYN_FCT_SYS   1
#define   DYN_FCT_PROC  2

#define   DYN_FCT_GET_CODE(dyn)  dyn->data.fct->ptr

trilean   dyn_set_fct          (dyn_c* dyn, void *ptr, const dyn_ushort type, dyn_const_str info);
void      dyn_fct_free         (dyn_c* dyn);
trilean   dyn_fct_copy         (const dyn_c* dyn, dyn_c* copy);
trilean dyn_op_neg(dyn_c *dyn);
trilean dyn_op_add(dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_sub(dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_mul(dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_div(dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_mod(dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_pow(dyn_c *dyn1, dyn_c *dyn2);

trilean dyn_op_and(dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_or (dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_xor(dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_not(dyn_c *dyn);

trilean dyn_op_id (dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_eq (dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_ne (dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_lt (dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_le (dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_gt (dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_ge (dyn_c *dyn1, dyn_c *dyn2);

trilean dyn_op_in (dyn_c *element, dyn_c *container);

trilean dyn_op_b_not(dyn_c *dyn);
trilean dyn_op_b_and(dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_b_or (dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_b_xor(dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_b_shift_l(dyn_c *dyn1, dyn_c *dyn2);
trilean dyn_op_b_shift_r(dyn_c *dyn1, dyn_c *dyn2);
#endif //DYN_C_H