vtorri
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Eo2: Updated naming Eo2->Eo.

This commit is contained in:
Tom Hacohen 2014-04-02 09:46:34 +01:00
parent 80faa56ed3
commit c32bb4fe95
44 changed files with 865 additions and 869 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

220
src/lib/eo/Eo.h
View File

@ -365,14 +365,14 @@ typedef enum _Eo_Class_Type Eo_Class_Type;
*/ */
#define EO_VERSION 2 #define EO_VERSION 2
typedef struct _Eo2_Op_Description typedef struct _Eo_Op_Description
{ {
void *api_func; /**< The EAPI function offering this op. */ void *api_func; /**< The EAPI function offering this op. */
void *func; /**< The static function to call for the op. */ void *func; /**< The static function to call for the op. */
Eo_Op op; /**< The op. */ Eo_Op op; /**< The op. */
Eo_Op_Type op_type; /**< The type of the Op. */ Eo_Op_Type op_type; /**< The type of the Op. */
const char *doc; /**< Explanation about the Op. */ const char *doc; /**< Explanation about the Op. */
} Eo2_Op_Description; } Eo_Op_Description;
/** /**
* @struct _Eo_Class_Description * @struct _Eo_Class_Description
@ -386,7 +386,7 @@ struct _Eo_Class_Description
const char *name; /**< The name of the class. */ const char *name; /**< The name of the class. */
Eo_Class_Type type; /**< The type of the class. */ Eo_Class_Type type; /**< The type of the class. */
struct { struct {
Eo2_Op_Description *descs2; Eo_Op_Description *descs2;
size_t count; size_t count;
} ops; /**< The ops description, should be filled using #EO_CLASS_DESCRIPTION_OPS */ } ops; /**< The ops description, should be filled using #EO_CLASS_DESCRIPTION_OPS */
const Eo_Event_Description **events; /**< The event descriptions for this class. */ const Eo_Event_Description **events; /**< The event descriptions for this class. */
@ -454,141 +454,137 @@ EAPI Eina_Bool eo_init(void);
*/ */
EAPI Eina_Bool eo_shutdown(void); EAPI Eina_Bool eo_shutdown(void);
/************************************ EO2 ************************************/ // computes size of Eo_Op_Description[]
#define EO_OP_DESC_SIZE(desc) (sizeof(desc)/sizeof(*desc) - 1)
#define EO2_VERSION EO_VERSION
// computes size of Eo2_Op_Description[]
#define EO2_OP_DESC_SIZE(desc) (sizeof(desc)/sizeof(*desc) - 1)
// Helpers macro to help populating #Eo_Class_Description. // Helpers macro to help populating #Eo_Class_Description.
#define EO2_CLASS_DESCRIPTION_NOOPS() { NULL, 0} #define EO_CLASS_DESCRIPTION_NOOPS() { NULL, 0}
#define EO2_CLASS_DESCRIPTION_OPS(op_descs) { op_descs, EO2_OP_DESC_SIZE(op_descs) } #define EO_CLASS_DESCRIPTION_OPS(op_descs) { op_descs, EO_OP_DESC_SIZE(op_descs) }
// to fetch internal function and object data at once // to fetch internal function and object data at once
typedef struct _Eo2_Op_Call_Data typedef struct _Eo_Op_Call_Data
{ {
Eo *obj; Eo *obj;
Eo_Class *klass; // remove this not necessary in Eo2_Hook_Call Eo_Class *klass; // remove this not necessary in Eo_Hook_Call
void *func; void *func;
void *data; void *data;
} Eo2_Op_Call_Data; } Eo_Op_Call_Data;
typedef void (*Eo2_Hook_Call)(const Eo_Class *klass_id, const Eo *obj, void *func, ...); typedef void (*Eo_Hook_Call)(const Eo_Class *klass_id, const Eo *obj, void *func, ...);
EAPI extern Eo2_Hook_Call eo2_hook_call_pre; EAPI extern Eo_Hook_Call eo_hook_call_pre;
EAPI extern Eo2_Hook_Call eo2_hook_call_post; EAPI extern Eo_Hook_Call eo_hook_call_post;
// to pass the internal function call to EO2_FUNC_BODY (as Func parameter) // to pass the internal function call to EO_FUNC_BODY (as Func parameter)
#define EO2_FUNC_CALL(...) __VA_ARGS__ #define EO_FUNC_CALL(...) __VA_ARGS__
#define EO2_HOOK_CALL_PREPARE(Hook) \ #define EO_HOOK_CALL_PREPARE(Hook) \
if (Hook) \ if (Hook) \
Hook(call.klass, call.obj, call.func); Hook(call.klass, call.obj, call.func);
#define EO2_HOOK_CALL_PREPAREV(Hook, ...) \ #define EO_HOOK_CALL_PREPAREV(Hook, ...) \
if (Hook) \ if (Hook) \
Hook(call.klass, call.obj, call.func, __VA_ARGS__); Hook(call.klass, call.obj, call.func, __VA_ARGS__);
// cache OP id, get real fct and object data then do the call // cache OP id, get real fct and object data then do the call
#define EO2_FUNC_COMMON_OP(Name, DefRet) \ #define EO_FUNC_COMMON_OP(Name, DefRet) \
Eo2_Op_Call_Data call; \ Eo_Op_Call_Data call; \
static Eo_Op op = EO_NOOP; \ static Eo_Op op = EO_NOOP; \
if (op == EO_NOOP) \ if (op == EO_NOOP) \
op = _eo2_api_op_id_get((void*) Name, __FILE__, __LINE__); \ op = _eo_api_op_id_get((void*) Name, __FILE__, __LINE__); \
if (!_eo2_call_resolve(#Name, op, &call, __FILE__, __LINE__)) return DefRet; \ if (!_eo_call_resolve(#Name, op, &call, __FILE__, __LINE__)) return DefRet; \
_Eo2_##Name##_func _func_ = (_Eo2_##Name##_func) call.func; \ _Eo_##Name##_func _func_ = (_Eo_##Name##_func) call.func; \
// to define an EAPI function // to define an EAPI function
#define EO2_FUNC_BODY(Name, Ret, DefRet) \ #define EO_FUNC_BODY(Name, Ret, DefRet) \
Ret \ Ret \
Name(void) \ Name(void) \
{ \ { \
typedef Ret (*_Eo2_##Name##_func)(Eo *, void *obj_data); \ typedef Ret (*_Eo_##Name##_func)(Eo *, void *obj_data); \
Ret _r; \ Ret _r; \
EO2_FUNC_COMMON_OP(Name, DefRet); \ EO_FUNC_COMMON_OP(Name, DefRet); \
EO2_HOOK_CALL_PREPARE(eo2_hook_call_pre); \ EO_HOOK_CALL_PREPARE(eo_hook_call_pre); \
_r = _func_(call.obj, call.data); \ _r = _func_(call.obj, call.data); \
EO2_HOOK_CALL_PREPARE(eo2_hook_call_post); \ EO_HOOK_CALL_PREPARE(eo_hook_call_post); \
return _r; \ return _r; \
} }
#define EO2_VOID_FUNC_BODY(Name) \ #define EO_VOID_FUNC_BODY(Name) \
void \ void \
Name(void) \ Name(void) \
{ \ { \
typedef void (*_Eo2_##Name##_func)(Eo *, void *obj_data); \ typedef void (*_Eo_##Name##_func)(Eo *, void *obj_data); \
EO2_FUNC_COMMON_OP(Name, ); \ EO_FUNC_COMMON_OP(Name, ); \
EO2_HOOK_CALL_PREPARE(eo2_hook_call_pre); \ EO_HOOK_CALL_PREPARE(eo_hook_call_pre); \
_func_(call.obj, call.data); \ _func_(call.obj, call.data); \
EO2_HOOK_CALL_PREPARE(eo2_hook_call_post); \ EO_HOOK_CALL_PREPARE(eo_hook_call_post); \
} }
#define EO2_FUNC_BODYV(Name, Ret, DefRet, Arguments, ...) \ #define EO_FUNC_BODYV(Name, Ret, DefRet, Arguments, ...) \
Ret \ Ret \
Name(__VA_ARGS__) \ Name(__VA_ARGS__) \
{ \ { \
typedef Ret (*_Eo2_##Name##_func)(Eo *, void *obj_data, __VA_ARGS__); \ typedef Ret (*_Eo_##Name##_func)(Eo *, void *obj_data, __VA_ARGS__); \
Ret _r; \ Ret _r; \
EO2_FUNC_COMMON_OP(Name, DefRet); \ EO_FUNC_COMMON_OP(Name, DefRet); \
EO2_HOOK_CALL_PREPAREV(eo2_hook_call_pre, Arguments); \ EO_HOOK_CALL_PREPAREV(eo_hook_call_pre, Arguments); \
_r = _func_(call.obj, call.data, Arguments); \ _r = _func_(call.obj, call.data, Arguments); \
EO2_HOOK_CALL_PREPAREV(eo2_hook_call_post, Arguments); \ EO_HOOK_CALL_PREPAREV(eo_hook_call_post, Arguments); \
return _r; \ return _r; \
} }
#define EO2_VOID_FUNC_BODYV(Name, Arguments, ...) \ #define EO_VOID_FUNC_BODYV(Name, Arguments, ...) \
void \ void \
Name(__VA_ARGS__) \ Name(__VA_ARGS__) \
{ \ { \
typedef void (*_Eo2_##Name##_func)(Eo *, void *obj_data, __VA_ARGS__); \ typedef void (*_Eo_##Name##_func)(Eo *, void *obj_data, __VA_ARGS__); \
EO2_FUNC_COMMON_OP(Name, ); \ EO_FUNC_COMMON_OP(Name, ); \
EO2_HOOK_CALL_PREPAREV(eo2_hook_call_pre, Arguments); \ EO_HOOK_CALL_PREPAREV(eo_hook_call_pre, Arguments); \
_func_(call.obj, call.data, Arguments); \ _func_(call.obj, call.data, Arguments); \
EO2_HOOK_CALL_PREPAREV(eo2_hook_call_post, Arguments); \ EO_HOOK_CALL_PREPAREV(eo_hook_call_post, Arguments); \
} }
// OP ID of an overriding function // OP ID of an overriding function
#define EO2_OP_OVERRIDE ((Eo_Op) -1) #define EO_OP_OVERRIDE ((Eo_Op) -1)
#define EO2_OP_FUNC(_api, _private, _doc) {_api, _private, EO_NOOP, EO_OP_TYPE_REGULAR, _doc} #define EO_OP_FUNC(_api, _private, _doc) {_api, _private, EO_NOOP, EO_OP_TYPE_REGULAR, _doc}
#define EO2_OP_CLASS_FUNC(_api, _private, _doc) {_api, _private, EO_NOOP, EO_OP_TYPE_CLASS, _doc} #define EO_OP_CLASS_FUNC(_api, _private, _doc) {_api, _private, EO_NOOP, EO_OP_TYPE_CLASS, _doc}
#define EO2_OP_FUNC_OVERRIDE(_api, _private) {_api, _private, EO2_OP_OVERRIDE, EO_OP_TYPE_REGULAR, NULL} #define EO_OP_FUNC_OVERRIDE(_api, _private) {_api, _private, EO_OP_OVERRIDE, EO_OP_TYPE_REGULAR, NULL}
#define EO2_OP_CLASS_FUNC_OVERRIDE(_api, _private) {_api, _private, EO2_OP_OVERRIDE, EO_OP_TYPE_CLASS, NULL} #define EO_OP_CLASS_FUNC_OVERRIDE(_api, _private) {_api, _private, EO_OP_OVERRIDE, EO_OP_TYPE_CLASS, NULL}
#define EO2_OP_SENTINEL { NULL, NULL, 0, EO_OP_TYPE_INVALID, NULL} #define EO_OP_SENTINEL { NULL, NULL, 0, EO_OP_TYPE_INVALID, NULL}
// returns the OP id corresponding to the given api_func // returns the OP id corresponding to the given api_func
EAPI Eo_Op _eo2_api_op_id_get(const void *api_func, const char *file, int line); EAPI Eo_Op _eo_api_op_id_get(const void *api_func, const char *file, int line);
// gets the real function pointer and the object data // gets the real function pointer and the object data
EAPI Eina_Bool _eo2_call_resolve(const char *func_name, const Eo_Op op, Eo2_Op_Call_Data *call, const char *file, int line); EAPI Eina_Bool _eo_call_resolve(const char *func_name, const Eo_Op op, Eo_Op_Call_Data *call, const char *file, int line);
// start of eo2_do barrier, gets the object pointer and ref it, put it on the stask // start of eo_do barrier, gets the object pointer and ref it, put it on the stask
EAPI Eina_Bool _eo2_do_start(const Eo *obj, const Eo_Class *cur_klass, Eina_Bool is_super, const char *file, const char *func, int line); EAPI Eina_Bool _eo_do_start(const Eo *obj, const Eo_Class *cur_klass, Eina_Bool is_super, const char *file, const char *func, int line);
// end of the eo2_do barrier, unref the obj, move the stack pointer // end of the eo_do barrier, unref the obj, move the stack pointer
EAPI void _eo2_do_end(const Eo **ojb); EAPI void _eo_do_end(const Eo **ojb);
#define EO2_DO_CLEANUP __attribute__((cleanup(_eo2_do_end))) #define EO_DO_CLEANUP __attribute__((cleanup(_eo_do_end)))
// eo object method calls batch, // eo object method calls batch,
#define _eo2_do_common(eoid, clsid, is_super, ...) \ #define _eo_do_common(eoid, clsid, is_super, ...) \
do \ do \
{ \ { \
const Eo *_eoid_ = eoid; \ const Eo *_eoid_ = eoid; \
if (_eo2_do_start(_eoid_, clsid, is_super, __FILE__, __FUNCTION__, __LINE__)) \ if (_eo_do_start(_eoid_, clsid, is_super, __FILE__, __FUNCTION__, __LINE__)) \
{ \ { \
const Eo *_id_clean_ EO2_DO_CLEANUP = _eoid_; \ const Eo *_id_clean_ EO_DO_CLEANUP = _eoid_; \
__VA_ARGS__; \ __VA_ARGS__; \
(void) _id_clean_; \ (void) _id_clean_; \
} \ } \
} while (0) } while (0)
#define eo2_do(eoid, ...) _eo2_do_common(eoid, NULL, EINA_FALSE, __VA_ARGS__) #define eo_do(eoid, ...) _eo_do_common(eoid, NULL, EINA_FALSE, __VA_ARGS__)
#define eo2_do_super(eoid, clsid, func) _eo2_do_common(eoid, clsid, EINA_TRUE, func) #define eo_do_super(eoid, clsid, func) _eo_do_common(eoid, clsid, EINA_TRUE, func)
/*****************************************************************************/ /*****************************************************************************/
@ -624,14 +620,14 @@ EAPI void eo_error_set_internal(const Eo *obj, const char *file, int line);
* *
* @see #eo_add_custom * @see #eo_add_custom
*/ */
#define eo2_add(klass, parent, ...) \ #define eo_add(klass, parent, ...) \
({ \ ({ \
const Eo_Class *_tmp_klass = klass; \ const Eo_Class *_tmp_klass = klass; \
Eo *_tmp_obj = _eo2_add_internal_start(__FILE__, __LINE__, _tmp_klass, parent); \ Eo *_tmp_obj = _eo_add_internal_start(__FILE__, __LINE__, _tmp_klass, parent); \
eo2_do(_tmp_obj, \ eo_do(_tmp_obj, \
eo2_constructor(); \ eo_constructor(); \
__VA_ARGS__; \ __VA_ARGS__; \
_tmp_obj = _eo2_add_internal_end(__FILE__, __LINE__, _tmp_obj); \ _tmp_obj = _eo_add_internal_end(__FILE__, __LINE__, _tmp_obj); \
); \ ); \
_tmp_obj; \ _tmp_obj; \
}) })
@ -646,19 +642,19 @@ EAPI void eo_error_set_internal(const Eo *obj, const char *file, int line);
* *
* @see #eo_add * @see #eo_add
*/ */
#define eo2_add_custom(klass, parent, ...) \ #define eo_add_custom(klass, parent, ...) \
({ \ ({ \
const Eo_Class *_tmp_klass = klass; \ const Eo_Class *_tmp_klass = klass; \
Eo *_tmp_obj = _eo2_add_internal_start(__FILE__, __LINE__, _tmp_klass, parent); \ Eo *_tmp_obj = _eo_add_internal_start(__FILE__, __LINE__, _tmp_klass, parent); \
eo2_do(_tmp_obj, \ eo_do(_tmp_obj, \
__VA_ARGS__; \ __VA_ARGS__; \
_tmp_obj = _eo2_add_internal_end(__FILE__, __LINE__, _tmp_obj); \ _tmp_obj = _eo_add_internal_end(__FILE__, __LINE__, _tmp_obj); \
); \ ); \
_tmp_obj; \ _tmp_obj; \
}) })
EAPI Eo * _eo2_add_internal_start(const char *file, int line, const Eo_Class *klass_id, Eo *parent); EAPI Eo * _eo_add_internal_start(const char *file, int line, const Eo_Class *klass_id, Eo *parent);
EAPI Eo * _eo2_add_internal_end(const char *file, int line, const Eo *obj); EAPI Eo * _eo_add_internal_end(const char *file, int line, const Eo *obj);
/** /**
* @brief Get a pointer to the data of an object for a specific class. * @brief Get a pointer to the data of an object for a specific class.
@ -918,12 +914,12 @@ EAPI Eina_Bool eo_composite_is(const Eo *comp_obj);
* @def EO_CLASS_CLASS * @def EO_CLASS_CLASS
* The class type for the Eo Class class. * The class type for the Eo Class class.
*/ */
#define EO2_CLASS_CLASS eo2_class_class_get() #define EO_CLASS_CLASS eo_class_class_get()
/** /**
* @brief Use #EO_CLASS_CLASS * @brief Use #EO_CLASS_CLASS
* @internal * @internal
* */ * */
EAPI const Eo_Class *eo2_class_class_get(void); EAPI const Eo_Class *eo_class_class_get(void);
/** /**
* @} * @}
@ -938,12 +934,12 @@ EAPI const Eo_Class *eo2_class_class_get(void);
* @def EO_BASE_CLASS * @def EO_BASE_CLASS
* The class type for the Eo base class. * The class type for the Eo base class.
*/ */
#define EO2_BASE_CLASS eo2_base_class_get() #define EO_BASE_CLASS eo_base_class_get()
/** /**
* @brief Use #EO_BASE_CLASS * @brief Use #EO_BASE_CLASS
* @internal * @internal
* */ * */
EAPI const Eo_Class *eo2_base_class_get(void); EAPI const Eo_Class *eo_base_class_get(void);
/** /**
* @typedef eo_base_data_free_func * @typedef eo_base_data_free_func
@ -960,7 +956,7 @@ typedef void (*eo_base_data_free_func)(void *);
* @see #eo_base_data_get * @see #eo_base_data_get
* @see #eo_base_data_del * @see #eo_base_data_del
*/ */
EAPI void eo2_base_data_set(const char *key, const void *data, eo_base_data_free_func free_func); EAPI void eo_base_data_set(const char *key, const void *data, eo_base_data_free_func free_func);
/** /**
* @brief Get generic data from object. * @brief Get generic data from object.
@ -970,13 +966,13 @@ EAPI void eo2_base_data_set(const char *key, const void *data, eo_base_data_free
* @see #eo_base_data_set * @see #eo_base_data_set
* @see #eo_base_data_del * @see #eo_base_data_del
*/ */
EAPI void *eo2_base_data_get(const char *key); EAPI void *eo_base_data_get(const char *key);
/** /**
* @brief Get dbg information from the object. * @brief Get dbg information from the object.
* @param[in] root node of the tree * @param[in] root node of the tree
*/ */
EAPI void eo2_dbg_info_get(Eo_Dbg_Info *root_node); EAPI void eo_dbg_info_get(Eo_Dbg_Info *root_node);
/** /**
* @brief Del generic data from object. * @brief Del generic data from object.
@ -985,7 +981,7 @@ EAPI void eo2_dbg_info_get(Eo_Dbg_Info *root_node);
* @see #eo_base_data_set * @see #eo_base_data_set
* @see #eo_base_data_get * @see #eo_base_data_get
*/ */
EAPI void eo2_base_data_del(const char *key); EAPI void eo_base_data_del(const char *key);
/** /**
* @brief Set the parent of an object * @brief Set the parent of an object
@ -998,7 +994,7 @@ EAPI void eo2_base_data_del(const char *key);
* @see eo_del() * @see eo_del()
* @see eo_parent_get() * @see eo_parent_get()
*/ */
EAPI void eo2_parent_set(Eo *parent); EAPI void eo_parent_set(Eo *parent);
/** /**
* @brief Get the parent of an object * @brief Get the parent of an object
@ -1006,7 +1002,7 @@ EAPI void eo2_parent_set(Eo *parent);
* *
* @see eo_parent_set() * @see eo_parent_set()
*/ */
EAPI Eo *eo2_parent_get(void); EAPI Eo *eo_parent_get(void);
/** /**
* @brief Get an iterator on all childrens * @brief Get an iterator on all childrens
@ -1015,7 +1011,7 @@ EAPI Eo *eo2_parent_get(void);
* *
* @see eo_parent_set() * @see eo_parent_set()
*/ */
EAPI Eina_Iterator *eo2_children_iterator_new(void); EAPI Eina_Iterator *eo_children_iterator_new(void);
/** /**
* @brief Add a new weak reference to obj. * @brief Add a new weak reference to obj.
@ -1028,7 +1024,7 @@ EAPI Eina_Iterator *eo2_children_iterator_new(void);
* *
* @see #eo_wref_del * @see #eo_wref_del
*/ */
EAPI void eo2_wref_add(Eo **wref); EAPI void eo_wref_add(Eo **wref);
/** /**
* @brief Delete the weak reference passed. * @brief Delete the weak reference passed.
@ -1036,7 +1032,7 @@ EAPI void eo2_wref_add(Eo **wref);
* *
* @see #eo_wref_add * @see #eo_wref_add
*/ */
EAPI void eo2_wref_del(Eo **wref); EAPI void eo_wref_del(Eo **wref);
/** /**
* @def eo_weak_ref * @def eo_weak_ref
@ -1050,9 +1046,9 @@ EAPI void eo2_wref_del(Eo **wref);
* @see eo_weak_unref * @see eo_weak_unref
* @see eo_wref_add * @see eo_wref_add
*/ */
#define eo2_weak_ref(wref) \ #define eo_weak_ref(wref) \
do { \ do { \
if (*wref) eo2_do(*wref, eo2_wref_add(wref)); \ if (*wref) eo_do(*wref, eo_wref_add(wref)); \
} while (0) } while (0)
/** /**
@ -1068,9 +1064,9 @@ EAPI void eo2_wref_del(Eo **wref);
* @see eo_wref_del * @see eo_wref_del
* @see eo_wref_del_safe * @see eo_wref_del_safe
*/ */
#define eo2_weak_unref(wref) \ #define eo_weak_unref(wref) \
do { \ do { \
if (*wref) eo2_do(*wref, eo2_wref_del(wref)); \ if (*wref) eo_do(*wref, eo_wref_del(wref)); \
} while (0) } while (0)
/** /**
@ -1083,7 +1079,7 @@ EAPI void eo2_wref_del(Eo **wref);
* *
* @see #eo_wref_del * @see #eo_wref_del
*/ */
#define eo2_wref_del_safe(wref) eo2_weak_unref(wref) #define eo_wref_del_safe(wref) eo_weak_unref(wref)
/** /**
* @brief Call the object's constructor. * @brief Call the object's constructor.
@ -1092,7 +1088,7 @@ EAPI void eo2_wref_del(Eo **wref);
* *
* @see #eo_destructor * @see #eo_destructor
*/ */
EAPI void eo2_constructor(void); EAPI void eo_constructor(void);
/** /**
* @brief Call the object's destructor. * @brief Call the object's destructor.
@ -1101,7 +1097,7 @@ EAPI void eo2_constructor(void);
* *
* @see #eo_constructor * @see #eo_constructor
*/ */
EAPI void eo2_destructor(void); EAPI void eo_destructor(void);
/** /**
* @addtogroup Eo_Events Eo's Event Handling * @addtogroup Eo_Events Eo's Event Handling
@ -1192,7 +1188,7 @@ struct _Eo_Callback_Array_Item
* *
* @see eo_event_callback_forwarder_del() * @see eo_event_callback_forwarder_del()
*/ */
EAPI void eo2_event_callback_forwarder_add(const Eo_Event_Description *desc, Eo *new_obj); EAPI void eo_event_callback_forwarder_add(const Eo_Event_Description *desc, Eo *new_obj);
/** /**
* @brief Remove an event callback forwarder for an event and an object. * @brief Remove an event callback forwarder for an event and an object.
@ -1201,7 +1197,7 @@ EAPI void eo2_event_callback_forwarder_add(const Eo_Event_Description *desc, Eo
* *
* @see eo_event_callback_forwarder_add() * @see eo_event_callback_forwarder_add()
*/ */
EAPI void eo2_event_callback_forwarder_del(const Eo_Event_Description *desc, Eo *new_obj); EAPI void eo_event_callback_forwarder_del(const Eo_Event_Description *desc, Eo *new_obj);
/** /**
* @brief freeze events of object. * @brief freeze events of object.
@ -1210,7 +1206,7 @@ EAPI void eo2_event_callback_forwarder_del(const Eo_Event_Description *desc, Eo
* *
* @see #eo_event_thaw * @see #eo_event_thaw
*/ */
EAPI void eo2_event_freeze(void); EAPI void eo_event_freeze(void);
/** /**
* @brief thaw events of object. * @brief thaw events of object.
@ -1219,7 +1215,7 @@ EAPI void eo2_event_freeze(void);
* *
* @see #eo_event_freeze * @see #eo_event_freeze
*/ */
EAPI void eo2_event_thaw(void); EAPI void eo_event_thaw(void);
/** /**
* @brief return freeze events of object. * @brief return freeze events of object.
@ -1231,7 +1227,7 @@ EAPI void eo2_event_thaw(void);
* @see #eo_event_freeze * @see #eo_event_freeze
* @see #eo_event_thaw * @see #eo_event_thaw
*/ */
EAPI int eo2_event_freeze_get(void); EAPI int eo_event_freeze_get(void);
/** /**
* @brief freeze events of object. * @brief freeze events of object.
@ -1241,7 +1237,7 @@ EAPI int eo2_event_freeze_get(void);
* @see #eo_event_freeze * @see #eo_event_freeze
* @see #eo_event_global_thaw * @see #eo_event_global_thaw
*/ */
EAPI void eo2_event_global_freeze(void); EAPI void eo_event_global_freeze(void);
/** /**
* @brief thaw events of object. * @brief thaw events of object.
@ -1251,7 +1247,7 @@ EAPI void eo2_event_global_freeze(void);
* @see #eo_event_thaw * @see #eo_event_thaw
* @see #eo_event_global_freeze * @see #eo_event_global_freeze
*/ */
EAPI void eo2_event_global_thaw(void); EAPI void eo_event_global_thaw(void);
/** /**
* @brief return freeze events of object. * @brief return freeze events of object.
@ -1264,7 +1260,7 @@ EAPI void eo2_event_global_thaw(void);
* @see #eo_event_global_freeze * @see #eo_event_global_freeze
* @see #eo_event_global_thaw * @see #eo_event_global_thaw
*/ */
EAPI int eo2_event_global_freeze_get(void); EAPI int eo_event_global_freeze_get(void);
/** /**
* @def eo_event_callback_add(obj, desc, cb, data) * @def eo_event_callback_add(obj, desc, cb, data)
@ -1277,8 +1273,8 @@ EAPI int eo2_event_global_freeze_get(void);
* *
* @see eo_event_callback_priority_add() * @see eo_event_callback_priority_add()
*/ */
#define eo2_event_callback_add(desc, cb, data) \ #define eo_event_callback_add(desc, cb, data) \
eo2_event_callback_priority_add(desc, \ eo_event_callback_priority_add(desc, \
EO_CALLBACK_PRIORITY_DEFAULT, cb, data) EO_CALLBACK_PRIORITY_DEFAULT, cb, data)
/** /**
@ -1292,7 +1288,7 @@ EAPI int eo2_event_global_freeze_get(void);
* *
* @see #eo_event_callback_add * @see #eo_event_callback_add
*/ */
EAPI void eo2_event_callback_priority_add(const Eo_Event_Description *desc, EAPI void eo_event_callback_priority_add(const Eo_Event_Description *desc,
Eo_Callback_Priority priority, Eo_Callback_Priority priority,
Eo_Event_Cb func, Eo_Event_Cb func,
const void *user_data); const void *user_data);
@ -1304,7 +1300,7 @@ EAPI void eo2_event_callback_priority_add(const Eo_Event_Description *desc,
* @param[in] user_data The data to compare. * @param[in] user_data The data to compare.
* *
*/ */
EAPI void eo2_event_callback_del(const Eo_Event_Description *desc, EAPI void eo_event_callback_del(const Eo_Event_Description *desc,
Eo_Event_Cb func, Eo_Event_Cb func,
const void *user_data); const void *user_data);
@ -1318,8 +1314,8 @@ EAPI void eo2_event_callback_del(const Eo_Event_Description *desc,
* *
* @see eo_event_callback_array_priority_add() * @see eo_event_callback_array_priority_add()
*/ */
#define eo2_event_callback_array_add(array, data) \ #define eo_event_callback_array_add(array, data) \
eo2_event_callback_array_priority_add(array, \ eo_event_callback_array_priority_add(array, \
EO_CALLBACK_PRIORITY_DEFAULT, data) EO_CALLBACK_PRIORITY_DEFAULT, data)
/** /**
@ -1332,7 +1328,7 @@ EAPI void eo2_event_callback_del(const Eo_Event_Description *desc,
* *
* @see #eo_event_callback_add * @see #eo_event_callback_add
*/ */
EAPI void eo2_event_callback_array_priority_add(const Eo_Callback_Array_Item *array, EAPI void eo_event_callback_array_priority_add(const Eo_Callback_Array_Item *array,
Eo_Callback_Priority priority, Eo_Callback_Priority priority,
const void *user_data); const void *user_data);
@ -1342,7 +1338,7 @@ EAPI void eo2_event_callback_array_priority_add(const Eo_Callback_Array_Item *ar
* @param[in] user_data The data to compare. * @param[in] user_data The data to compare.
* *
*/ */
EAPI void eo2_event_callback_array_del(const Eo_Callback_Array_Item *array, EAPI void eo_event_callback_array_del(const Eo_Callback_Array_Item *array,
const void *user_data); const void *user_data);
/** /**
@ -1351,7 +1347,7 @@ EAPI void eo2_event_callback_array_del(const Eo_Callback_Array_Item *array,
* @param[in] event_info Extra event info to pass to the callbacks. * @param[in] event_info Extra event info to pass to the callbacks.
* @param[out] aborted @c EINA_TRUE if one of the callbacks aborted the call, @c EINA_FALSE otherwise. * @param[out] aborted @c EINA_TRUE if one of the callbacks aborted the call, @c EINA_FALSE otherwise.
*/ */
EAPI Eina_Bool eo2_event_callback_call(const Eo_Event_Description *desc, void *event_info); EAPI Eina_Bool eo_event_callback_call(const Eo_Event_Description *desc, void *event_info);
/** /**
* @} * @}

190
src/lib/eo/eo.c
View File

@ -184,12 +184,12 @@ _eo_op_class_get(Eo_Op op)
return NULL; return NULL;
} }
static const Eo2_Op_Description * static const Eo_Op_Description *
_eo2_op_id_desc_get(Eo_Op op) _eo_op_id_desc_get(Eo_Op op)
{ {
unsigned int i; unsigned int i;
const _Eo_Class *klass; const _Eo_Class *klass;
const Eo2_Op_Description *op_descs; const Eo_Op_Description *op_descs;
if (op == EO_NOOP) if (op == EO_NOOP)
return NULL; return NULL;
@ -213,12 +213,12 @@ _eo2_op_id_desc_get(Eo_Op op)
static const char * static const char *
_eo_op_id_name_get(Eo_Op op) _eo_op_id_name_get(Eo_Op op)
{ {
const Eo2_Op_Description *desc = _eo2_op_id_desc_get(op); const Eo_Op_Description *desc = _eo_op_id_desc_get(op);
return (desc) ? desc->doc : NULL; return (desc) ? desc->doc : NULL;
} }
static inline const op_type_funcs * static inline const op_type_funcs *
_eo2_kls_itr_next(const _Eo_Class *orig_kls, const _Eo_Class *cur_klass, Eo_Op op) _eo_kls_itr_next(const _Eo_Class *orig_kls, const _Eo_Class *cur_klass, Eo_Op op)
{ {
const _Eo_Class **kls_itr = NULL; const _Eo_Class **kls_itr = NULL;
@ -245,16 +245,16 @@ _eo2_kls_itr_next(const _Eo_Class *orig_kls, const _Eo_Class *cur_klass, Eo_Op o
return NULL; return NULL;
} }
/************************************ EO2 ************************************/ /************************************ EO ************************************/
EAPI Eo2_Hook_Call eo2_hook_call_pre = NULL; EAPI Eo_Hook_Call eo_hook_call_pre = NULL;
EAPI Eo2_Hook_Call eo2_hook_call_post = NULL; EAPI Eo_Hook_Call eo_hook_call_post = NULL;
// FIXME: Thread Local Storage // FIXME: Thread Local Storage
#define EO2_INVALID_DATA (void *) -1 #define EO_INVALID_DATA (void *) -1
#define EO2_CALL_STACK_DEPTH 30 #define EO_CALL_STACK_DEPTH 30
typedef struct _Eo2_Stack_Frame typedef struct _Eo_Stack_Frame
{ {
const Eo *eo_id; const Eo *eo_id;
union { union {
@ -263,27 +263,27 @@ typedef struct _Eo2_Stack_Frame
} o; } o;
const _Eo_Class *cur_klass; const _Eo_Class *cur_klass;
void *obj_data; void *obj_data;
} Eo2_Stack_Frame; } Eo_Stack_Frame;
static Eina_TLS _eo2_call_stack_key = 0; static Eina_TLS _eo_call_stack_key = 0;
typedef struct _Eo2_Call_Stack { typedef struct _Eo_Call_Stack {
Eo2_Stack_Frame *frames; Eo_Stack_Frame *frames;
Eo2_Stack_Frame *frame_ptr; Eo_Stack_Frame *frame_ptr;
Eo2_Stack_Frame *last_frame; Eo_Stack_Frame *last_frame;
Eo2_Stack_Frame *shrink_frame; Eo_Stack_Frame *shrink_frame;
} Eo2_Call_Stack; } Eo_Call_Stack;
static Eo2_Call_Stack * static Eo_Call_Stack *
_eo2_call_stack_create() _eo_call_stack_create()
{ {
Eo2_Call_Stack *stack; Eo_Call_Stack *stack;
stack = calloc(1, sizeof(Eo2_Call_Stack)); stack = calloc(1, sizeof(Eo_Call_Stack));
if (!stack) if (!stack)
return NULL; return NULL;
stack->frames = calloc(EO2_CALL_STACK_DEPTH, sizeof(Eo2_Stack_Frame)); stack->frames = calloc(EO_CALL_STACK_DEPTH, sizeof(Eo_Stack_Frame));
if (!stack->frames) if (!stack->frames)
{ {
free(stack); free(stack);
@ -292,16 +292,16 @@ _eo2_call_stack_create()
// first frame is never used // first frame is never used
stack->frame_ptr = stack->frames; stack->frame_ptr = stack->frames;
stack->last_frame = &stack->frames[EO2_CALL_STACK_DEPTH - 1]; stack->last_frame = &stack->frames[EO_CALL_STACK_DEPTH - 1];
stack->shrink_frame = stack->frames; stack->shrink_frame = stack->frames;
return stack; return stack;
} }
static void static void
_eo2_call_stack_free(void *ptr) _eo_call_stack_free(void *ptr)
{ {
Eo2_Call_Stack *stack = (Eo2_Call_Stack *) ptr; Eo_Call_Stack *stack = (Eo_Call_Stack *) ptr;
if (!stack) return; if (!stack) return;
@ -310,24 +310,24 @@ _eo2_call_stack_free(void *ptr)
free(stack); free(stack);
} }
static inline Eo2_Call_Stack * static inline Eo_Call_Stack *
_eo2_call_stack_get() _eo_call_stack_get()
{ {
Eo2_Call_Stack *stack = eina_tls_get(_eo2_call_stack_key); Eo_Call_Stack *stack = eina_tls_get(_eo_call_stack_key);
if (stack) return stack; if (stack) return stack;
stack = _eo2_call_stack_create(); stack = _eo_call_stack_create();
if (!stack) if (!stack)
{ {
EINA_LOG_ERR("Could not alloc eo2 call stack."); EINA_LOG_ERR("Could not alloc eo call stack.");
return NULL; return NULL;
} }
if (!eina_tls_set(_eo2_call_stack_key, stack)) if (!eina_tls_set(_eo_call_stack_key, stack))
{ {
EINA_LOG_ERR("Could not set eo2 call stack in TLS key."); EINA_LOG_ERR("Could not set eo call stack in TLS key.");
_eo2_call_stack_free(stack); _eo_call_stack_free(stack);
return NULL; return NULL;
} }
@ -335,7 +335,7 @@ _eo2_call_stack_get()
} }
static inline void static inline void
_eo2_call_stack_resize(Eo2_Call_Stack *stack, Eina_Bool grow) _eo_call_stack_resize(Eo_Call_Stack *stack, Eina_Bool grow)
{ {
size_t sz, next_sz; size_t sz, next_sz;
int frame_offset; int frame_offset;
@ -348,7 +348,7 @@ _eo2_call_stack_resize(Eo2_Call_Stack *stack, Eina_Bool grow)
next_sz = sz >> 1; next_sz = sz >> 1;
DBG("resize from %lu to %lu", sz, next_sz); DBG("resize from %lu to %lu", sz, next_sz);
stack->frames = realloc(stack->frames, next_sz * sizeof(Eo2_Stack_Frame)); stack->frames = realloc(stack->frames, next_sz * sizeof(Eo_Stack_Frame));
if(!stack->frames) if(!stack->frames)
{ {
CRI("unable to resize call stack, abort."); CRI("unable to resize call stack, abort.");
@ -360,7 +360,7 @@ _eo2_call_stack_resize(Eo2_Call_Stack *stack, Eina_Bool grow)
if (grow) if (grow)
frame_offset = (sz >> 1); frame_offset = (sz >> 1);
if (next_sz == EO2_CALL_STACK_DEPTH) if (next_sz == EO_CALL_STACK_DEPTH)
frame_offset = 0; frame_offset = 0;
else else
frame_offset = (next_sz >> 1); frame_offset = (next_sz >> 1);
@ -368,22 +368,22 @@ _eo2_call_stack_resize(Eo2_Call_Stack *stack, Eina_Bool grow)
} }
static inline Eina_Bool static inline Eina_Bool
_eo2_do_internal(const Eo *eo_id, const Eo_Class *cur_klass_id, _eo_do_internal(const Eo *eo_id, const Eo_Class *cur_klass_id,
Eina_Bool is_super, Eo2_Stack_Frame *fptr, Eo2_Stack_Frame *pfptr) Eina_Bool is_super, Eo_Stack_Frame *fptr, Eo_Stack_Frame *pfptr)
{ {
Eina_Bool is_klass = _eo_is_a_class(eo_id); Eina_Bool is_klass = _eo_is_a_class(eo_id);
/* If we are already in the same object context, we inherit info from it. */ /* If we are already in the same object context, we inherit info from it. */
if (pfptr) if (pfptr)
{ {
memcpy(fptr, pfptr, sizeof(Eo2_Stack_Frame)); memcpy(fptr, pfptr, sizeof(Eo_Stack_Frame));
if (!is_klass) if (!is_klass)
_eo_ref(fptr->o.obj); _eo_ref(fptr->o.obj);
} }
else else
{ {
fptr->eo_id = eo_id; fptr->eo_id = eo_id;
fptr->obj_data = EO2_INVALID_DATA; fptr->obj_data = EO_INVALID_DATA;
if (is_klass) if (is_klass)
{ {
EO_CLASS_POINTER_RETURN_VAL(eo_id, _klass, EINA_FALSE); EO_CLASS_POINTER_RETURN_VAL(eo_id, _klass, EINA_FALSE);
@ -401,7 +401,7 @@ _eo2_do_internal(const Eo *eo_id, const Eo_Class *cur_klass_id,
{ {
EO_CLASS_POINTER_RETURN_VAL(cur_klass_id, cur_klass, EINA_FALSE); EO_CLASS_POINTER_RETURN_VAL(cur_klass_id, cur_klass, EINA_FALSE);
if (fptr->cur_klass == cur_klass) if (fptr->cur_klass == cur_klass)
fptr->obj_data = EO2_INVALID_DATA; fptr->obj_data = EO_INVALID_DATA;
fptr->cur_klass = cur_klass; fptr->cur_klass = cur_klass;
} }
else else
@ -413,20 +413,20 @@ _eo2_do_internal(const Eo *eo_id, const Eo_Class *cur_klass_id,
} }
EAPI Eina_Bool EAPI Eina_Bool
_eo2_do_start(const Eo *eo_id, const Eo_Class *cur_klass_id, Eina_Bool is_super, const char *file EINA_UNUSED, const char *func EINA_UNUSED, int line EINA_UNUSED) _eo_do_start(const Eo *eo_id, const Eo_Class *cur_klass_id, Eina_Bool is_super, const char *file EINA_UNUSED, const char *func EINA_UNUSED, int line EINA_UNUSED)
{ {
Eo2_Stack_Frame *fptr, *pfptr; Eo_Stack_Frame *fptr, *pfptr;
Eo2_Call_Stack *stack = _eo2_call_stack_get(); Eo_Call_Stack *stack = _eo_call_stack_get();
if (stack->frame_ptr == stack->last_frame) if (stack->frame_ptr == stack->last_frame)
_eo2_call_stack_resize(stack, EINA_TRUE); _eo_call_stack_resize(stack, EINA_TRUE);
fptr = stack->frame_ptr; fptr = stack->frame_ptr;
pfptr = ((eo_id) && (fptr->eo_id == eo_id) ? fptr : NULL); pfptr = ((eo_id) && (fptr->eo_id == eo_id) ? fptr : NULL);
fptr++; fptr++;
if (!_eo2_do_internal(eo_id, cur_klass_id, is_super, fptr, pfptr)) if (!_eo_do_internal(eo_id, cur_klass_id, is_super, fptr, pfptr))
return EINA_FALSE; return EINA_FALSE;
stack->frame_ptr++; stack->frame_ptr++;
@ -435,17 +435,17 @@ _eo2_do_start(const Eo *eo_id, const Eo_Class *cur_klass_id, Eina_Bool is_super,
} }
EAPI void EAPI void
_eo2_do_end(const Eo **eo_id EINA_UNUSED) _eo_do_end(const Eo **eo_id EINA_UNUSED)
{ {
Eo2_Stack_Frame *fptr; Eo_Stack_Frame *fptr;
Eo2_Call_Stack *stack = _eo2_call_stack_get(); Eo_Call_Stack *stack = _eo_call_stack_get();
fptr = stack->frame_ptr; fptr = stack->frame_ptr;
if (!_eo_is_a_class(fptr->eo_id) && fptr->o.obj) if (!_eo_is_a_class(fptr->eo_id) && fptr->o.obj)
_eo_unref(fptr->o.obj); _eo_unref(fptr->o.obj);
fptr->obj_data = EO2_INVALID_DATA; fptr->obj_data = EO_INVALID_DATA;
if (fptr == stack->frames) if (fptr == stack->frames)
{ {
@ -456,20 +456,20 @@ _eo2_do_end(const Eo **eo_id EINA_UNUSED)
stack->frame_ptr--; stack->frame_ptr--;
if (fptr == stack->shrink_frame) if (fptr == stack->shrink_frame)
_eo2_call_stack_resize(stack, EINA_FALSE); _eo_call_stack_resize(stack, EINA_FALSE);
} }
EAPI Eina_Bool EAPI Eina_Bool
_eo2_call_resolve(const char *func_name, const Eo_Op op, Eo2_Op_Call_Data *call, const char *file, int line) _eo_call_resolve(const char *func_name, const Eo_Op op, Eo_Op_Call_Data *call, const char *file, int line)
{ {
Eo2_Stack_Frame *fptr; Eo_Stack_Frame *fptr;
const _Eo_Class *klass; const _Eo_Class *klass;
const op_type_funcs *func; const op_type_funcs *func;
Eina_Bool is_obj; Eina_Bool is_obj;
if (op == EO_NOOP) return EINA_FALSE; if (op == EO_NOOP) return EINA_FALSE;
fptr = _eo2_call_stack_get()->frame_ptr; fptr = _eo_call_stack_get()->frame_ptr;
is_obj = !_eo_is_a_class(fptr->eo_id); is_obj = !_eo_is_a_class(fptr->eo_id);
klass = (is_obj) ? fptr->o.obj->klass : fptr->o.kls; klass = (is_obj) ? fptr->o.obj->klass : fptr->o.kls;
@ -477,7 +477,7 @@ _eo2_call_resolve(const char *func_name, const Eo_Op op, Eo2_Op_Call_Data *call,
/* If we have a current class, we need to itr to the next. */ /* If we have a current class, we need to itr to the next. */
if (fptr->cur_klass) if (fptr->cur_klass)
{ {
func = _eo2_kls_itr_next(klass, fptr->cur_klass, op); func = _eo_kls_itr_next(klass, fptr->cur_klass, op);
if (!func) if (!func)
goto end; goto end;
@ -506,7 +506,7 @@ _eo2_call_resolve(const char *func_name, const Eo_Op op, Eo2_Op_Call_Data *call,
call->obj = (Eo *)fptr->eo_id; call->obj = (Eo *)fptr->eo_id;
if (func->src == fptr->o.obj->klass) if (func->src == fptr->o.obj->klass)
{ {
if (fptr->obj_data == EO2_INVALID_DATA) if (fptr->obj_data == EO_INVALID_DATA)
fptr->obj_data = _eo_data_scope_get(fptr->o.obj, func->src); fptr->obj_data = _eo_data_scope_get(fptr->o.obj, func->src);
call->data = fptr->obj_data; call->data = fptr->obj_data;
@ -582,14 +582,14 @@ end2:
} }
static inline const Eo2_Op_Description * static inline const Eo_Op_Description *
_eo2_api_desc_get(const void *api_func, const _Eo_Class *klass, const _Eo_Class **extns) _eo_api_desc_get(const void *api_func, const _Eo_Class *klass, const _Eo_Class **extns)
{ {
int imin, imax, imid; int imin, imax, imid;
const _Eo_Class *cur_klass; const _Eo_Class *cur_klass;
const _Eo_Class **kls_itr = NULL; const _Eo_Class **kls_itr = NULL;
const Eo2_Op_Description *op_desc; const Eo_Op_Description *op_desc;
const Eo2_Op_Description *op_descs; const Eo_Op_Description *op_descs;
if (klass) if (klass)
{ {
@ -621,7 +621,7 @@ _eo2_api_desc_get(const void *api_func, const _Eo_Class *klass, const _Eo_Class
for (kls_itr = extns ; *kls_itr ; kls_itr++) for (kls_itr = extns ; *kls_itr ; kls_itr++)
{ {
cur_klass = *kls_itr; cur_klass = *kls_itr;
op_desc = _eo2_api_desc_get(api_func, cur_klass, NULL); op_desc = _eo_api_desc_get(api_func, cur_klass, NULL);
if (op_desc) return op_desc; if (op_desc) return op_desc;
} }
} }
@ -630,11 +630,11 @@ _eo2_api_desc_get(const void *api_func, const _Eo_Class *klass, const _Eo_Class
} }
EAPI Eo_Op EAPI Eo_Op
_eo2_api_op_id_get(const void *api_func, const char *file, int line) _eo_api_op_id_get(const void *api_func, const char *file, int line)
{ {
const Eo2_Op_Description *desc; const Eo_Op_Description *desc;
const _Eo_Class *klass; const _Eo_Class *klass;
Eo2_Call_Stack *stack = _eo2_call_stack_get(); Eo_Call_Stack *stack = _eo_call_stack_get();
Eina_Bool class_ref = _eo_is_a_class(stack->frame_ptr->eo_id); Eina_Bool class_ref = _eo_is_a_class(stack->frame_ptr->eo_id);
@ -643,7 +643,7 @@ _eo2_api_op_id_get(const void *api_func, const char *file, int line)
else else
klass = stack->frame_ptr->o.obj->klass; klass = stack->frame_ptr->o.obj->klass;
desc = _eo2_api_desc_get(api_func, klass, klass->extensions); desc = _eo_api_desc_get(api_func, klass, klass->extensions);
if (desc == NULL) if (desc == NULL)
{ {
@ -656,24 +656,24 @@ _eo2_api_op_id_get(const void *api_func, const char *file, int line)
} }
static int static int
eo2_api_funcs_cmp(const void *p1, const void *p2) eo_api_funcs_cmp(const void *p1, const void *p2)
{ {
const Eo2_Op_Description *op1, *op2; const Eo_Op_Description *op1, *op2;
op1 = (Eo2_Op_Description *) p1; op1 = (Eo_Op_Description *) p1;
op2 = (Eo2_Op_Description *) p2; op2 = (Eo_Op_Description *) p2;
if (op1->api_func > op2->api_func) return -1; if (op1->api_func > op2->api_func) return -1;
else if (op1->api_func < op2->api_func) return 1; else if (op1->api_func < op2->api_func) return 1;
else return 0; else return 0;
} }
EAPI Eina_Bool EAPI Eina_Bool
_eo2_class_funcs_set(_Eo_Class *klass) _eo_class_funcs_set(_Eo_Class *klass)
{ {
int op_id; int op_id;
const void *last_api_func; const void *last_api_func;
const Eo2_Op_Description *api_desc; const Eo_Op_Description *api_desc;
Eo2_Op_Description *op_desc; Eo_Op_Description *op_desc;
Eo2_Op_Description *op_descs; Eo_Op_Description *op_descs;
op_id = klass->base_id; op_id = klass->base_id;
op_descs = klass->desc->ops.descs2; op_descs = klass->desc->ops.descs2;
@ -682,7 +682,7 @@ _eo2_class_funcs_set(_Eo_Class *klass)
if (!op_descs) return EINA_TRUE; if (!op_descs) return EINA_TRUE;
qsort((void*)op_descs, klass->desc->ops.count, sizeof(Eo2_Op_Description), eo2_api_funcs_cmp); qsort((void*)op_descs, klass->desc->ops.count, sizeof(Eo_Op_Description), eo_api_funcs_cmp);
last_api_func = NULL; last_api_func = NULL;
for (op_desc = op_descs; op_desc->op_type != EO_OP_TYPE_INVALID; op_desc++) for (op_desc = op_descs; op_desc->op_type != EO_OP_TYPE_INVALID; op_desc++)
@ -705,9 +705,9 @@ _eo2_class_funcs_set(_Eo_Class *klass)
op_desc->op = op_id; op_desc->op = op_id;
op_id++; op_id++;
} }
else if (op_desc->op == EO2_OP_OVERRIDE) else if (op_desc->op == EO_OP_OVERRIDE)
{ {
api_desc = _eo2_api_desc_get(op_desc->api_func, klass->parent, klass->extensions); api_desc = _eo_api_desc_get(op_desc->api_func, klass->parent, klass->extensions);
if (api_desc == NULL) if (api_desc == NULL)
{ {
@ -732,7 +732,7 @@ _eo2_class_funcs_set(_Eo_Class *klass)
} }
EAPI Eo * EAPI Eo *
_eo2_add_internal_start(const char *file, int line, const Eo_Class *klass_id, Eo *parent_id) _eo_add_internal_start(const char *file, int line, const Eo_Class *klass_id, Eo *parent_id)
{ {
_Eo_Object *obj; _Eo_Object *obj;
@ -780,16 +780,16 @@ _eo2_add_internal_start(const char *file, int line, const Eo_Class *klass_id, Eo
_eo_ref(obj); _eo_ref(obj);
eo2_do(_eo_id_get(obj), eo2_parent_set(parent_id)); eo_do(_eo_id_get(obj), eo_parent_set(parent_id));
return _eo_id_get(obj); return _eo_id_get(obj);
} }
EAPI Eo * EAPI Eo *
_eo2_add_internal_end(const char *file, int line, const Eo *eo_id) _eo_add_internal_end(const char *file, int line, const Eo *eo_id)
{ {
Eo2_Stack_Frame *fptr; Eo_Stack_Frame *fptr;
Eo2_Call_Stack *stack = _eo2_call_stack_get(); Eo_Call_Stack *stack = _eo_call_stack_get();
fptr = stack->frame_ptr; fptr = stack->frame_ptr;
@ -805,7 +805,7 @@ _eo2_add_internal_end(const char *file, int line, const Eo *eo_id)
fptr->cur_klass : fptr->o.obj->klass; fptr->cur_klass : fptr->o.obj->klass;
ERR("in %s:%d: Object of class '%s' - Not all of the object constructors have been executed.", ERR("in %s:%d: Object of class '%s' - Not all of the object constructors have been executed.",
file, line, klass->desc->name); file, line, klass->desc->name);
/* Unref twice, once for the ref in _eo2_add_internal_start, and once for the basic object ref. */ /* Unref twice, once for the ref in _eo_add_internal_start, and once for the basic object ref. */
_eo_unref(fptr->o.obj); _eo_unref(fptr->o.obj);
_eo_unref(fptr->o.obj); _eo_unref(fptr->o.obj);
return NULL; return NULL;
@ -835,7 +835,7 @@ eo_class_get(const Eo *eo_id)
if (_eo_is_a_class(eo_id)) if (_eo_is_a_class(eo_id))
{ {
EO_CLASS_POINTER_RETURN_VAL(eo_id, _klass, NULL); EO_CLASS_POINTER_RETURN_VAL(eo_id, _klass, NULL);
return eo2_class_class_get(); return eo_class_class_get();
} }
EO_OBJ_POINTER_RETURN_VAL(eo_id, obj, NULL); EO_OBJ_POINTER_RETURN_VAL(eo_id, obj, NULL);
@ -1290,7 +1290,7 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...)
} }
} }
if (!_eo2_class_funcs_set(klass)) if (!_eo_class_funcs_set(klass))
{ {
eina_spinlock_free(&klass->objects.trash_lock); eina_spinlock_free(&klass->objects.trash_lock);
eina_spinlock_free(&klass->iterators.trash_lock); eina_spinlock_free(&klass->iterators.trash_lock);
@ -1408,7 +1408,7 @@ EAPI void
eo_del(const Eo *obj) eo_del(const Eo *obj)
{ {
EO_OBJ_POINTER_RETURN(obj, _obj); EO_OBJ_POINTER_RETURN(obj, _obj);
eo2_do((Eo *) obj, eo2_parent_set(NULL)); eo_do((Eo *) obj, eo_parent_set(NULL));
eo_unref(obj); eo_unref(obj);
} }
@ -1658,13 +1658,13 @@ eo_init(void)
EINA_LOG_STATE_INIT); EINA_LOG_STATE_INIT);
/* bootstrap EO_CLASS_CLASS */ /* bootstrap EO_CLASS_CLASS */
(void) eo2_class_class_get(); (void) eo_class_class_get();
if (_eo2_call_stack_key != 0) if (_eo_call_stack_key != 0)
WRN("_eo2_call_stack_key already set, this should not happen."); WRN("_eo_call_stack_key already set, this should not happen.");
else else
{ {
if (!eina_tls_cb_new(&_eo2_call_stack_key, _eo2_call_stack_free)) if (!eina_tls_cb_new(&_eo_call_stack_key, _eo_call_stack_free))
{ {
EINA_LOG_ERR("Could not create TLS key for call stack."); EINA_LOG_ERR("Could not create TLS key for call stack.");
return EINA_FALSE; return EINA_FALSE;
@ -1699,8 +1699,8 @@ eo_shutdown(void)
eina_spinlock_free(&_eo_class_creation_lock); eina_spinlock_free(&_eo_class_creation_lock);
if (_eo2_call_stack_key != 0) if (_eo_call_stack_key != 0)
eina_tls_free(_eo2_call_stack_key); eina_tls_free(_eo_call_stack_key);
_eo_free_ids_tables(); _eo_free_ids_tables();
@ -1743,7 +1743,7 @@ eo_composite_attach(Eo *comp_obj_id, Eo *parent_id)
comp_obj->composite = EINA_TRUE; comp_obj->composite = EINA_TRUE;
*comp_dst = comp_obj; *comp_dst = comp_obj;
eo2_do(comp_obj_id, eo2_parent_set(parent_id)); eo_do(comp_obj_id, eo_parent_set(parent_id));
return EINA_TRUE; return EINA_TRUE;
} }
@ -1765,7 +1765,7 @@ eo_composite_detach(Eo *comp_obj_id, Eo *parent_id)
{ {
comp_obj->composite = EINA_FALSE; comp_obj->composite = EINA_FALSE;
*comp_itr = NULL; *comp_itr = NULL;
eo2_do(comp_obj_id, eo2_parent_set(NULL)); eo_do(comp_obj_id, eo_parent_set(NULL));
return EINA_TRUE; return EINA_TRUE;
} }
} }

156
src/lib/eo/eo2_base_class.c
View File

@ -68,7 +68,7 @@ _data_set(Eo *obj, void *class_data,
if (!key) return; if (!key) return;
eo2_do(obj, eo2_base_data_del(key); ); eo_do(obj, eo_base_data_del(key); );
node = malloc(sizeof(Eo_Generic_Data_Node)); node = malloc(sizeof(Eo_Generic_Data_Node));
if (!node) return; if (!node) return;
@ -78,7 +78,7 @@ _data_set(Eo *obj, void *class_data,
pd->generic_data = eina_inlist_prepend(pd->generic_data, pd->generic_data = eina_inlist_prepend(pd->generic_data,
EINA_INLIST_GET(node)); EINA_INLIST_GET(node));
} }
EAPI EO2_VOID_FUNC_BODYV(eo2_base_data_set, EO2_FUNC_CALL(key, data, free_func), EAPI EO_VOID_FUNC_BODYV(eo_base_data_set, EO_FUNC_CALL(key, data, free_func),
const char *key, const void *data, eo_base_data_free_func free_func); const char *key, const void *data, eo_base_data_free_func free_func);
static void * static void *
@ -102,7 +102,7 @@ _data_get(Eo *obj EINA_UNUSED, void *class_data, const char *key)
return NULL; return NULL;
} }
EAPI EO2_FUNC_BODYV(eo2_base_data_get, void*, NULL, EO2_FUNC_CALL(key), const char *key); EAPI EO_FUNC_BODYV(eo_base_data_get, void*, NULL, EO_FUNC_CALL(key), const char *key);
static void static void
_parent_set(Eo *obj, void *class_data, Eo *parent_id) _parent_set(Eo *obj, void *class_data, Eo *parent_id)
@ -121,7 +121,7 @@ _parent_set(Eo *obj, void *class_data, Eo *parent_id)
{ {
Private_Data *old_parent_pd; Private_Data *old_parent_pd;
old_parent_pd = eo_data_scope_get(pd->parent, EO2_BASE_CLASS); old_parent_pd = eo_data_scope_get(pd->parent, EO_BASE_CLASS);
if (old_parent_pd) if (old_parent_pd)
{ {
old_parent_pd->children = eina_list_remove(old_parent_pd->children, old_parent_pd->children = eina_list_remove(old_parent_pd->children,
@ -140,7 +140,7 @@ _parent_set(Eo *obj, void *class_data, Eo *parent_id)
if (parent_id) if (parent_id)
{ {
Private_Data *parent_pd = NULL; Private_Data *parent_pd = NULL;
parent_pd = eo_data_scope_get(parent_id, EO2_BASE_CLASS); parent_pd = eo_data_scope_get(parent_id, EO_BASE_CLASS);
if (EINA_LIKELY(parent_pd != NULL)) if (EINA_LIKELY(parent_pd != NULL))
{ {
@ -161,7 +161,7 @@ _parent_set(Eo *obj, void *class_data, Eo *parent_id)
pd->parent = NULL; pd->parent = NULL;
} }
} }
EAPI EO2_VOID_FUNC_BODYV(eo2_parent_set, EO2_FUNC_CALL(parent_id), Eo *parent_id); EAPI EO_VOID_FUNC_BODYV(eo_parent_set, EO_FUNC_CALL(parent_id), Eo *parent_id);
static Eo * static Eo *
_parent_get(Eo *obj EINA_UNUSED, void *class_data) _parent_get(Eo *obj EINA_UNUSED, void *class_data)
@ -170,7 +170,7 @@ _parent_get(Eo *obj EINA_UNUSED, void *class_data)
return pd->parent; return pd->parent;
} }
EAPI EO2_FUNC_BODY(eo2_parent_get, Eo *, NULL); EAPI EO_FUNC_BODY(eo_parent_get, Eo *, NULL);
/* Children accessor */ /* Children accessor */
typedef struct _Eo_Children_Iterator Eo_Children_Iterator; typedef struct _Eo_Children_Iterator Eo_Children_Iterator;
@ -261,14 +261,14 @@ _children_iterator_new(Eo *obj_id, void *class_data)
return (Eina_Iterator *)it; return (Eina_Iterator *)it;
} }
EAPI EO2_FUNC_BODY(eo2_children_iterator_new, Eina_Iterator *, NULL); EAPI EO_FUNC_BODY(eo_children_iterator_new, Eina_Iterator *, NULL);
static void static void
_dbg_info_get(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, Eo_Dbg_Info *root_node EINA_UNUSED) _dbg_info_get(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, Eo_Dbg_Info *root_node EINA_UNUSED)
{ /* No info required in the meantime */ { /* No info required in the meantime */
return; return;
} }
EAPI EO2_VOID_FUNC_BODYV(eo2_dbg_info_get, EO2_FUNC_CALL(root_node), Eo_Dbg_Info *root_node); EAPI EO_VOID_FUNC_BODYV(eo_dbg_info_get, EO_FUNC_CALL(root_node), Eo_Dbg_Info *root_node);
static void static void
_data_del(Eo *obj EINA_UNUSED, void *class_data, const char *key) _data_del(Eo *obj EINA_UNUSED, void *class_data, const char *key)
@ -289,7 +289,7 @@ _data_del(Eo *obj EINA_UNUSED, void *class_data, const char *key)
} }
} }
} }
EAPI EO2_VOID_FUNC_BODYV(eo2_base_data_del, EO2_FUNC_CALL(key), const char *key); EAPI EO_VOID_FUNC_BODYV(eo_base_data_del, EO_FUNC_CALL(key), const char *key);
/* Weak reference. */ /* Weak reference. */
@ -325,7 +325,7 @@ _wref_add(Eo *obj, void *class_data, Eo **wref)
pd->wrefs[count] = NULL; pd->wrefs[count] = NULL;
*wref = obj; *wref = obj;
} }
EAPI EO2_VOID_FUNC_BODYV(eo2_wref_add, EO2_FUNC_CALL(wref), Eo **wref); EAPI EO_VOID_FUNC_BODYV(eo_wref_add, EO_FUNC_CALL(wref), Eo **wref);
static void static void
_wref_del(Eo *obj, void *class_data, Eo **wref) _wref_del(Eo *obj, void *class_data, Eo **wref)
@ -386,7 +386,7 @@ _wref_del(Eo *obj, void *class_data, Eo **wref)
*wref = NULL; *wref = NULL;
} }
EAPI EO2_VOID_FUNC_BODYV(eo2_wref_del, EO2_FUNC_CALL(wref), Eo **wref); EAPI EO_VOID_FUNC_BODYV(eo_wref_del, EO_FUNC_CALL(wref), Eo **wref);
static inline void static inline void
_wref_destruct(Private_Data *pd) _wref_destruct(Private_Data *pd)
@ -537,11 +537,11 @@ _ev_cb_priority_add(Eo *obj, void *class_data,
{ {
const Eo_Callback_Array_Item arr[] = { {desc, func}, {NULL, NULL}}; const Eo_Callback_Array_Item arr[] = { {desc, func}, {NULL, NULL}};
eo2_do(obj, eo2_event_callback_call(EO_EV_CALLBACK_ADD, (void *)arr)); eo_do(obj, eo_event_callback_call(EO_EV_CALLBACK_ADD, (void *)arr));
} }
} }
EAPI EO2_VOID_FUNC_BODYV(eo2_event_callback_priority_add, EAPI EO_VOID_FUNC_BODYV(eo_event_callback_priority_add,
EO2_FUNC_CALL(desc, priority, func, user_data), EO_FUNC_CALL(desc, priority, func, user_data),
const Eo_Event_Description *desc, const Eo_Event_Description *desc,
Eo_Callback_Priority priority, Eo_Callback_Priority priority,
Eo_Event_Cb func, Eo_Event_Cb func,
@ -566,15 +566,15 @@ _ev_cb_del(Eo *obj, void *class_data,
cb->delete_me = EINA_TRUE; cb->delete_me = EINA_TRUE;
pd->deletions_waiting = EINA_TRUE; pd->deletions_waiting = EINA_TRUE;
_eo_callbacks_clear(pd); _eo_callbacks_clear(pd);
eo2_do(obj, eo2_event_callback_call(EO_EV_CALLBACK_DEL, (void *)arr); ); eo_do(obj, eo_event_callback_call(EO_EV_CALLBACK_DEL, (void *)arr); );
return; return;
} }
} }
DBG("Callback of object %p with function %p and data %p not found.", obj, func, user_data); DBG("Callback of object %p with function %p and data %p not found.", obj, func, user_data);
} }
EAPI EO2_VOID_FUNC_BODYV(eo2_event_callback_del, EAPI EO_VOID_FUNC_BODYV(eo_event_callback_del,
EO2_FUNC_CALL(desc, func, user_data), EO_FUNC_CALL(desc, func, user_data),
const Eo_Event_Description *desc, const Eo_Event_Description *desc,
Eo_Event_Cb func, Eo_Event_Cb func,
const void *user_data); const void *user_data);
@ -597,11 +597,11 @@ _ev_cb_array_priority_add(Eo *obj, void *class_data,
_eo_callbacks_sorted_insert(pd, cb); _eo_callbacks_sorted_insert(pd, cb);
{ {
eo2_do(obj, eo2_event_callback_call(EO_EV_CALLBACK_ADD, (void *)array); ); eo_do(obj, eo_event_callback_call(EO_EV_CALLBACK_ADD, (void *)array); );
} }
} }
EAPI EO2_VOID_FUNC_BODYV(eo2_event_callback_array_priority_add, EAPI EO_VOID_FUNC_BODYV(eo_event_callback_array_priority_add,
EO2_FUNC_CALL(array, priority, user_data), EO_FUNC_CALL(array, priority, user_data),
const Eo_Callback_Array_Item *array, const Eo_Callback_Array_Item *array,
Eo_Callback_Priority priority, Eo_Callback_Priority priority,
const void *user_data); const void *user_data);
@ -622,15 +622,15 @@ _ev_cb_array_del(Eo *obj, void *class_data,
pd->deletions_waiting = EINA_TRUE; pd->deletions_waiting = EINA_TRUE;
_eo_callbacks_clear(pd); _eo_callbacks_clear(pd);
eo2_do(obj, eo2_event_callback_call(EO_EV_CALLBACK_DEL, (void *)array); ); eo_do(obj, eo_event_callback_call(EO_EV_CALLBACK_DEL, (void *)array); );
return; return;
} }
} }
DBG("Callback of object %p with function array %p and data %p not found.", obj, array, user_data); DBG("Callback of object %p with function array %p and data %p not found.", obj, array, user_data);
} }
EAPI EO2_VOID_FUNC_BODYV(eo2_event_callback_array_del, EAPI EO_VOID_FUNC_BODYV(eo_event_callback_array_del,
EO2_FUNC_CALL(array, user_data), EO_FUNC_CALL(array, user_data),
const Eo_Callback_Array_Item *array, const Eo_Callback_Array_Item *array,
const void *user_data); const void *user_data);
@ -702,9 +702,9 @@ end:
return ret; return ret;
} }
EAPI EO2_FUNC_BODYV(eo2_event_callback_call, Eina_Bool, EAPI EO_FUNC_BODYV(eo_event_callback_call, Eina_Bool,
EINA_FALSE, EINA_FALSE,
EO2_FUNC_CALL(desc, event_info), EO_FUNC_CALL(desc, event_info),
const Eo_Event_Description *desc, const Eo_Event_Description *desc,
void *event_info); void *event_info);
@ -715,7 +715,7 @@ _eo_event_forwarder_callback(void *data, Eo *obj, const Eo_Event_Description *de
Eo *new_obj = (Eo *) data; Eo *new_obj = (Eo *) data;
Eina_Bool ret = EINA_FALSE; Eina_Bool ret = EINA_FALSE;
eo2_do(new_obj, ret = eo2_event_callback_call(desc, (void *)event_info); ); eo_do(new_obj, ret = eo_event_callback_call(desc, (void *)event_info); );
return ret; return ret;
} }
@ -729,10 +729,10 @@ _ev_cb_forwarder_add(Eo *obj, void *class_data EINA_UNUSED,
/* FIXME: Add it EO_MAGIC_RETURN(new_obj, EO_EINA_MAGIC); */ /* FIXME: Add it EO_MAGIC_RETURN(new_obj, EO_EINA_MAGIC); */
eo2_do(obj, eo2_event_callback_add(desc, _eo_event_forwarder_callback, new_obj); ); eo_do(obj, eo_event_callback_add(desc, _eo_event_forwarder_callback, new_obj); );
} }
EAPI EO2_VOID_FUNC_BODYV(eo2_event_callback_forwarder_add, EAPI EO_VOID_FUNC_BODYV(eo_event_callback_forwarder_add,
EO2_FUNC_CALL(desc, new_obj), EO_FUNC_CALL(desc, new_obj),
const Eo_Event_Description *desc, const Eo_Event_Description *desc,
Eo *new_obj); Eo *new_obj);
@ -744,10 +744,10 @@ _ev_cb_forwarder_del(Eo *obj, void *class_data EINA_UNUSED,
/* FIXME: Add it EO_MAGIC_RETURN(new_obj, EO_EINA_MAGIC); */ /* FIXME: Add it EO_MAGIC_RETURN(new_obj, EO_EINA_MAGIC); */
eo2_do(obj, eo2_event_callback_del(desc, _eo_event_forwarder_callback, new_obj); ); eo_do(obj, eo_event_callback_del(desc, _eo_event_forwarder_callback, new_obj); );
} }
EAPI EO2_VOID_FUNC_BODYV(eo2_event_callback_forwarder_del, EAPI EO_VOID_FUNC_BODYV(eo_event_callback_forwarder_del,
EO2_FUNC_CALL(desc, new_obj), EO_FUNC_CALL(desc, new_obj),
const Eo_Event_Description *desc, const Eo_Event_Description *desc,
Eo *new_obj); Eo *new_obj);
@ -757,7 +757,7 @@ _ev_freeze(Eo *obj EINA_UNUSED, void *class_data)
Private_Data *pd = (Private_Data *) class_data; Private_Data *pd = (Private_Data *) class_data;
pd->event_freeze_count++; pd->event_freeze_count++;
} }
EAPI EO2_VOID_FUNC_BODY(eo2_event_freeze); EAPI EO_VOID_FUNC_BODY(eo_event_freeze);
static void static void
_ev_thaw(Eo *obj, void *class_data) _ev_thaw(Eo *obj, void *class_data)
@ -772,7 +772,7 @@ _ev_thaw(Eo *obj, void *class_data)
ERR("Events for object %p have already been thawed.", obj); ERR("Events for object %p have already been thawed.", obj);
} }
} }
EAPI EO2_VOID_FUNC_BODY(eo2_event_thaw); EAPI EO_VOID_FUNC_BODY(eo_event_thaw);
static int static int
_ev_freeze_get(Eo *obj EINA_UNUSED, void *class_data) _ev_freeze_get(Eo *obj EINA_UNUSED, void *class_data)
@ -781,14 +781,14 @@ _ev_freeze_get(Eo *obj EINA_UNUSED, void *class_data)
return pd->event_freeze_count; return pd->event_freeze_count;
} }
EAPI EO2_FUNC_BODY(eo2_event_freeze_get, int, 0); EAPI EO_FUNC_BODY(eo_event_freeze_get, int, 0);
static void static void
_ev_global_freeze(const Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED) _ev_global_freeze(const Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED)
{ {
event_freeze_count++; event_freeze_count++;
} }
EAPI EO2_VOID_FUNC_BODY(eo2_event_global_freeze); EAPI EO_VOID_FUNC_BODY(eo_event_global_freeze);
static void static void
_ev_global_thaw(const Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED) _ev_global_thaw(const Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED)
@ -802,18 +802,18 @@ _ev_global_thaw(const Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED)
ERR("Global events have already been thawed."); ERR("Global events have already been thawed.");
} }
} }
EAPI EO2_VOID_FUNC_BODY(eo2_event_global_thaw); EAPI EO_VOID_FUNC_BODY(eo_event_global_thaw);
static int static int
_ev_global_freeze_get(const Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED) _ev_global_freeze_get(const Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED)
{ {
return event_freeze_count; return event_freeze_count;
} }
EAPI EO2_FUNC_BODY(eo2_event_global_freeze_get, int, 0); EAPI EO_FUNC_BODY(eo_event_global_freeze_get, int, 0);
/* Eo_Dbg */ /* Eo_Dbg */
EAPI void EAPI void
eo2_dbg_info_free(Eo_Dbg_Info *info) eo_dbg_info_free(Eo_Dbg_Info *info)
{ {
eina_value_flush(&(info->value)); eina_value_flush(&(info->value));
free(info); free(info);
@ -888,7 +888,7 @@ _eo_dbg_info_pget(const Eina_Value_Type *type EINA_UNUSED, const void *_mem, voi
return EINA_TRUE; return EINA_TRUE;
} }
static const Eina_Value_Type _EO2_DBG_INFO_TYPE = { static const Eina_Value_Type _EO_DBG_INFO_TYPE = {
EINA_VALUE_TYPE_VERSION, EINA_VALUE_TYPE_VERSION,
sizeof(Eo_Dbg_Info *), sizeof(Eo_Dbg_Info *),
"Eo_Dbg_Info_Ptr", "Eo_Dbg_Info_Ptr",
@ -903,17 +903,17 @@ static const Eina_Value_Type _EO2_DBG_INFO_TYPE = {
_eo_dbg_info_pget _eo_dbg_info_pget
}; };
EAPI const Eina_Value_Type *EO2_DBG_INFO_TYPE = &_EO2_DBG_INFO_TYPE; EAPI const Eina_Value_Type *EO_DBG_INFO_TYPE = &_EO_DBG_INFO_TYPE;
/* EOF event callbacks */ /* EOF event callbacks */
/* EO_BASE_CLASS stuff */ /* EO_BASE_CLASS stuff */
#define MY_CLASS EO2_BASE_CLASS #define MY_CLASS EO_BASE_CLASS
/* FIXME: Set proper type descriptions. */ /* FIXME: Set proper type descriptions. */
// FIXME: eo2 multiple definition // FIXME: eo multiple definition
/* EAPI const Eo_Event_Description _EO_EV_CALLBACK_ADD = */ /* EAPI const Eo_Event_Description _EO_EV_CALLBACK_ADD = */
/* EO_EVENT_DESCRIPTION("callback,add", "A callback was added."); */ /* EO_EVENT_DESCRIPTION("callback,add", "A callback was added."); */
/* EAPI const Eo_Event_Description _EO_EV_CALLBACK_DEL = */ /* EAPI const Eo_Event_Description _EO_EV_CALLBACK_DEL = */
@ -928,7 +928,7 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED)
_eo_condtor_done(obj); _eo_condtor_done(obj);
} }
EAPI EO2_VOID_FUNC_BODY(eo2_constructor); EAPI EO_VOID_FUNC_BODY(eo_constructor);
static void static void
_destructor(Eo *obj, void *class_data) _destructor(Eo *obj, void *class_data)
@ -939,7 +939,7 @@ _destructor(Eo *obj, void *class_data)
DBG("%p - %s.", obj, eo_class_name_get(MY_CLASS)); DBG("%p - %s.", obj, eo_class_name_get(MY_CLASS));
EINA_LIST_FREE(pd->children, child) EINA_LIST_FREE(pd->children, child)
eo2_do(child, eo2_parent_set(NULL)); eo_do(child, eo_parent_set(NULL));
_eo_generic_data_del_all(class_data); _eo_generic_data_del_all(class_data);
_wref_destruct(class_data); _wref_destruct(class_data);
@ -947,7 +947,7 @@ _destructor(Eo *obj, void *class_data)
_eo_condtor_done(obj); _eo_condtor_done(obj);
} }
EAPI EO2_VOID_FUNC_BODY(eo2_destructor); EAPI EO_VOID_FUNC_BODY(eo_destructor);
static void static void
_class_constructor(Eo_Class *klass EINA_UNUSED) _class_constructor(Eo_Class *klass EINA_UNUSED)
@ -955,35 +955,35 @@ _class_constructor(Eo_Class *klass EINA_UNUSED)
event_freeze_count = 0; event_freeze_count = 0;
} }
static Eo2_Op_Description op_descs [] = { static Eo_Op_Description op_descs [] = {
EO2_OP_FUNC(eo2_constructor, _constructor, "Constructor."), EO_OP_FUNC(eo_constructor, _constructor, "Constructor."),
EO2_OP_FUNC(eo2_destructor, _destructor, "Destructor."), EO_OP_FUNC(eo_destructor, _destructor, "Destructor."),
EO2_OP_FUNC(eo2_parent_set, _parent_set, "Set parent."), EO_OP_FUNC(eo_parent_set, _parent_set, "Set parent."),
EO2_OP_FUNC(eo2_parent_get, _parent_get, "Get parent."), EO_OP_FUNC(eo_parent_get, _parent_get, "Get parent."),
EO2_OP_FUNC(eo2_children_iterator_new, _children_iterator_new, "Get Children Iterator."), EO_OP_FUNC(eo_children_iterator_new, _children_iterator_new, "Get Children Iterator."),
EO2_OP_FUNC(eo2_base_data_set, _data_set, "Set data for key."), EO_OP_FUNC(eo_base_data_set, _data_set, "Set data for key."),
EO2_OP_FUNC(eo2_base_data_get, _data_get, "Get data for key."), EO_OP_FUNC(eo_base_data_get, _data_get, "Get data for key."),
EO2_OP_FUNC(eo2_base_data_del, _data_del, "Del key."), EO_OP_FUNC(eo_base_data_del, _data_del, "Del key."),
EO2_OP_FUNC(eo2_wref_add, _wref_add, "Add a weak ref to the object."), EO_OP_FUNC(eo_wref_add, _wref_add, "Add a weak ref to the object."),
EO2_OP_FUNC(eo2_wref_del, _wref_del, "Delete the weak ref."), EO_OP_FUNC(eo_wref_del, _wref_del, "Delete the weak ref."),
EO2_OP_FUNC(eo2_event_callback_priority_add, _ev_cb_priority_add, "Add an event callback with a priority."), EO_OP_FUNC(eo_event_callback_priority_add, _ev_cb_priority_add, "Add an event callback with a priority."),
EO2_OP_FUNC(eo2_event_callback_del, _ev_cb_del, "Delete an event callback"), EO_OP_FUNC(eo_event_callback_del, _ev_cb_del, "Delete an event callback"),
EO2_OP_FUNC(eo2_event_callback_array_priority_add, _ev_cb_array_priority_add, "Add an event callback array with a priority."), EO_OP_FUNC(eo_event_callback_array_priority_add, _ev_cb_array_priority_add, "Add an event callback array with a priority."),
EO2_OP_FUNC(eo2_event_callback_array_del, _ev_cb_array_del, "Delete an event callback array"), EO_OP_FUNC(eo_event_callback_array_del, _ev_cb_array_del, "Delete an event callback array"),
EO2_OP_FUNC(eo2_event_callback_call, _ev_cb_call, "Call the event callbacks for an event."), EO_OP_FUNC(eo_event_callback_call, _ev_cb_call, "Call the event callbacks for an event."),
EO2_OP_FUNC(eo2_event_callback_forwarder_add, _ev_cb_forwarder_add, "Add an event forwarder."), EO_OP_FUNC(eo_event_callback_forwarder_add, _ev_cb_forwarder_add, "Add an event forwarder."),
EO2_OP_FUNC(eo2_event_callback_forwarder_del, _ev_cb_forwarder_del, "Delete an event forwarder."), EO_OP_FUNC(eo_event_callback_forwarder_del, _ev_cb_forwarder_del, "Delete an event forwarder."),
EO2_OP_FUNC(eo2_event_freeze, _ev_freeze, "Freezes events."), EO_OP_FUNC(eo_event_freeze, _ev_freeze, "Freezes events."),
EO2_OP_FUNC(eo2_event_thaw, _ev_thaw, "Thaws events."), EO_OP_FUNC(eo_event_thaw, _ev_thaw, "Thaws events."),
EO2_OP_FUNC(eo2_event_freeze_get, _ev_freeze_get, "Get event freeze counter."), EO_OP_FUNC(eo_event_freeze_get, _ev_freeze_get, "Get event freeze counter."),
EO2_OP_FUNC(eo2_event_global_freeze, _ev_global_freeze, "Freezes events globally."), EO_OP_FUNC(eo_event_global_freeze, _ev_global_freeze, "Freezes events globally."),
EO2_OP_FUNC(eo2_event_global_thaw, _ev_global_thaw, "Thaws events globally."), EO_OP_FUNC(eo_event_global_thaw, _ev_global_thaw, "Thaws events globally."),
EO2_OP_FUNC(eo2_event_global_freeze_get, _ev_global_freeze_get, "Get global event freeze counter."), EO_OP_FUNC(eo_event_global_freeze_get, _ev_global_freeze_get, "Get global event freeze counter."),
EO2_OP_FUNC(eo2_dbg_info_get, _dbg_info_get, "Get debug info list for obj."), EO_OP_FUNC(eo_dbg_info_get, _dbg_info_get, "Get debug info list for obj."),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
// FIXME: eo2 // FIXME: eo
static const Eo_Event_Description *event_desc[] = { static const Eo_Event_Description *event_desc[] = {
EO_EV_CALLBACK_ADD, EO_EV_CALLBACK_ADD,
EO_EV_CALLBACK_DEL, EO_EV_CALLBACK_DEL,
@ -992,14 +992,14 @@ static const Eo_Event_Description *event_desc[] = {
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Eo2_Base", "Eo_Base",
EO_CLASS_TYPE_REGULAR_NO_INSTANT, EO_CLASS_TYPE_REGULAR_NO_INSTANT,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
event_desc, event_desc,
sizeof(Private_Data), sizeof(Private_Data),
_class_constructor, _class_constructor,
NULL NULL
}; };
EO_DEFINE_CLASS(eo2_base_class_get, &class_desc, NULL, NULL) EO_DEFINE_CLASS(eo_base_class_get, &class_desc, NULL, NULL)

8
src/lib/eo/eo2_class_class.c
View File

@ -5,14 +5,14 @@
#include "Eo.h" #include "Eo.h"
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Eo2_Abstract_Class", "Eo_Abstract_Class",
EO_CLASS_TYPE_REGULAR_NO_INSTANT, EO_CLASS_TYPE_REGULAR_NO_INSTANT,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
0, 0,
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(eo2_class_class_get, &class_desc, NULL, NULL) EO_DEFINE_CLASS(eo_class_class_get, &class_desc, NULL, NULL)

6
src/lib/eo/eo_private.h
View File

@ -109,7 +109,7 @@ struct _Eo_Object
/* [composite*] */ /* [composite*] */
}; };
/* FIXME: Change the type to something generic that makes sense for eo2 */ /* FIXME: Change the type to something generic that makes sense for eo */
typedef void (*eo_op_func_type)(Eo *, void *class_data, va_list *list); typedef void (*eo_op_func_type)(Eo *, void *class_data, va_list *list);
typedef struct _Dich_Chain1 Dich_Chain1; typedef struct _Dich_Chain1 Dich_Chain1;
@ -216,12 +216,12 @@ _eo_del_internal(const char *file, int line, _Eo_Object *obj)
const _Eo_Class *klass = obj->klass; const _Eo_Class *klass = obj->klass;
eo2_do(_eo_id_get(obj), eo2_event_callback_call(EO_EV_DEL, NULL)); eo_do(_eo_id_get(obj), eo_event_callback_call(EO_EV_DEL, NULL));
_eo_condtor_reset(obj); _eo_condtor_reset(obj);
do_err = EINA_FALSE; do_err = EINA_FALSE;
eo2_do(_eo_id_get(obj), eo2_destructor();); eo_do(_eo_id_get(obj), eo_destructor(););
if (EINA_UNLIKELY(do_err)) if (EINA_UNLIKELY(do_err))
{ {

12
src/tests/eo/access/access_inherit.c
View File

@ -16,18 +16,18 @@ _prot_print(Eo *obj, void *class_data EINA_UNUSED)
printf("%s %d\n", __func__, pd->protected_x1); printf("%s %d\n", __func__, pd->protected_x1);
} }
EAPI EO2_VOID_FUNC_BODY(inherit_prot_print); EAPI EO_VOID_FUNC_BODY(inherit_prot_print);
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC(inherit_prot_print, _prot_print, "Print protected var x1."), EO_OP_FUNC(inherit_prot_print, _prot_print, "Print protected var x1."),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Inherit", "Inherit",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,

4
src/tests/eo/access/access_main.c
View File

@ -13,9 +13,9 @@ main(int argc, char *argv[])
(void) argv; (void) argv;
eo_init(); eo_init();
Eo *obj = eo2_add(INHERIT_CLASS, NULL); Eo *obj = eo_add(INHERIT_CLASS, NULL);
eo2_do(obj, simple_a_set(1), inherit_prot_print()); eo_do(obj, simple_a_set(1), inherit_prot_print());
Simple_Public_Data *pd = eo_data_scope_get(obj, SIMPLE_CLASS); Simple_Public_Data *pd = eo_data_scope_get(obj, SIMPLE_CLASS);
printf("Pub: %d\n", pd->public_x2); printf("Pub: %d\n", pd->public_x2);

16
src/tests/eo/access/access_simple.c
View File

@ -27,14 +27,14 @@ _a_set(Eo *obj, void *class_data, int a)
pd->protected.protected_x1 = a + 1; pd->protected.protected_x1 = a + 1;
pd->protected.public.public_x2 = a + 2; pd->protected.public.public_x2 = a + 2;
eo2_do(obj, eo2_event_callback_call(EV_A_CHANGED, &pd->a)); eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a));
} }
EAPI EO2_VOID_FUNC_BODYV(simple_a_set, EO2_FUNC_CALL(a), int a); EAPI EO_VOID_FUNC_BODYV(simple_a_set, EO_FUNC_CALL(a), int a);
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC(simple_a_set, _a_set, "Set property A"), EO_OP_FUNC(simple_a_set, _a_set, "Set property A"),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Event_Description *event_desc[] = { static const Eo_Event_Description *event_desc[] = {
@ -43,15 +43,15 @@ static const Eo_Event_Description *event_desc[] = {
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
event_desc, event_desc,
sizeof(Private_Data), sizeof(Private_Data),
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(simple_class_get, &class_desc, EO2_BASE_CLASS, NULL) EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, NULL)

24
src/tests/eo/composite_objects/composite_objects_comp.c
View File

@ -14,7 +14,7 @@ static int
_a_get(Eo *obj, void *class_data EINA_UNUSED) _a_get(Eo *obj, void *class_data EINA_UNUSED)
{ {
int a = 0; int a = 0;
eo2_do_super(obj, MY_CLASS, a = simple_a_get()); eo_do_super(obj, MY_CLASS, a = simple_a_get());
return a; return a;
} }
@ -22,37 +22,37 @@ _a_get(Eo *obj, void *class_data EINA_UNUSED)
static void static void
_constructor(Eo *obj, void *class_data EINA_UNUSED) _constructor(Eo *obj, void *class_data EINA_UNUSED)
{ {
eo2_do_super(obj, MY_CLASS, eo2_constructor()); eo_do_super(obj, MY_CLASS, eo_constructor());
Eo *simple = eo2_add(SIMPLE_CLASS, obj); Eo *simple = eo_add(SIMPLE_CLASS, obj);
eo_composite_attach(simple, obj); eo_composite_attach(simple, obj);
eo2_do(simple, eo2_event_callback_forwarder_add(EV_A_CHANGED, obj)); eo_do(simple, eo_event_callback_forwarder_add(EV_A_CHANGED, obj));
fail_if(eo_composite_is(obj)); fail_if(eo_composite_is(obj));
fail_if(!eo_composite_is(simple)); fail_if(!eo_composite_is(simple));
eo2_do(obj, eo2_base_data_set("simple-obj", simple, NULL)); eo_do(obj, eo_base_data_set("simple-obj", simple, NULL));
eo_unref(simple); eo_unref(simple);
} }
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor),
EO2_OP_FUNC_OVERRIDE(simple_a_get, _a_get), EO_OP_FUNC_OVERRIDE(simple_a_get, _a_get),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Comp", "Comp",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(comp_class_get, &class_desc, EO2_BASE_CLASS, EO_DEFINE_CLASS(comp_class_get, &class_desc, EO_BASE_CLASS,
SIMPLE_CLASS, NULL); SIMPLE_CLASS, NULL);

14
src/tests/eo/composite_objects/composite_objects_main.c
View File

@ -30,27 +30,27 @@ main(int argc, char *argv[])
(void) argv; (void) argv;
eo_init(); eo_init();
Eo *obj = eo2_add(COMP_CLASS, NULL); Eo *obj = eo_add(COMP_CLASS, NULL);
eo2_do(obj, eo2_event_callback_add(EV_A_CHANGED, _a_changed_cb, NULL)); eo_do(obj, eo_event_callback_add(EV_A_CHANGED, _a_changed_cb, NULL));
fail_if(!eo_isa(obj, COMP_CLASS)); fail_if(!eo_isa(obj, COMP_CLASS));
fail_if(!eo_isa(obj, SIMPLE_CLASS)); fail_if(!eo_isa(obj, SIMPLE_CLASS));
int a = 0; int a = 0;
eo2_do(obj, simple_a_set(1)); eo_do(obj, simple_a_set(1));
fail_if(!cb_called); fail_if(!cb_called);
eo2_do(obj, a = simple_a_get()); eo_do(obj, a = simple_a_get());
fail_if(a != 1); fail_if(a != 1);
/* disable the callback forwarder, and fail if it's still called. */ /* disable the callback forwarder, and fail if it's still called. */
Eo *simple = NULL; Eo *simple = NULL;
eo2_do(obj, simple = eo2_base_data_get("simple-obj")); eo_do(obj, simple = eo_base_data_get("simple-obj"));
eo_ref(simple); eo_ref(simple);
eo2_do(simple, eo2_event_callback_forwarder_del(EV_A_CHANGED, obj)); eo_do(simple, eo_event_callback_forwarder_del(EV_A_CHANGED, obj));
cb_called = EINA_FALSE; cb_called = EINA_FALSE;
eo2_do(obj, simple_a_set(2)); eo_do(obj, simple_a_set(2));
fail_if(cb_called); fail_if(cb_called);
fail_if(!eo_composite_is(simple)); fail_if(!eo_composite_is(simple));

20
src/tests/eo/composite_objects/composite_objects_simple.c
View File

@ -17,7 +17,7 @@ _a_set(Eo *obj, void *class_data, int a)
printf("%s %d\n", eo_class_name_get(MY_CLASS), a); printf("%s %d\n", eo_class_name_get(MY_CLASS), a);
pd->a = a; pd->a = a;
eo2_do(obj, eo2_event_callback_call(EV_A_CHANGED, &pd->a)); eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a));
} }
static int static int
@ -27,13 +27,13 @@ _a_get(Eo *obj EINA_UNUSED, void *class_data)
return pd->a; return pd->a;
} }
EAPI EO2_VOID_FUNC_BODYV(simple_a_set, EO2_FUNC_CALL(a), int a); EAPI EO_VOID_FUNC_BODYV(simple_a_set, EO_FUNC_CALL(a), int a);
EAPI EO2_FUNC_BODY(simple_a_get, int, 0); EAPI EO_FUNC_BODY(simple_a_get, int, 0);
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC(simple_a_set, _a_set, "Set property A"), EO_OP_FUNC(simple_a_set, _a_set, "Set property A"),
EO2_OP_FUNC(simple_a_get, _a_get, "Get property A"), EO_OP_FUNC(simple_a_get, _a_get, "Get property A"),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Event_Description *event_desc[] = { static const Eo_Event_Description *event_desc[] = {
@ -42,15 +42,15 @@ static const Eo_Event_Description *event_desc[] = {
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
event_desc, event_desc,
sizeof(Simple_Public_Data), sizeof(Simple_Public_Data),
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(simple_class_get, &class_desc, EO2_BASE_CLASS, NULL); EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, NULL);

22
src/tests/eo/constructors/constructors_main.c
View File

@ -24,14 +24,14 @@ main(int argc, char *argv[])
(void) argv; (void) argv;
eo_init(); eo_init();
Eo *obj = eo2_add(SIMPLE_CLASS, NULL); Eo *obj = eo_add(SIMPLE_CLASS, NULL);
fail_if(my_init_count != 2); fail_if(my_init_count != 2);
eo2_do(obj, simple_a_set(1), simple_b_set(2)); eo_do(obj, simple_a_set(1), simple_b_set(2));
int a = 0, b = 0; int a = 0, b = 0;
eo2_do(obj, a = simple_a_get(), b = simple_b_get(), mixin_add_and_print(5)); eo_do(obj, a = simple_a_get(), b = simple_b_get(), mixin_add_and_print(5));
fail_if(a != 1); fail_if(a != 1);
fail_if(b != 2); fail_if(b != 2);
@ -39,14 +39,14 @@ main(int argc, char *argv[])
fail_if(my_init_count != 0); fail_if(my_init_count != 0);
obj = eo2_add(SIMPLE2_CLASS, NULL); obj = eo_add(SIMPLE2_CLASS, NULL);
fail_if(obj); fail_if(obj);
obj = eo2_add(SIMPLE3_CLASS, NULL); obj = eo_add(SIMPLE3_CLASS, NULL);
fail_if(obj); fail_if(obj);
my_init_count = 0; my_init_count = 0;
obj = eo2_add(SIMPLE4_CLASS, NULL); obj = eo_add(SIMPLE4_CLASS, NULL);
fail_if(my_init_count != 2); fail_if(my_init_count != 2);
@ -54,23 +54,23 @@ main(int argc, char *argv[])
fail_if(my_init_count != 0); fail_if(my_init_count != 0);
obj = eo2_add(SIMPLE5_CLASS, NULL); obj = eo_add(SIMPLE5_CLASS, NULL);
fail_if(!obj); fail_if(!obj);
eo_unref(obj); eo_unref(obj);
obj = eo2_add(SIMPLE6_CLASS, NULL); obj = eo_add(SIMPLE6_CLASS, NULL);
fail_if(!obj); fail_if(!obj);
eo_unref(obj); eo_unref(obj);
obj = eo2_add(SIMPLE7_CLASS, NULL); obj = eo_add(SIMPLE7_CLASS, NULL);
fail_if(obj); fail_if(obj);
my_init_count = 0; my_init_count = 0;
obj = eo2_add_custom(SIMPLE_CLASS, NULL, simple_constructor(7)); obj = eo_add_custom(SIMPLE_CLASS, NULL, simple_constructor(7));
fail_if(!obj); fail_if(!obj);
fail_if(my_init_count != 2); fail_if(my_init_count != 2);
eo2_do(obj, a = simple_a_get()); eo_do(obj, a = simple_a_get());
fail_if(a != 7); fail_if(a != 7);
eo_unref(obj); eo_unref(obj);

24
src/tests/eo/constructors/constructors_mixin.c
View File

@ -12,7 +12,7 @@ static void
_add_and_print_set(Eo *obj, void *class_data EINA_UNUSED, int x) _add_and_print_set(Eo *obj, void *class_data EINA_UNUSED, int x)
{ {
int a = 0, b = 0; int a = 0, b = 0;
eo2_do(obj, a = simple_a_get(), b = simple_b_get()); eo_do(obj, a = simple_a_get(), b = simple_b_get());
printf("%s %d\n", __func__, a + b + x); printf("%s %d\n", __func__, a + b + x);
} }
@ -21,7 +21,7 @@ extern int my_init_count;
static void static void
_constructor(Eo *obj, void *class_data EINA_UNUSED) _constructor(Eo *obj, void *class_data EINA_UNUSED)
{ {
eo2_do_super(obj, MY_CLASS, eo2_constructor()); eo_do_super(obj, MY_CLASS, eo_constructor());
my_init_count++; my_init_count++;
} }
@ -29,30 +29,30 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED)
static void static void
_destructor(Eo *obj, void *class_data EINA_UNUSED) _destructor(Eo *obj, void *class_data EINA_UNUSED)
{ {
eo2_do_super(obj, MY_CLASS, eo2_destructor()); eo_do_super(obj, MY_CLASS, eo_destructor());
my_init_count--; my_init_count--;
} }
EAPI EO2_VOID_FUNC_BODYV(mixin_add_and_print, EO2_FUNC_CALL(x), int x); EAPI EO_VOID_FUNC_BODYV(mixin_add_and_print, EO_FUNC_CALL(x), int x);
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC(mixin_add_and_print, _add_and_print_set, "Add A + B + param and print it"), EO_OP_FUNC(mixin_add_and_print, _add_and_print_set, "Add A + B + param and print it"),
EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor),
EO2_OP_FUNC_OVERRIDE(eo2_destructor, _destructor), EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Mixin", "Mixin",
EO_CLASS_TYPE_MIXIN, EO_CLASS_TYPE_MIXIN,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(mixin_class_get, &class_desc, NULL, EO2_BASE_CLASS, NULL); EO_DEFINE_CLASS(mixin_class_get, &class_desc, NULL, EO_BASE_CLASS, NULL);

36
src/tests/eo/constructors/constructors_simple.c
View File

@ -31,8 +31,8 @@ _##name##_set(Eo *obj EINA_UNUSED, void *class_data, int name) \
pd->name = name; \ pd->name = name; \
printf("%s %d\n", __func__, pd->name); \ printf("%s %d\n", __func__, pd->name); \
} \ } \
EO2_VOID_FUNC_BODYV(simple_##name##_set, EO2_FUNC_CALL(name), int name); \ EO_VOID_FUNC_BODYV(simple_##name##_set, EO_FUNC_CALL(name), int name); \
EO2_FUNC_BODY(simple_##name##_get, int, 0); EO_FUNC_BODY(simple_##name##_get, int, 0);
_GET_SET_FUNC(a) _GET_SET_FUNC(a)
_GET_SET_FUNC(b) _GET_SET_FUNC(b)
@ -44,7 +44,7 @@ _simple_constructor(Eo *obj, void *class_data, int a)
{ {
Private_Data *pd = class_data; Private_Data *pd = class_data;
eo2_do_super(obj, MY_CLASS, eo2_constructor()); eo_do_super(obj, MY_CLASS, eo_constructor());
pd->a = a; pd->a = a;
printf("%s %d\n", __func__, pd->a); printf("%s %d\n", __func__, pd->a);
@ -55,7 +55,7 @@ _simple_constructor(Eo *obj, void *class_data, int a)
static void static void
_constructor(Eo *obj, void *class_data EINA_UNUSED) _constructor(Eo *obj, void *class_data EINA_UNUSED)
{ {
eo2_do_super(obj, MY_CLASS, eo2_constructor()); eo_do_super(obj, MY_CLASS, eo_constructor());
my_init_count++; my_init_count++;
} }
@ -63,7 +63,7 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED)
static void static void
_destructor(Eo *obj, void *class_data EINA_UNUSED) _destructor(Eo *obj, void *class_data EINA_UNUSED)
{ {
eo2_do_super(obj, MY_CLASS, eo2_destructor()); eo_do_super(obj, MY_CLASS, eo_destructor());
my_init_count--; my_init_count--;
} }
@ -80,30 +80,30 @@ _class_destructor(Eo_Class *klass EINA_UNUSED)
free(class_var); free(class_var);
} }
EO2_VOID_FUNC_BODYV(simple_constructor, EO2_FUNC_CALL(a), int a); EO_VOID_FUNC_BODYV(simple_constructor, EO_FUNC_CALL(a), int a);
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor),
EO2_OP_FUNC_OVERRIDE(eo2_destructor, _destructor), EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor),
EO2_OP_FUNC(simple_constructor, _simple_constructor, "Construct and set A."), EO_OP_FUNC(simple_constructor, _simple_constructor, "Construct and set A."),
EO2_OP_FUNC(simple_a_set, _a_set, "Set property a"), EO_OP_FUNC(simple_a_set, _a_set, "Set property a"),
EO2_OP_FUNC(simple_a_get, _a_get, "Get property a"), EO_OP_FUNC(simple_a_get, _a_get, "Get property a"),
EO2_OP_FUNC(simple_b_set, _b_set, "Set property b"), EO_OP_FUNC(simple_b_set, _b_set, "Set property b"),
EO2_OP_FUNC(simple_b_get, _b_get, "Get property b"), EO_OP_FUNC(simple_b_get, _b_get, "Get property b"),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
sizeof(Private_Data), sizeof(Private_Data),
_class_constructor, _class_constructor,
_class_destructor _class_destructor
}; };
EO_DEFINE_CLASS(simple_class_get, &class_desc, EO2_BASE_CLASS, EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS,
MIXIN_CLASS, NULL); MIXIN_CLASS, NULL);

14
src/tests/eo/constructors/constructors_simple2.c
View File

@ -11,26 +11,26 @@
static void static void
_constructor(Eo *obj, void *class_data EINA_UNUSED) _constructor(Eo *obj, void *class_data EINA_UNUSED)
{ {
eo2_do_super(obj, MY_CLASS, eo2_constructor()); eo_do_super(obj, MY_CLASS, eo_constructor());
eo_error_set(obj); eo_error_set(obj);
} }
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple2", "Simple2",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(simple2_class_get, &class_desc, EO2_BASE_CLASS, NULL); EO_DEFINE_CLASS(simple2_class_get, &class_desc, EO_BASE_CLASS, NULL);

12
src/tests/eo/constructors/constructors_simple3.c
View File

@ -14,21 +14,21 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
(void) obj; (void) obj;
} }
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple3", "Simple3",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(simple3_class_get, &class_desc, EO2_BASE_CLASS, NULL); EO_DEFINE_CLASS(simple3_class_get, &class_desc, EO_BASE_CLASS, NULL);

4
src/tests/eo/constructors/constructors_simple4.c
View File

@ -10,10 +10,10 @@
#define MY_CLASS SIMPLE4_CLASS #define MY_CLASS SIMPLE4_CLASS
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple4", "Simple4",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
0, 0,
NULL, NULL,

12
src/tests/eo/constructors/constructors_simple5.c
View File

@ -14,21 +14,21 @@ _destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
(void) obj; (void) obj;
} }
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(eo2_destructor, _destructor), EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple5", "Simple5",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(simple5_class_get, &class_desc, EO2_BASE_CLASS, NULL); EO_DEFINE_CLASS(simple5_class_get, &class_desc, EO_BASE_CLASS, NULL);

14
src/tests/eo/constructors/constructors_simple6.c
View File

@ -11,26 +11,26 @@
static void static void
_destructor(Eo *obj, void *class_data EINA_UNUSED) _destructor(Eo *obj, void *class_data EINA_UNUSED)
{ {
eo2_do_super(obj, MY_CLASS, eo2_destructor()); eo_do_super(obj, MY_CLASS, eo_destructor());
eo_error_set(obj); eo_error_set(obj);
} }
static Eo2_Op_Description op_descs [] = { static Eo_Op_Description op_descs [] = {
EO2_OP_FUNC_OVERRIDE(eo2_destructor, _destructor), EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple6", "Simple6",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(simple6_class_get, &class_desc, EO2_BASE_CLASS, NULL); EO_DEFINE_CLASS(simple6_class_get, &class_desc, EO_BASE_CLASS, NULL);

12
src/tests/eo/constructors/constructors_simple7.c
View File

@ -15,19 +15,19 @@ static void
_constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
{ {
/* FIXME: Actually test it. */ /* FIXME: Actually test it. */
eo2_do_super(obj, MY_CLASS, eo2_constructor()); eo_do_super(obj, MY_CLASS, eo_constructor());
} }
static Eo2_Op_Description op_descs [] = { static Eo_Op_Description op_descs [] = {
EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple7", "Simple7",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,

4
src/tests/eo/function_overrides/function_overrides_inherit.c
View File

@ -9,10 +9,10 @@
#define MY_CLASS INHERIT_CLASS #define MY_CLASS INHERIT_CLASS
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Inherit", "Inherit",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
0, 0,
NULL, NULL,

32
src/tests/eo/function_overrides/function_overrides_inherit2.c
View File

@ -15,11 +15,11 @@ static void
_a_set(Eo *obj, void *class_data EINA_UNUSED, int a) _a_set(Eo *obj, void *class_data EINA_UNUSED, int a)
{ {
printf("%s %d\n", eo_class_name_get(MY_CLASS), a); printf("%s %d\n", eo_class_name_get(MY_CLASS), a);
eo2_do(obj, simple_a_print()); eo_do(obj, simple_a_print());
eo2_do_super(obj, MY_CLASS, simple_a_set(a + 1)); eo_do_super(obj, MY_CLASS, simple_a_set(a + 1));
Eina_Bool called = EINA_FALSE; Eina_Bool called = EINA_FALSE;
eo2_do_super(obj, MY_CLASS, called = simple_a_print()); eo_do_super(obj, MY_CLASS, called = simple_a_print());
fail_if(!called); fail_if(!called);
} }
@ -28,7 +28,7 @@ _print(Eo *obj, void *class_data EINA_UNUSED)
{ {
Eina_Bool called = EINA_FALSE; Eina_Bool called = EINA_FALSE;
printf("Hey\n"); printf("Hey\n");
eo2_do_super(obj, MY_CLASS, called = inherit2_print()); eo_do_super(obj, MY_CLASS, called = inherit2_print());
fail_if(called); fail_if(called);
return EINA_TRUE; return EINA_TRUE;
@ -47,31 +47,31 @@ _class_print(Eo_Class *klass, void *data EINA_UNUSED)
{ {
Eina_Bool called = EINA_FALSE; Eina_Bool called = EINA_FALSE;
printf("Print %s-%s\n", eo_class_name_get(klass), eo_class_name_get(MY_CLASS)); printf("Print %s-%s\n", eo_class_name_get(klass), eo_class_name_get(MY_CLASS));
eo2_do_super(klass, MY_CLASS, called = simple_class_print()); eo_do_super(klass, MY_CLASS, called = simple_class_print());
fail_if(!called); fail_if(!called);
eo2_do_super(klass, MY_CLASS, called = simple_class_print2()); eo_do_super(klass, MY_CLASS, called = simple_class_print2());
fail_if(!called); fail_if(!called);
return EINA_TRUE; return EINA_TRUE;
} }
EAPI EO2_FUNC_BODY(inherit2_print, Eina_Bool, EINA_FALSE); EAPI EO_FUNC_BODY(inherit2_print, Eina_Bool, EINA_FALSE);
EAPI EO2_FUNC_BODY(inherit2_print2, Eina_Bool, EINA_FALSE); EAPI EO_FUNC_BODY(inherit2_print2, Eina_Bool, EINA_FALSE);
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC(inherit2_print, _print, "Print hey"), EO_OP_FUNC(inherit2_print, _print, "Print hey"),
EO2_OP_FUNC(inherit2_print2, _print2, "Print hey2"), EO_OP_FUNC(inherit2_print2, _print2, "Print hey2"),
EO2_OP_CLASS_FUNC_OVERRIDE(simple_class_print, _class_print), EO_OP_CLASS_FUNC_OVERRIDE(simple_class_print, _class_print),
EO2_OP_FUNC_OVERRIDE(simple_a_set, _a_set), EO_OP_FUNC_OVERRIDE(simple_a_set, _a_set),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Inherit2", "Inherit2",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,

12
src/tests/eo/function_overrides/function_overrides_inherit3.c
View File

@ -13,19 +13,19 @@ static void
_a_set(Eo *obj, void *class_data EINA_UNUSED, int a) _a_set(Eo *obj, void *class_data EINA_UNUSED, int a)
{ {
printf("%s %d\n", eo_class_name_get(MY_CLASS), a); printf("%s %d\n", eo_class_name_get(MY_CLASS), a);
eo2_do_super(obj, MY_CLASS, simple_a_set(a + 1)); eo_do_super(obj, MY_CLASS, simple_a_set(a + 1));
} }
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(simple_a_set, _a_set), EO_OP_FUNC_OVERRIDE(simple_a_set, _a_set),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Inherit3", "Inherit3",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,

34
src/tests/eo/function_overrides/function_overrides_main.c
View File

@ -18,57 +18,57 @@ main(int argc, char *argv[])
eo_init(); eo_init();
Eina_Bool called = EINA_FALSE; Eina_Bool called = EINA_FALSE;
Eo *obj = eo2_add(INHERIT2_CLASS, NULL); Eo *obj = eo_add(INHERIT2_CLASS, NULL);
eo2_do(obj, simple_a_set(1)); eo_do(obj, simple_a_set(1));
Simple_Public_Data *pd = eo_data_scope_get(obj, SIMPLE_CLASS); Simple_Public_Data *pd = eo_data_scope_get(obj, SIMPLE_CLASS);
fail_if(pd->a != 2); fail_if(pd->a != 2);
eo_unref(obj); eo_unref(obj);
obj = eo2_add(INHERIT3_CLASS, NULL); obj = eo_add(INHERIT3_CLASS, NULL);
eo2_do(obj, simple_a_set(1)); eo_do(obj, simple_a_set(1));
pd = eo_data_scope_get(obj, SIMPLE_CLASS); pd = eo_data_scope_get(obj, SIMPLE_CLASS);
fail_if(pd->a != 3); fail_if(pd->a != 3);
eo_unref(obj); eo_unref(obj);
obj = eo2_add(INHERIT2_CLASS, NULL); obj = eo_add(INHERIT2_CLASS, NULL);
eo2_do(obj, called = inherit2_print()); eo_do(obj, called = inherit2_print());
fail_if(!called); fail_if(!called);
eo2_do(obj, called = inherit2_print(), called = inherit2_print()); eo_do(obj, called = inherit2_print(), called = inherit2_print());
fail_if(!called); fail_if(!called);
eo_unref(obj); eo_unref(obj);
obj = eo2_add(SIMPLE_CLASS, NULL); obj = eo_add(SIMPLE_CLASS, NULL);
eo2_do(obj, called = inherit2_print()); eo_do(obj, called = inherit2_print());
fail_if(called); fail_if(called);
#ifdef EO_DEBUG #ifdef EO_DEBUG
eo2_do(obj, called = simple_class_print()); eo_do(obj, called = simple_class_print());
fail_if(called); fail_if(called);
#endif #endif
eo2_do(SIMPLE_CLASS, called = simple_class_print()); eo_do(SIMPLE_CLASS, called = simple_class_print());
fail_if(!called); fail_if(!called);
eo2_do(INHERIT_CLASS, called = simple_class_print()); eo_do(INHERIT_CLASS, called = simple_class_print());
fail_if(!called); fail_if(!called);
eo2_do(INHERIT2_CLASS, called = simple_class_print()); eo_do(INHERIT2_CLASS, called = simple_class_print());
fail_if(!called); fail_if(!called);
eo2_do(INHERIT3_CLASS, called = simple_class_print()); eo_do(INHERIT3_CLASS, called = simple_class_print());
fail_if(!called); fail_if(!called);
#ifdef EO_DEBUG #ifdef EO_DEBUG
eo2_do(SIMPLE_CLASS, called = simple_a_print()); eo_do(SIMPLE_CLASS, called = simple_a_print());
fail_if(called); fail_if(called);
#endif #endif
eo2_do_super(obj, SIMPLE_CLASS, eo2_constructor()); eo_do_super(obj, SIMPLE_CLASS, eo_constructor());
eo2_do_super(obj, SIMPLE_CLASS, eo2_destructor()); eo_do_super(obj, SIMPLE_CLASS, eo_destructor());
eo_unref(obj); eo_unref(obj);

30
src/tests/eo/function_overrides/function_overrides_simple.c
View File

@ -34,10 +34,10 @@ _class_print(Eo_Class *klass, void *class_data EINA_UNUSED)
{ {
printf("Print %s-%s\n", eo_class_name_get(klass), eo_class_name_get(MY_CLASS)); printf("Print %s-%s\n", eo_class_name_get(klass), eo_class_name_get(MY_CLASS));
Eina_Bool called = EINA_FALSE; Eina_Bool called = EINA_FALSE;
eo2_do_super(klass, MY_CLASS, called = simple_class_print()); eo_do_super(klass, MY_CLASS, called = simple_class_print());
fail_if(called); fail_if(called);
eo2_do_super(klass, MY_CLASS, called = simple_class_print2()); eo_do_super(klass, MY_CLASS, called = simple_class_print2());
fail_if(called); fail_if(called);
return EINA_TRUE; return EINA_TRUE;
@ -51,29 +51,29 @@ _class_print2(Eo_Class *klass, void *class_data EINA_UNUSED)
return EINA_TRUE; return EINA_TRUE;
} }
EAPI EO2_VOID_FUNC_BODYV(simple_a_set, EO2_FUNC_CALL(a), int a); EAPI EO_VOID_FUNC_BODYV(simple_a_set, EO_FUNC_CALL(a), int a);
EAPI EO2_FUNC_BODY(simple_a_print, Eina_Bool, EINA_FALSE); EAPI EO_FUNC_BODY(simple_a_print, Eina_Bool, EINA_FALSE);
EAPI EO2_FUNC_BODY(simple_class_print, Eina_Bool, EINA_FALSE); EAPI EO_FUNC_BODY(simple_class_print, Eina_Bool, EINA_FALSE);
EAPI EO2_FUNC_BODY(simple_class_print2, Eina_Bool, EINA_FALSE); EAPI EO_FUNC_BODY(simple_class_print2, Eina_Bool, EINA_FALSE);
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC(simple_a_set, _a_set, "Set property A"), EO_OP_FUNC(simple_a_set, _a_set, "Set property A"),
EO2_OP_FUNC(simple_a_print, _a_print, "Print property A"), EO_OP_FUNC(simple_a_print, _a_print, "Print property A"),
EO2_OP_FUNC(simple_class_print, _class_print, "Print class name."), EO_OP_FUNC(simple_class_print, _class_print, "Print class name."),
EO2_OP_FUNC(simple_class_print2, _class_print2, "Print2 class name."), EO_OP_FUNC(simple_class_print2, _class_print2, "Print2 class name."),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
sizeof(Simple_Public_Data), sizeof(Simple_Public_Data),
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(simple_class_get, &class_desc, EO2_BASE_CLASS, NULL); EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, NULL);

12
src/tests/eo/interface/interface_interface.c
View File

@ -8,18 +8,18 @@
#define MY_CLASS INTERFACE_CLASS #define MY_CLASS INTERFACE_CLASS
EO2_FUNC_BODY(interface_ab_sum_get, int, 0); EO_FUNC_BODY(interface_ab_sum_get, int, 0);
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC(interface_ab_sum_get, NULL, "Get the sum of a and b."), EO_OP_FUNC(interface_ab_sum_get, NULL, "Get the sum of a and b."),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Interface", "Interface",
EO_CLASS_TYPE_INTERFACE, EO_CLASS_TYPE_INTERFACE,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,

12
src/tests/eo/interface/interface_interface2.c
View File

@ -9,18 +9,18 @@
#define MY_CLASS INTERFACE2_CLASS #define MY_CLASS INTERFACE2_CLASS
EO2_FUNC_BODY(interface2_ab_sum_get2, int, 0); EO_FUNC_BODY(interface2_ab_sum_get2, int, 0);
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC(interface2_ab_sum_get2, NULL, "Print the sum of a and b."), EO_OP_FUNC(interface2_ab_sum_get2, NULL, "Print the sum of a and b."),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Interface2", "Interface2",
EO_CLASS_TYPE_INTERFACE, EO_CLASS_TYPE_INTERFACE,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,

10
src/tests/eo/interface/interface_main.c
View File

@ -16,18 +16,18 @@ main(int argc, char *argv[])
(void) argv; (void) argv;
eo_init(); eo_init();
Eo *obj = eo2_add(SIMPLE_CLASS, NULL); Eo *obj = eo_add(SIMPLE_CLASS, NULL);
eo2_do(obj, simple_a_set(1), simple_b_set(2)); eo_do(obj, simple_a_set(1), simple_b_set(2));
int a = 0, b = 0, sum = 0; int a = 0, b = 0, sum = 0;
eo2_do(obj, a = simple_a_get(), b = simple_b_get(), sum = interface_ab_sum_get()); eo_do(obj, a = simple_a_get(), b = simple_b_get(), sum = interface_ab_sum_get());
fail_if(sum != a + b); fail_if(sum != a + b);
sum = 0; sum = 0;
eo2_do(obj, sum = interface_ab_sum_get(), sum = interface_ab_sum_get()); eo_do(obj, sum = interface_ab_sum_get(), sum = interface_ab_sum_get());
fail_if(sum != a + b); fail_if(sum != a + b);
eo2_do(obj, sum = interface2_ab_sum_get2(), sum = interface2_ab_sum_get2()); eo_do(obj, sum = interface2_ab_sum_get2(), sum = interface2_ab_sum_get2());
fail_if(sum != a + b + 1); fail_if(sum != a + b + 1);
eo_unref(obj); eo_unref(obj);

30
src/tests/eo/interface/interface_simple.c
View File

@ -30,8 +30,8 @@ _##name##_set(Eo *obj EINA_UNUSED, void *class_data, int name) \
pd->name = name; \ pd->name = name; \
printf("%s %d\n", __func__, pd->name); \ printf("%s %d\n", __func__, pd->name); \
} \ } \
EO2_VOID_FUNC_BODYV(simple_##name##_set, EO2_FUNC_CALL(name), int name); \ EO_VOID_FUNC_BODYV(simple_##name##_set, EO_FUNC_CALL(name), int name); \
EO2_FUNC_BODY(simple_##name##_get, int, 0); EO_FUNC_BODY(simple_##name##_get, int, 0);
_GET_SET_FUNC(a) _GET_SET_FUNC(a)
_GET_SET_FUNC(b) _GET_SET_FUNC(b)
@ -40,7 +40,7 @@ static int
_ab_sum_get(Eo *obj, void *class_data EINA_UNUSED) _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED)
{ {
int a = 0, b = 0; int a = 0, b = 0;
eo2_do(obj, a = simple_a_get(), b = simple_b_get()); eo_do(obj, a = simple_a_get(), b = simple_b_get());
printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__); printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__);
return a + b; return a + b;
} }
@ -49,30 +49,30 @@ static int
_ab_sum_get2(Eo *obj, void *class_data EINA_UNUSED) _ab_sum_get2(Eo *obj, void *class_data EINA_UNUSED)
{ {
int a = 0, b = 0; int a = 0, b = 0;
eo2_do(obj, a = simple_a_get(), b = simple_b_get()); eo_do(obj, a = simple_a_get(), b = simple_b_get());
printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__); printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__);
return a + b + 1; return a + b + 1;
} }
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC(simple_a_set, _a_set, "Set property a"), EO_OP_FUNC(simple_a_set, _a_set, "Set property a"),
EO2_OP_FUNC(simple_a_get, _a_get, "Get property a"), EO_OP_FUNC(simple_a_get, _a_get, "Get property a"),
EO2_OP_FUNC(simple_b_set, _b_set, "Set property b"), EO_OP_FUNC(simple_b_set, _b_set, "Set property b"),
EO2_OP_FUNC(simple_b_get, _b_get, "Get property b"), EO_OP_FUNC(simple_b_get, _b_get, "Get property b"),
EO2_OP_FUNC_OVERRIDE(interface_ab_sum_get, _ab_sum_get), EO_OP_FUNC_OVERRIDE(interface_ab_sum_get, _ab_sum_get),
EO2_OP_FUNC_OVERRIDE(interface2_ab_sum_get2, _ab_sum_get2), EO_OP_FUNC_OVERRIDE(interface2_ab_sum_get2, _ab_sum_get2),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
sizeof(Private_Data), sizeof(Private_Data),
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(simple_class_get, &class_desc, EO2_BASE_CLASS, INTERFACE2_CLASS, NULL); EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, INTERFACE2_CLASS, NULL);

12
src/tests/eo/mixin/mixin_inherit.c
View File

@ -13,22 +13,22 @@ static int
_a_get(Eo *obj, void *class_data EINA_UNUSED) _a_get(Eo *obj, void *class_data EINA_UNUSED)
{ {
int ret = 0; int ret = 0;
eo2_do_super(obj, MY_CLASS, ret = simple_a_get()); eo_do_super(obj, MY_CLASS, ret = simple_a_get());
printf("%s %d\n", __func__, ret); printf("%s %d\n", __func__, ret);
return ret; return ret;
} }
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(simple_a_get, _a_get), EO_OP_FUNC_OVERRIDE(simple_a_get, _a_get),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Inherit", "Inherit",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,

12
src/tests/eo/mixin/mixin_main.c
View File

@ -18,15 +18,15 @@ main(int argc, char *argv[])
(void) argv; (void) argv;
eo_init(); eo_init();
Eo *obj = eo2_add(SIMPLE_CLASS, NULL); Eo *obj = eo_add(SIMPLE_CLASS, NULL);
eo2_do(obj, simple_a_set(1), simple_b_set(2)); eo_do(obj, simple_a_set(1), simple_b_set(2));
int a = 0, b = 0, sum = 0; int a = 0, b = 0, sum = 0;
eo2_do(obj, a = simple_a_get(), b = simple_b_get(), sum = mixin_ab_sum_get()); eo_do(obj, a = simple_a_get(), b = simple_b_get(), sum = mixin_ab_sum_get());
fail_if(sum != a + b + 2); /* 2 for the two mixins... */ fail_if(sum != a + b + 2); /* 2 for the two mixins... */
eo2_do(obj, sum = mixin_ab_sum_get(), sum = mixin_ab_sum_get()); eo_do(obj, sum = mixin_ab_sum_get(), sum = mixin_ab_sum_get());
Mixin2_Public_Data *pd2 = eo_data_scope_get(obj, MIXIN2_CLASS); Mixin2_Public_Data *pd2 = eo_data_scope_get(obj, MIXIN2_CLASS);
fail_if(pd2->count != 6); fail_if(pd2->count != 6);
@ -36,8 +36,8 @@ main(int argc, char *argv[])
eo_unref(obj); eo_unref(obj);
obj = eo2_add(INHERIT_CLASS, NULL); obj = eo_add(INHERIT_CLASS, NULL);
eo2_do(obj, simple_a_set(5), a = simple_a_get()); eo_do(obj, simple_a_set(5), a = simple_a_get());
printf("%d\n", a); printf("%d\n", a);
fail_if(a != 5); fail_if(a != 5);

24
src/tests/eo/mixin/mixin_mixin.c
View File

@ -12,7 +12,7 @@ static int
_ab_sum_get(Eo *obj, void *class_data EINA_UNUSED) _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED)
{ {
int a = 0, b = 0; int a = 0, b = 0;
eo2_do(obj, a = simple_a_get(), b = simple_b_get()); eo_do(obj, a = simple_a_get(), b = simple_b_get());
printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__); printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__);
return a + b; return a + b;
} }
@ -20,34 +20,34 @@ _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED)
static void static void
_constructor(Eo *obj, void *class_data EINA_UNUSED) _constructor(Eo *obj, void *class_data EINA_UNUSED)
{ {
eo2_do_super(obj, MY_CLASS, eo2_constructor()); eo_do_super(obj, MY_CLASS, eo_constructor());
} }
static void static void
_destructor(Eo *obj, void *class_data EINA_UNUSED) _destructor(Eo *obj, void *class_data EINA_UNUSED)
{ {
eo2_do_super(obj, MY_CLASS, eo2_destructor()); eo_do_super(obj, MY_CLASS, eo_destructor());
} }
EAPI EO2_FUNC_BODY(mixin_ab_sum_get, int, 0); EAPI EO_FUNC_BODY(mixin_ab_sum_get, int, 0);
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor),
EO2_OP_FUNC_OVERRIDE(eo2_destructor, _destructor), EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor),
EO2_OP_FUNC(mixin_ab_sum_get, _ab_sum_get, "Get the sum of a and b."), EO_OP_FUNC(mixin_ab_sum_get, _ab_sum_get, "Get the sum of a and b."),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Mixin", "Mixin",
EO_CLASS_TYPE_MIXIN, EO_CLASS_TYPE_MIXIN,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(mixin_class_get, &class_desc, NULL, EO2_BASE_CLASS, NULL) EO_DEFINE_CLASS(mixin_class_get, &class_desc, NULL, EO_BASE_CLASS, NULL)

22
src/tests/eo/mixin/mixin_mixin2.c
View File

@ -18,14 +18,14 @@ _ab_sum_get(Eo *obj, void *class_data)
Mixin2_Public_Data *pd = (Mixin2_Public_Data *) class_data; Mixin2_Public_Data *pd = (Mixin2_Public_Data *) class_data;
int sum = 0; int sum = 0;
printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__); printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__);
eo2_do_super(obj, MY_CLASS, sum = mixin_ab_sum_get()); eo_do_super(obj, MY_CLASS, sum = mixin_ab_sum_get());
++sum; ++sum;
pd->count += 2; pd->count += 2;
{ {
int _a = 0, _b = 0; int _a = 0, _b = 0;
eo2_do(obj, _a = simple_a_get(), _b = simple_b_get()); eo_do(obj, _a = simple_a_get(), _b = simple_b_get());
fail_if(sum != _a + _b + 1); fail_if(sum != _a + _b + 1);
} }
@ -35,27 +35,27 @@ _ab_sum_get(Eo *obj, void *class_data)
static void static void
_constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
{ {
eo2_do_super(obj, MY_CLASS, eo2_constructor()); eo_do_super(obj, MY_CLASS, eo_constructor());
} }
static void static void
_destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) _destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
{ {
eo2_do_super(obj, MY_CLASS, eo2_destructor()); eo_do_super(obj, MY_CLASS, eo_destructor());
} }
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor),
EO2_OP_FUNC_OVERRIDE(eo2_destructor, _destructor), EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor),
EO2_OP_FUNC_OVERRIDE(mixin_ab_sum_get, _ab_sum_get), EO_OP_FUNC_OVERRIDE(mixin_ab_sum_get, _ab_sum_get),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Mixin2", "Mixin2",
EO_CLASS_TYPE_MIXIN, EO_CLASS_TYPE_MIXIN,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
sizeof(Mixin2_Public_Data), sizeof(Mixin2_Public_Data),
NULL, NULL,

22
src/tests/eo/mixin/mixin_mixin3.c
View File

@ -18,14 +18,14 @@ _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED)
Mixin3_Public_Data *pd = (Mixin3_Public_Data *) class_data; Mixin3_Public_Data *pd = (Mixin3_Public_Data *) class_data;
int sum = 0; int sum = 0;
printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__); printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__);
eo2_do_super(obj, MY_CLASS, sum = mixin_ab_sum_get()); eo_do_super(obj, MY_CLASS, sum = mixin_ab_sum_get());
++sum; ++sum;
pd->count += 3; pd->count += 3;
{ {
int _a = 0, _b = 0; int _a = 0, _b = 0;
eo2_do(obj, _a = simple_a_get(), _b = simple_b_get()); eo_do(obj, _a = simple_a_get(), _b = simple_b_get());
fail_if(sum != _a + _b + 2); fail_if(sum != _a + _b + 2);
} }
@ -35,27 +35,27 @@ _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED)
static void static void
_constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
{ {
eo2_do_super(obj, MY_CLASS, eo2_constructor()); eo_do_super(obj, MY_CLASS, eo_constructor());
} }
static void static void
_destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) _destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED)
{ {
eo2_do_super(obj, MY_CLASS, eo2_destructor()); eo_do_super(obj, MY_CLASS, eo_destructor());
} }
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor),
EO2_OP_FUNC_OVERRIDE(eo2_destructor, _destructor), EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor),
EO2_OP_FUNC_OVERRIDE(mixin_ab_sum_get, _ab_sum_get), EO_OP_FUNC_OVERRIDE(mixin_ab_sum_get, _ab_sum_get),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Mixin3", "Mixin3",
EO_CLASS_TYPE_MIXIN, EO_CLASS_TYPE_MIXIN,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
sizeof(Mixin3_Public_Data), sizeof(Mixin3_Public_Data),
NULL, NULL,

4
src/tests/eo/mixin/mixin_mixin4.c
View File

@ -12,10 +12,10 @@
#define MY_CLASS MIXIN4_CLASS #define MY_CLASS MIXIN4_CLASS
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Mixin4", "Mixin4",
EO_CLASS_TYPE_MIXIN, EO_CLASS_TYPE_MIXIN,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
0, 0,
NULL, NULL,

22
src/tests/eo/mixin/mixin_simple.c
View File

@ -31,31 +31,31 @@ _##name##_set(Eo *obj EINA_UNUSED, void *class_data, int name) \
pd->name = name; \ pd->name = name; \
printf("%s %d\n", __func__, pd->name); \ printf("%s %d\n", __func__, pd->name); \
} \ } \
EO2_VOID_FUNC_BODYV(simple_##name##_set, EO2_FUNC_CALL(name), int name); \ EO_VOID_FUNC_BODYV(simple_##name##_set, EO_FUNC_CALL(name), int name); \
EO2_FUNC_BODY(simple_##name##_get, int, 0); EO_FUNC_BODY(simple_##name##_get, int, 0);
_GET_SET_FUNC(a) _GET_SET_FUNC(a)
_GET_SET_FUNC(b) _GET_SET_FUNC(b)
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC(simple_a_set, _a_set, "Set property a"), EO_OP_FUNC(simple_a_set, _a_set, "Set property a"),
EO2_OP_FUNC(simple_a_get, _a_get, "Get property a"), EO_OP_FUNC(simple_a_get, _a_get, "Get property a"),
EO2_OP_FUNC(simple_b_set, _b_set, "Set property b"), EO_OP_FUNC(simple_b_set, _b_set, "Set property b"),
EO2_OP_FUNC(simple_b_get, _b_get, "Get property b"), EO_OP_FUNC(simple_b_get, _b_get, "Get property b"),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
sizeof(Private_Data), sizeof(Private_Data),
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(simple_class_get, &class_desc, EO2_BASE_CLASS, EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS,
MIXIN3_CLASS, MIXIN2_CLASS, NULL); MIXIN3_CLASS, MIXIN2_CLASS, NULL);

110
src/tests/eo/signals/signals_main.c
View File

@ -29,8 +29,8 @@ _a_changed_cb(void *data, Eo *obj, const Eo_Event_Description *desc, void *event
cb_count++; cb_count++;
eo2_do(obj, eo2_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _null_cb, (void *) 23423)); eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _null_cb, (void *) 23423));
eo2_do(obj, eo2_event_callback_del(EV_A_CHANGED, _null_cb, (void *) 23423)); eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _null_cb, (void *) 23423));
/* Stop as we reached the 3rd one. */ /* Stop as we reached the 3rd one. */
return (cb_count != 3); return (cb_count != 3);
@ -43,136 +43,136 @@ main(int argc, char *argv[])
(void) argv; (void) argv;
eo_init(); eo_init();
Eo *obj = eo2_add(SIMPLE_CLASS, NULL); Eo *obj = eo_add(SIMPLE_CLASS, NULL);
Simple_Public_Data *pd = eo_data_scope_get(obj, SIMPLE_CLASS); Simple_Public_Data *pd = eo_data_scope_get(obj, SIMPLE_CLASS);
/* The order of these two is undetermined. */ /* The order of these two is undetermined. */
eo2_do(obj, eo2_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2)); eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2));
eo2_do(obj, eo2_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1)); eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1));
/* This will be called afterwards. */ /* This will be called afterwards. */
eo2_do(obj, eo2_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_DEFAULT, _a_changed_cb, (void *) 3)); eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_DEFAULT, _a_changed_cb, (void *) 3));
/* This will never be called because the previous callback returns NULL. */ /* This will never be called because the previous callback returns NULL. */
eo2_do(obj, eo2_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_AFTER, _a_changed_cb, (void *) 4)); eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_AFTER, _a_changed_cb, (void *) 4));
eo2_do(obj, simple_a_set(1)); eo_do(obj, simple_a_set(1));
fail_if(cb_count != 3); fail_if(cb_count != 3);
eo2_do(obj, eo2_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 3)); eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 3));
fail_if(pd->cb_count != 3); fail_if(pd->cb_count != 3);
eo2_do(obj, eo2_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 12)); eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 12));
fail_if(pd->cb_count != 3); fail_if(pd->cb_count != 3);
eo2_do(obj, eo2_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 4)); eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 4));
fail_if(pd->cb_count != 2); fail_if(pd->cb_count != 2);
eo2_do(obj, eo2_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 2)); eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 2));
fail_if(pd->cb_count != 1); fail_if(pd->cb_count != 1);
eo2_do(obj, eo2_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 1)); eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 1));
fail_if(pd->cb_count != 0); fail_if(pd->cb_count != 0);
/* Freeze/thaw. */ /* Freeze/thaw. */
int fcount = 0; int fcount = 0;
cb_count = 0; cb_count = 0;
eo2_do(obj, eo2_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1)); eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1));
fail_if(pd->cb_count != 1); fail_if(pd->cb_count != 1);
eo2_do(obj, fcount = eo2_event_freeze_get()); eo_do(obj, fcount = eo_event_freeze_get());
fail_if(fcount != 0); fail_if(fcount != 0);
eo2_do(obj, eo2_event_freeze()); eo_do(obj, eo_event_freeze());
eo2_do(obj, fcount = eo2_event_freeze_get()); eo_do(obj, fcount = eo_event_freeze_get());
fail_if(fcount != 1); fail_if(fcount != 1);
eo2_do(obj, eo2_event_freeze()); eo_do(obj, eo_event_freeze());
eo2_do(obj, fcount = eo2_event_freeze_get()); eo_do(obj, fcount = eo_event_freeze_get());
fail_if(fcount != 2); fail_if(fcount != 2);
eo2_do(obj, eo2_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2)); eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2));
fail_if(pd->cb_count != 1); fail_if(pd->cb_count != 1);
eo2_do(obj, simple_a_set(2)); eo_do(obj, simple_a_set(2));
fail_if(cb_count != 0); fail_if(cb_count != 0);
eo2_do(obj, eo2_event_thaw()); eo_do(obj, eo_event_thaw());
eo2_do(obj, fcount = eo2_event_freeze_get()); eo_do(obj, fcount = eo_event_freeze_get());
fail_if(fcount != 1); fail_if(fcount != 1);
eo2_do(obj, eo2_event_thaw()); eo_do(obj, eo_event_thaw());
eo2_do(obj, fcount = eo2_event_freeze_get()); eo_do(obj, fcount = eo_event_freeze_get());
fail_if(fcount != 0); fail_if(fcount != 0);
eo2_do(obj, simple_a_set(3)); eo_do(obj, simple_a_set(3));
fail_if(cb_count != 2); fail_if(cb_count != 2);
cb_count = 0; cb_count = 0;
eo2_do(obj, eo2_event_thaw()); eo_do(obj, eo_event_thaw());
eo2_do(obj, fcount = eo2_event_freeze_get()); eo_do(obj, fcount = eo_event_freeze_get());
fail_if(fcount != 0); fail_if(fcount != 0);
eo2_do(obj, eo2_event_freeze()); eo_do(obj, eo_event_freeze());
eo2_do(obj, fcount = eo2_event_freeze_get()); eo_do(obj, fcount = eo_event_freeze_get());
fail_if(fcount != 1); fail_if(fcount != 1);
eo2_do(obj, simple_a_set(2)); eo_do(obj, simple_a_set(2));
fail_if(cb_count != 0); fail_if(cb_count != 0);
eo2_do(obj, eo2_event_thaw()); eo_do(obj, eo_event_thaw());
eo2_do(obj, fcount = eo2_event_freeze_get()); eo_do(obj, fcount = eo_event_freeze_get());
fail_if(fcount != 0); fail_if(fcount != 0);
eo2_do(obj, eo2_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 1)); eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 1));
fail_if(pd->cb_count != 0); fail_if(pd->cb_count != 0);
eo2_do(obj, eo2_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 2)); eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 2));
fail_if(pd->cb_count != -1); fail_if(pd->cb_count != -1);
/* Global Freeze/thaw. */ /* Global Freeze/thaw. */
fcount = 0; fcount = 0;
cb_count = 0; cb_count = 0;
pd->cb_count = 0; pd->cb_count = 0;
eo2_do(obj, eo2_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1)); eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 1));
fail_if(pd->cb_count != 1); fail_if(pd->cb_count != 1);
eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get());
fail_if(fcount != 0); fail_if(fcount != 0);
eo2_do(EO2_BASE_CLASS, eo2_event_global_freeze()); eo_do(EO_BASE_CLASS, eo_event_global_freeze());
eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get());
fail_if(fcount != 1); fail_if(fcount != 1);
eo2_do(EO2_BASE_CLASS, eo2_event_global_freeze()); eo_do(EO_BASE_CLASS, eo_event_global_freeze());
eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get());
fail_if(fcount != 2); fail_if(fcount != 2);
eo2_do(obj, eo2_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2)); eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2));
fail_if(pd->cb_count != 1); fail_if(pd->cb_count != 1);
eo2_do(obj, simple_a_set(2)); eo_do(obj, simple_a_set(2));
fail_if(cb_count != 0); fail_if(cb_count != 0);
eo2_do(EO2_BASE_CLASS, eo2_event_global_thaw()); eo_do(EO_BASE_CLASS, eo_event_global_thaw());
eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get());
fail_if(fcount != 1); fail_if(fcount != 1);
eo2_do(EO2_BASE_CLASS, eo2_event_global_thaw()); eo_do(EO_BASE_CLASS, eo_event_global_thaw());
eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get());
fail_if(fcount != 0); fail_if(fcount != 0);
eo2_do(obj, simple_a_set(3)); eo_do(obj, simple_a_set(3));
fail_if(cb_count != 2); fail_if(cb_count != 2);
cb_count = 0; cb_count = 0;
eo2_do(EO2_BASE_CLASS, eo2_event_global_thaw()); eo_do(EO_BASE_CLASS, eo_event_global_thaw());
eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get());
fail_if(fcount != 0); fail_if(fcount != 0);
eo2_do(EO2_BASE_CLASS, eo2_event_global_freeze()); eo_do(EO_BASE_CLASS, eo_event_global_freeze());
eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get());
fail_if(fcount != 1); fail_if(fcount != 1);
eo2_do(obj, simple_a_set(2)); eo_do(obj, simple_a_set(2));
fail_if(cb_count != 0); fail_if(cb_count != 0);
eo2_do(EO2_BASE_CLASS, eo2_event_global_thaw()); eo_do(EO_BASE_CLASS, eo_event_global_thaw());
eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get());
fail_if(fcount != 0); fail_if(fcount != 0);

26
src/tests/eo/signals/signals_simple.c
View File

@ -23,7 +23,7 @@ _a_set(Eo *obj, void *class_data, int a)
pd->a = a; pd->a = a;
printf("%s %d\n", __func__, pd->a); printf("%s %d\n", __func__, pd->a);
eo2_do(obj, eo2_event_callback_call(EV_A_CHANGED, &pd->a)); eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a));
} }
Eina_Bool Eina_Bool
@ -63,20 +63,20 @@ _cb_deled(void *data, Eo *obj, const Eo_Event_Description *desc, void *event_inf
static void static void
_constructor(Eo *obj, void *class_data EINA_UNUSED) _constructor(Eo *obj, void *class_data EINA_UNUSED)
{ {
eo2_do_super(obj, MY_CLASS, eo2_constructor()); eo_do_super(obj, MY_CLASS, eo_constructor());
eo2_do(obj, eo2_event_callback_add(EO_EV_CALLBACK_ADD, _cb_added, NULL)); eo_do(obj, eo_event_callback_add(EO_EV_CALLBACK_ADD, _cb_added, NULL));
eo2_do(obj, eo2_event_callback_add(EO_EV_CALLBACK_DEL, _cb_deled, NULL)); eo_do(obj, eo_event_callback_add(EO_EV_CALLBACK_DEL, _cb_deled, NULL));
eo2_do(obj, eo2_base_data_set("cb_count", (intptr_t) 0, NULL)); eo_do(obj, eo_base_data_set("cb_count", (intptr_t) 0, NULL));
} }
EAPI EO2_VOID_FUNC_BODYV(simple_a_set, EO2_FUNC_CALL(a), int a); EAPI EO_VOID_FUNC_BODYV(simple_a_set, EO_FUNC_CALL(a), int a);
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor),
EO2_OP_FUNC(simple_a_set, _a_set, "Set property a"), EO_OP_FUNC(simple_a_set, _a_set, "Set property a"),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
@ -86,15 +86,15 @@ static const Eo_Event_Description *event_desc[] = {
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
event_desc, event_desc,
sizeof(Private_Data), sizeof(Private_Data),
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(simple_class_get, &class_desc, EO2_BASE_CLASS, NULL); EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, NULL);

18
src/tests/eo/suite/eo_test_call_errors.c
View File

@ -16,11 +16,11 @@ START_TEST(eo_pure_virtual_fct_call)
eo_init(); eo_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx); eina_log_print_cb_set(eo_test_print_cb, &ctx);
Eo *obj = eo2_add(SIMPLE_CLASS, NULL); Eo *obj = eo_add(SIMPLE_CLASS, NULL);
fail_if(!obj); fail_if(!obj);
TEST_EO_ERROR("_eo2_call_resolve", "in %s:%d: you called a pure virtual func '%s' (%d)."); TEST_EO_ERROR("_eo_call_resolve", "in %s:%d: you called a pure virtual func '%s' (%d).");
eo2_do(obj, simple_pure_virtual()); eo_do(obj, simple_pure_virtual());
fail_unless(ctx.did); fail_unless(ctx.did);
eo_unref(obj); eo_unref(obj);
@ -34,11 +34,11 @@ START_TEST(eo_api_not_implemented_call)
eo_init(); eo_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx); eina_log_print_cb_set(eo_test_print_cb, &ctx);
Eo *obj = eo2_add(SIMPLE_CLASS, NULL); Eo *obj = eo_add(SIMPLE_CLASS, NULL);
fail_if(!obj); fail_if(!obj);
TEST_EO_ERROR("_eo2_api_op_id_get", "in %s:%d: unable to resolve %s api func %p."); TEST_EO_ERROR("_eo_api_op_id_get", "in %s:%d: unable to resolve %s api func %p.");
eo2_do(obj, simple_no_implementation()); eo_do(obj, simple_no_implementation());
fail_unless(ctx.did); fail_unless(ctx.did);
eo_unref(obj); eo_unref(obj);
@ -52,11 +52,11 @@ START_TEST(eo_op_not_found_in_super)
eo_init(); eo_init();
eina_log_print_cb_set(eo_test_print_cb, &ctx); eina_log_print_cb_set(eo_test_print_cb, &ctx);
Eo *obj = eo2_add(SIMPLE_CLASS, NULL); Eo *obj = eo_add(SIMPLE_CLASS, NULL);
fail_if(!obj); fail_if(!obj);
TEST_EO_ERROR("_eo2_call_resolve", "in %s:%d: func '%s' (%d) could not be resolved for class '%s' for super of '%s'."); TEST_EO_ERROR("_eo_call_resolve", "in %s:%d: func '%s' (%d) could not be resolved for class '%s' for super of '%s'.");
eo2_do_super(obj, SIMPLE_CLASS, simple_a_set(10)); eo_do_super(obj, SIMPLE_CLASS, simple_a_set(10));
fail_unless(ctx.did); fail_unless(ctx.did);
eo_unref(obj); eo_unref(obj);

90
src/tests/eo/suite/eo_test_class_errors.c
View File

@ -21,10 +21,10 @@ START_TEST(eo_inherit_errors)
const Eo_Class *klass_simple; const Eo_Class *klass_simple;
static const Eo_Class_Description class_desc_simple = { static const Eo_Class_Description class_desc_simple = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
0, 0,
NULL, NULL,
@ -32,10 +32,10 @@ START_TEST(eo_inherit_errors)
}; };
static const Eo_Class_Description class_desc_mixin = { static const Eo_Class_Description class_desc_mixin = {
EO2_VERSION, EO_VERSION,
"Mixin", "Mixin",
EO_CLASS_TYPE_MIXIN, EO_CLASS_TYPE_MIXIN,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
0, 0,
NULL, NULL,
@ -43,10 +43,10 @@ START_TEST(eo_inherit_errors)
}; };
static Eo_Class_Description class_desc = { static Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"General", "General",
EO_CLASS_TYPE_MIXIN, EO_CLASS_TYPE_MIXIN,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
0, 0,
NULL, NULL,
@ -56,7 +56,7 @@ START_TEST(eo_inherit_errors)
klass_mixin = eo_class_new(&class_desc_mixin, NULL, NULL); klass_mixin = eo_class_new(&class_desc_mixin, NULL, NULL);
fail_if(!klass_mixin); fail_if(!klass_mixin);
klass_simple = eo_class_new(&class_desc_simple, EO2_BASE_CLASS, NULL); klass_simple = eo_class_new(&class_desc_simple, EO_BASE_CLASS, NULL);
fail_if(!klass_simple); fail_if(!klass_simple);
TEST_EO_ERROR("eo_class_new", "Non-regular classes ('%s') aren't allowed to inherit from regular classes ('%s')."); TEST_EO_ERROR("eo_class_new", "Non-regular classes ('%s') aren't allowed to inherit from regular classes ('%s').");
@ -89,10 +89,10 @@ START_TEST(eo_inconsistent_mro)
const Eo_Class *klass_mixin3; const Eo_Class *klass_mixin3;
static const Eo_Class_Description class_desc_simple = { static const Eo_Class_Description class_desc_simple = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
0, 0,
NULL, NULL,
@ -100,10 +100,10 @@ START_TEST(eo_inconsistent_mro)
}; };
static const Eo_Class_Description class_desc_mixin = { static const Eo_Class_Description class_desc_mixin = {
EO2_VERSION, EO_VERSION,
"Mixin", "Mixin",
EO_CLASS_TYPE_MIXIN, EO_CLASS_TYPE_MIXIN,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
0, 0,
NULL, NULL,
@ -111,10 +111,10 @@ START_TEST(eo_inconsistent_mro)
}; };
static const Eo_Class_Description class_desc_mixin2 = { static const Eo_Class_Description class_desc_mixin2 = {
EO2_VERSION, EO_VERSION,
"Mixin2", "Mixin2",
EO_CLASS_TYPE_MIXIN, EO_CLASS_TYPE_MIXIN,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
0, 0,
NULL, NULL,
@ -122,10 +122,10 @@ START_TEST(eo_inconsistent_mro)
}; };
static const Eo_Class_Description class_desc_mixin3 = { static const Eo_Class_Description class_desc_mixin3 = {
EO2_VERSION, EO_VERSION,
"Mixin3", "Mixin3",
EO_CLASS_TYPE_MIXIN, EO_CLASS_TYPE_MIXIN,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
0, 0,
NULL, NULL,
@ -142,14 +142,14 @@ START_TEST(eo_inconsistent_mro)
fail_if(!klass_mixin3); fail_if(!klass_mixin3);
TEST_EO_ERROR("_eo_class_mro_init", "Cannot create a consistent method resolution order for class '%s' because of '%s'."); TEST_EO_ERROR("_eo_class_mro_init", "Cannot create a consistent method resolution order for class '%s' because of '%s'.");
klass = eo_class_new(&class_desc_simple, EO2_BASE_CLASS, klass_mixin, klass_mixin2, NULL); klass = eo_class_new(&class_desc_simple, EO_BASE_CLASS, klass_mixin, klass_mixin2, NULL);
fail_if(klass); fail_if(klass);
fail_unless(ctx.did); fail_unless(ctx.did);
klass = eo_class_new(&class_desc_simple, EO2_BASE_CLASS, klass_mixin2, klass_mixin, NULL); klass = eo_class_new(&class_desc_simple, EO_BASE_CLASS, klass_mixin2, klass_mixin, NULL);
fail_if(!klass); fail_if(!klass);
klass = eo_class_new(&class_desc_simple, EO2_BASE_CLASS, klass_mixin2, klass_mixin3, NULL); klass = eo_class_new(&class_desc_simple, EO_BASE_CLASS, klass_mixin2, klass_mixin3, NULL);
fail_if(!klass); fail_if(!klass);
eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); eina_log_print_cb_set(eina_log_print_cb_stderr, NULL);
@ -168,10 +168,10 @@ START_TEST(eo_bad_interface)
const Eo_Class *klass; const Eo_Class *klass;
static Eo_Class_Description class_desc = { static Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Interface", "Interface",
EO_CLASS_TYPE_INTERFACE, EO_CLASS_TYPE_INTERFACE,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
10, 10,
NULL, NULL,
@ -216,22 +216,22 @@ START_TEST(eo_null_api)
const Eo_Class *klass; const Eo_Class *klass;
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC(NULL, _null_fct, "NULL API function"), EO_OP_FUNC(NULL, _null_fct, "NULL API function"),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static Eo_Class_Description class_desc = { static Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,
NULL NULL
}; };
TEST_EO_ERROR("_eo2_class_funcs_set", "Class '%s': NULL API not allowed (%d NULL->%p '%s')."); TEST_EO_ERROR("_eo_class_funcs_set", "Class '%s': NULL API not allowed (%d NULL->%p '%s').");
klass = eo_class_new(&class_desc, NULL, NULL); klass = eo_class_new(&class_desc, NULL, NULL);
fail_if(klass); fail_if(klass);
fail_unless(ctx.did); fail_unless(ctx.did);
@ -249,22 +249,22 @@ START_TEST(eo_wrong_override)
const Eo_Class *klass; const Eo_Class *klass;
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(null_fct, _null_fct), EO_OP_FUNC_OVERRIDE(null_fct, _null_fct),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static Eo_Class_Description class_desc = { static Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,
NULL NULL
}; };
TEST_EO_ERROR("_eo2_class_funcs_set", "Class '%s': Can't find api func description in class hierarchy (%p->%p)."); TEST_EO_ERROR("_eo_class_funcs_set", "Class '%s': Can't find api func description in class hierarchy (%p->%p).");
klass = eo_class_new(&class_desc, NULL, NULL); klass = eo_class_new(&class_desc, NULL, NULL);
fail_if(klass); fail_if(klass);
fail_unless(ctx.did); fail_unless(ctx.did);
@ -282,23 +282,23 @@ START_TEST(eo_api_redefined)
const Eo_Class *klass; const Eo_Class *klass;
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC(null_fct, _null_fct, "API function"), EO_OP_FUNC(null_fct, _null_fct, "API function"),
EO2_OP_FUNC(null_fct, NULL, "Redefining API function"), EO_OP_FUNC(null_fct, NULL, "Redefining API function"),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static Eo_Class_Description class_desc = { static Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,
NULL NULL
}; };
TEST_EO_ERROR("_eo2_class_funcs_set", "Class '%s': API previously defined (%d %p->%p '%s')."); TEST_EO_ERROR("_eo_class_funcs_set", "Class '%s': API previously defined (%d %p->%p '%s').");
klass = eo_class_new(&class_desc, NULL, NULL); klass = eo_class_new(&class_desc, NULL, NULL);
fail_if(klass); fail_if(klass);
fail_unless(ctx.did); fail_unless(ctx.did);
@ -316,16 +316,16 @@ START_TEST(eo_dich_func_override)
const Eo_Class *klass; const Eo_Class *klass;
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(simple_a_set, _null_fct), EO_OP_FUNC_OVERRIDE(simple_a_set, _null_fct),
EO2_OP_FUNC_OVERRIDE(simple_a_set, NULL), EO_OP_FUNC_OVERRIDE(simple_a_set, NULL),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static Eo_Class_Description class_desc = { static Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
0, 0,
NULL, NULL,

44
src/tests/eo/suite/eo_test_class_simple.c
View File

@ -17,7 +17,7 @@ _a_set(Eo *obj EINA_UNUSED, void *class_data, int a)
printf("%s %d\n", eo_class_name_get(MY_CLASS), a); printf("%s %d\n", eo_class_name_get(MY_CLASS), a);
pd->a = a; pd->a = a;
eo2_do(obj, eo2_event_callback_call(EV_A_CHANGED, &pd->a)); eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a));
} }
static int static int
@ -45,7 +45,7 @@ _class_hi_print(Eo_Class *klass, void *data EINA_UNUSED)
return EINA_TRUE; return EINA_TRUE;
} }
EO2_VOID_FUNC_BODYV(simple_recursive, EO2_FUNC_CALL(n), int n); EO_VOID_FUNC_BODYV(simple_recursive, EO_FUNC_CALL(n), int n);
static void static void
_recursive(Eo *obj, void *class_data EINA_UNUSED, int n) _recursive(Eo *obj, void *class_data EINA_UNUSED, int n)
@ -55,7 +55,7 @@ _recursive(Eo *obj, void *class_data EINA_UNUSED, int n)
if (count < n) if (count < n)
{ {
count++; count++;
eo2_do(obj, simple_recursive(n)); eo_do(obj, simple_recursive(n));
} }
else else
count = 0; count = 0;
@ -64,39 +64,39 @@ _recursive(Eo *obj, void *class_data EINA_UNUSED, int n)
static void static void
_dbg_info_get(Eo *eo_obj, void *_pd EINA_UNUSED, Eo_Dbg_Info *root) _dbg_info_get(Eo *eo_obj, void *_pd EINA_UNUSED, Eo_Dbg_Info *root)
{ {
eo2_do_super(eo_obj, MY_CLASS, eo2_dbg_info_get(root)); eo_do_super(eo_obj, MY_CLASS, eo_dbg_info_get(root));
Eo_Dbg_Info *group = EO_DBG_INFO_LIST_APPEND(root, "Test list"); Eo_Dbg_Info *group = EO_DBG_INFO_LIST_APPEND(root, "Test list");
EO_DBG_INFO_APPEND(group, "Test", EINA_VALUE_TYPE_INT, 8); EO_DBG_INFO_APPEND(group, "Test", EINA_VALUE_TYPE_INT, 8);
} }
EO2_VOID_FUNC_BODYV(simple_a_set, EO2_FUNC_CALL(a), int a); EO_VOID_FUNC_BODYV(simple_a_set, EO_FUNC_CALL(a), int a);
EO2_FUNC_BODY(simple_a_get, int, 0); EO_FUNC_BODY(simple_a_get, int, 0);
EO2_FUNC_BODY(simple_a_print, Eina_Bool, EINA_FALSE); EO_FUNC_BODY(simple_a_print, Eina_Bool, EINA_FALSE);
EO2_FUNC_BODY(simple_class_hi_print, Eina_Bool, EINA_FALSE); EO_FUNC_BODY(simple_class_hi_print, Eina_Bool, EINA_FALSE);
EO2_VOID_FUNC_BODY(simple_pure_virtual); EO_VOID_FUNC_BODY(simple_pure_virtual);
EO2_VOID_FUNC_BODY(simple_no_implementation); EO_VOID_FUNC_BODY(simple_no_implementation);
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(eo2_dbg_info_get, _dbg_info_get), EO_OP_FUNC_OVERRIDE(eo_dbg_info_get, _dbg_info_get),
EO2_OP_FUNC(simple_a_set, _a_set, "Set property a"), EO_OP_FUNC(simple_a_set, _a_set, "Set property a"),
EO2_OP_FUNC(simple_a_get, _a_get, "Get property a"), EO_OP_FUNC(simple_a_get, _a_get, "Get property a"),
EO2_OP_FUNC(simple_a_print, _a_print, "Print property a"), EO_OP_FUNC(simple_a_print, _a_print, "Print property a"),
EO2_OP_CLASS_FUNC(simple_class_hi_print, _class_hi_print, "Print property a"), EO_OP_CLASS_FUNC(simple_class_hi_print, _class_hi_print, "Print property a"),
EO2_OP_FUNC(simple_recursive, _recursive, "Recursive function"), EO_OP_FUNC(simple_recursive, _recursive, "Recursive function"),
EO2_OP_FUNC(simple_pure_virtual, NULL, "Pure Virtual function"), EO_OP_FUNC(simple_pure_virtual, NULL, "Pure Virtual function"),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
sizeof(Simple_Public_Data), sizeof(Simple_Public_Data),
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(simple_class_get, &class_desc, EO2_BASE_CLASS, NULL) EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, NULL)

300
src/tests/eo/suite/eo_test_general.c
View File

@ -11,13 +11,13 @@
START_TEST(eo_simple) START_TEST(eo_simple)
{ {
eo_init(); eo_init();
Eo *obj = eo2_add(EO2_BASE_CLASS, NULL); Eo *obj = eo_add(EO_BASE_CLASS, NULL);
fail_if(obj); fail_if(obj);
obj = eo2_add(SIMPLE_CLASS, NULL); obj = eo_add(SIMPLE_CLASS, NULL);
fail_if(!obj); fail_if(!obj);
eo2_do(obj, eo2_constructor()); eo_do(obj, eo_constructor());
eo2_do(obj, eo2_destructor()); eo_do(obj, eo_destructor());
eo_unref(obj); eo_unref(obj);
eo_shutdown(); eo_shutdown();
@ -27,10 +27,10 @@ END_TEST
START_TEST(eo_stack) START_TEST(eo_stack)
{ {
eo_init(); eo_init();
Eo *obj = eo2_add(SIMPLE_CLASS, NULL); Eo *obj = eo_add(SIMPLE_CLASS, NULL);
fail_if(!obj); fail_if(!obj);
eo2_do(obj, simple_recursive(123)); eo_do(obj, simple_recursive(123));
eo_unref(obj); eo_unref(obj);
@ -94,23 +94,23 @@ START_TEST(eo_signals)
{ EO_EV_DEL, _eo_signals_eo_del_cb }, { EO_EV_DEL, _eo_signals_eo_del_cb },
{ NULL, NULL } { NULL, NULL }
}; };
Eo *obj = eo2_add(SIMPLE_CLASS, NULL); Eo *obj = eo_add(SIMPLE_CLASS, NULL);
eo2_do(obj, eo2_event_callback_add(EO_EV_CALLBACK_ADD, _eo_signals_cb_added_deled, callbacks)); eo_do(obj, eo_event_callback_add(EO_EV_CALLBACK_ADD, _eo_signals_cb_added_deled, callbacks));
eo2_do(obj, eo2_event_callback_add(EO_EV_CALLBACK_DEL, _eo_signals_cb_added_deled, callbacks)); eo_do(obj, eo_event_callback_add(EO_EV_CALLBACK_DEL, _eo_signals_cb_added_deled, callbacks));
eo2_do(obj, eo2_event_callback_array_priority_add(callbacks, -100, (void *) 1)); eo_do(obj, eo_event_callback_array_priority_add(callbacks, -100, (void *) 1));
eo2_do(obj, eo2_event_callback_array_add(callbacks, (void *) 3)); eo_do(obj, eo_event_callback_array_add(callbacks, (void *) 3));
eo2_do(obj, eo2_event_callback_array_priority_add(callbacks, -50, (void *) 2)); eo_do(obj, eo_event_callback_array_priority_add(callbacks, -50, (void *) 2));
eo2_do(obj, simple_a_set(1)); eo_do(obj, simple_a_set(1));
ck_assert_int_eq(_eo_signals_cb_flag, 0x3); ck_assert_int_eq(_eo_signals_cb_flag, 0x3);
eo2_do(obj, eo2_event_callback_array_del(callbacks, (void *) 1)); eo_do(obj, eo_event_callback_array_del(callbacks, (void *) 1));
eo2_do(obj, eo2_event_callback_array_del(callbacks, (void *) 2)); eo_do(obj, eo_event_callback_array_del(callbacks, (void *) 2));
eo2_do(obj, eo2_event_callback_array_del(callbacks, (void *) 3)); eo_do(obj, eo_event_callback_array_del(callbacks, (void *) 3));
/* Try to delete something that doesn't exist. */ /* Try to delete something that doesn't exist. */
eo2_do(obj, eo2_event_callback_array_del(callbacks, (void *) 4)); eo_do(obj, eo_event_callback_array_del(callbacks, (void *) 4));
_eo_signals_cb_flag = 0; _eo_signals_cb_flag = 0;
eo2_do(obj, simple_a_set(1)); eo_do(obj, simple_a_set(1));
ck_assert_int_eq(_eo_signals_cb_flag, 0x0); ck_assert_int_eq(_eo_signals_cb_flag, 0x0);
eo_unref(obj); eo_unref(obj);
@ -125,20 +125,20 @@ START_TEST(eo_data_fetch)
/* Usually should be const, not const only for the test... */ /* Usually should be const, not const only for the test... */
static Eo_Class_Description class_desc = { static Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple2", "Simple2",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
10, 10,
NULL, NULL,
NULL NULL
}; };
const Eo_Class *klass = eo_class_new(&class_desc, EO2_BASE_CLASS, NULL); const Eo_Class *klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL);
fail_if(!klass); fail_if(!klass);
Eo *obj = eo2_add(klass, NULL); Eo *obj = eo_add(klass, NULL);
fail_if(!obj); fail_if(!obj);
#ifdef EO_DEBUG #ifdef EO_DEBUG
fail_if(eo_data_scope_get(obj, SIMPLE_CLASS)); fail_if(eo_data_scope_get(obj, SIMPLE_CLASS));
@ -146,10 +146,10 @@ START_TEST(eo_data_fetch)
eo_unref(obj); eo_unref(obj);
class_desc.data_size = 0; class_desc.data_size = 0;
klass = eo_class_new(&class_desc, EO2_BASE_CLASS, NULL); klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL);
fail_if(!klass); fail_if(!klass);
obj = eo2_add(klass, NULL); obj = eo_add(klass, NULL);
fail_if(!obj); fail_if(!obj);
fail_if(eo_data_scope_get(obj, klass)); fail_if(eo_data_scope_get(obj, klass));
eo_unref(obj); eo_unref(obj);
@ -167,10 +167,10 @@ START_TEST(eo_isa_tests)
{ {
/* Usually should be const, not const only for the test... */ /* Usually should be const, not const only for the test... */
static Eo_Class_Description class_desc = { static Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Iface", "Iface",
EO_CLASS_TYPE_INTERFACE, EO_CLASS_TYPE_INTERFACE,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
0, 0,
NULL, NULL,
@ -184,10 +184,10 @@ START_TEST(eo_isa_tests)
{ {
/* Usually should be const, not const only for the test... */ /* Usually should be const, not const only for the test... */
static Eo_Class_Description class_desc = { static Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Mixin", "Mixin",
EO_CLASS_TYPE_MIXIN, EO_CLASS_TYPE_MIXIN,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
0, 0,
NULL, NULL,
@ -201,36 +201,36 @@ START_TEST(eo_isa_tests)
{ {
/* Usually should be const, not const only for the test... */ /* Usually should be const, not const only for the test... */
static Eo_Class_Description class_desc = { static Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple2", "Simple2",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
10, 10,
NULL, NULL,
NULL NULL
}; };
klass = eo_class_new(&class_desc, EO2_BASE_CLASS, iface, mixin, NULL); klass = eo_class_new(&class_desc, EO_BASE_CLASS, iface, mixin, NULL);
fail_if(!klass); fail_if(!klass);
} }
Eo *obj = eo2_add(klass, NULL); Eo *obj = eo_add(klass, NULL);
fail_if(!obj); fail_if(!obj);
fail_if(eo_isa(obj, SIMPLE_CLASS)); fail_if(eo_isa(obj, SIMPLE_CLASS));
fail_if(!eo_isa(obj, iface)); fail_if(!eo_isa(obj, iface));
fail_if(!eo_isa(obj, mixin)); fail_if(!eo_isa(obj, mixin));
fail_if(!eo_isa(obj, klass)); fail_if(!eo_isa(obj, klass));
fail_if(!eo_isa(obj, EO2_BASE_CLASS)); fail_if(!eo_isa(obj, EO_BASE_CLASS));
eo_unref(obj); eo_unref(obj);
obj = eo2_add(SIMPLE_CLASS, NULL); obj = eo_add(SIMPLE_CLASS, NULL);
fail_if(!obj); fail_if(!obj);
fail_if(eo_isa(obj, klass)); fail_if(eo_isa(obj, klass));
fail_if(eo_isa(obj, iface)); fail_if(eo_isa(obj, iface));
fail_if(eo_isa(obj, mixin)); fail_if(eo_isa(obj, mixin));
fail_if(!eo_isa(obj, SIMPLE_CLASS)); fail_if(!eo_isa(obj, SIMPLE_CLASS));
fail_if(!eo_isa(obj, EO2_BASE_CLASS)); fail_if(!eo_isa(obj, EO_BASE_CLASS));
eo_unref(obj); eo_unref(obj);
eo_shutdown(); eo_shutdown();
@ -242,13 +242,13 @@ START_TEST(eo_composite_tests)
{ {
eo_init(); eo_init();
Eo *obj = eo2_add(SIMPLE_CLASS, NULL); Eo *obj = eo_add(SIMPLE_CLASS, NULL);
fail_if(!obj); fail_if(!obj);
Eo *obj2 = eo2_add(SIMPLE_CLASS, NULL); Eo *obj2 = eo_add(SIMPLE_CLASS, NULL);
fail_if(!obj2); fail_if(!obj2);
eo_composite_attach(obj2, obj); eo_composite_attach(obj2, obj);
eo2_do(obj2, eo2_parent_set(NULL)); eo_do(obj2, eo_parent_set(NULL));
fail_if(eo_composite_is(obj2)); fail_if(eo_composite_is(obj2));
eo_unref(obj2); eo_unref(obj2);
@ -267,21 +267,21 @@ _man_con(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED)
{ {
if (_man_should_con) if (_man_should_con)
eo_manual_free_set(obj, EINA_TRUE); eo_manual_free_set(obj, EINA_TRUE);
eo2_do_super(obj, cur_klass, eo2_constructor()); eo_do_super(obj, cur_klass, eo_constructor());
} }
static void static void
_man_des(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED) _man_des(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED)
{ {
eo2_do_super(obj, cur_klass, eo2_destructor()); eo_do_super(obj, cur_klass, eo_destructor());
if (_man_should_des) if (_man_should_des)
eo_manual_free_set(obj, EINA_FALSE); eo_manual_free_set(obj, EINA_FALSE);
} }
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC_OVERRIDE(eo2_constructor, _man_con), EO_OP_FUNC_OVERRIDE(eo_constructor, _man_con),
EO2_OP_FUNC_OVERRIDE(eo2_destructor, _man_des), EO_OP_FUNC_OVERRIDE(eo_destructor, _man_des),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
START_TEST(eo_man_free) START_TEST(eo_man_free)
@ -290,35 +290,35 @@ START_TEST(eo_man_free)
/* Usually should be const, not const only for the test... */ /* Usually should be const, not const only for the test... */
static Eo_Class_Description class_desc = { static Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple2", "Simple2",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
10, 10,
NULL, NULL,
NULL NULL
}; };
const Eo_Class *klass = eo_class_new(&class_desc, EO2_BASE_CLASS, NULL); const Eo_Class *klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL);
fail_if(!klass); fail_if(!klass);
cur_klass = klass; cur_klass = klass;
Eo *obj = eo2_add(klass, NULL); Eo *obj = eo_add(klass, NULL);
fail_if(!obj); fail_if(!obj);
eo_unref(obj); eo_unref(obj);
obj = eo2_add(klass, NULL); obj = eo_add(klass, NULL);
fail_if(!obj); fail_if(!obj);
fail_if(eo_manual_free(obj)); fail_if(eo_manual_free(obj));
eo_unref(obj); eo_unref(obj);
_man_should_des = EINA_FALSE; _man_should_des = EINA_FALSE;
klass = eo_class_new(&class_desc, EO2_BASE_CLASS, NULL); klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL);
cur_klass = klass; cur_klass = klass;
fail_if(!klass); fail_if(!klass);
obj = eo2_add(klass, NULL); obj = eo_add(klass, NULL);
fail_if(!obj); fail_if(!obj);
fail_if(eo_manual_free(obj)); fail_if(eo_manual_free(obj));
fail_if(eo_destructed_is(obj)); fail_if(eo_destructed_is(obj));
@ -326,23 +326,23 @@ START_TEST(eo_man_free)
fail_if(!eo_destructed_is(obj)); fail_if(!eo_destructed_is(obj));
fail_if(!eo_manual_free(obj)); fail_if(!eo_manual_free(obj));
obj = eo2_add(klass, NULL); obj = eo_add(klass, NULL);
fail_if(!obj); fail_if(!obj);
eo_unref(obj); eo_unref(obj);
fail_if(!eo_destructed_is(obj)); fail_if(!eo_destructed_is(obj));
fail_if(!eo_manual_free(obj)); fail_if(!eo_manual_free(obj));
_man_should_con = EINA_FALSE; _man_should_con = EINA_FALSE;
klass = eo_class_new(&class_desc, EO2_BASE_CLASS, NULL); klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL);
cur_klass = klass; cur_klass = klass;
fail_if(!klass); fail_if(!klass);
obj = eo2_add(klass, NULL); obj = eo_add(klass, NULL);
fail_if(!obj); fail_if(!obj);
fail_if(eo_manual_free(obj)); fail_if(eo_manual_free(obj));
eo_unref(obj); eo_unref(obj);
obj = eo2_add(klass, NULL); obj = eo_add(klass, NULL);
fail_if(!obj); fail_if(!obj);
eo_manual_free_set(obj, EINA_TRUE); eo_manual_free_set(obj, EINA_TRUE);
eo_unref(obj); eo_unref(obj);
@ -351,7 +351,7 @@ START_TEST(eo_man_free)
eo_unref(obj); eo_unref(obj);
fail_if(!eo_manual_free(obj)); fail_if(!eo_manual_free(obj));
obj = eo2_add(klass, NULL); obj = eo_add(klass, NULL);
fail_if(!obj); fail_if(!obj);
eo_manual_free_set(obj, EINA_TRUE); eo_manual_free_set(obj, EINA_TRUE);
eo_unref(obj); eo_unref(obj);
@ -369,9 +369,9 @@ END_TEST
START_TEST(eo_refs) START_TEST(eo_refs)
{ {
eo_init(); eo_init();
Eo *obj = eo2_add(SIMPLE_CLASS, NULL); Eo *obj = eo_add(SIMPLE_CLASS, NULL);
Eo *obj2 = eo2_add(SIMPLE_CLASS, NULL); Eo *obj2 = eo_add(SIMPLE_CLASS, NULL);
Eo *obj3 = eo2_add(SIMPLE_CLASS, NULL); Eo *obj3 = eo_add(SIMPLE_CLASS, NULL);
eo_xref(obj, obj2); eo_xref(obj, obj2);
fail_if(eo_ref_get(obj) != 2); fail_if(eo_ref_get(obj) != 2);
@ -406,11 +406,11 @@ START_TEST(eo_refs)
eo_unref(obj3); eo_unref(obj3);
/* Check hierarchy */ /* Check hierarchy */
obj = eo2_add(SIMPLE_CLASS, NULL); obj = eo_add(SIMPLE_CLASS, NULL);
obj2 = eo2_add(SIMPLE_CLASS, obj); obj2 = eo_add(SIMPLE_CLASS, obj);
Eo *wref = NULL; Eo *wref = NULL;
eo2_do(obj2, eo2_wref_add(&wref)); eo_do(obj2, eo_wref_add(&wref));
fail_if(!wref); fail_if(!wref);
eo_unref(obj2); eo_unref(obj2);
@ -422,13 +422,13 @@ START_TEST(eo_refs)
fail_if(wref); fail_if(wref);
/* Just check it doesn't seg atm. */ /* Just check it doesn't seg atm. */
obj = eo2_add(SIMPLE_CLASS, NULL); obj = eo_add(SIMPLE_CLASS, NULL);
eo_ref(obj); eo_ref(obj);
eo_unref(obj); eo_unref(obj);
eo_unref(obj); eo_unref(obj);
obj = eo2_add(SIMPLE_CLASS, NULL); obj = eo_add(SIMPLE_CLASS, NULL);
obj2 = eo2_add(SIMPLE_CLASS, obj); obj2 = eo_add(SIMPLE_CLASS, obj);
eo_unref(obj2); eo_unref(obj2);
eo_ref(obj2); eo_ref(obj2);
eo_del(obj2); eo_del(obj2);
@ -442,17 +442,17 @@ START_TEST(eo_weak_reference)
{ {
eo_init(); eo_init();
Eo *obj = eo2_add(SIMPLE_CLASS, NULL); Eo *obj = eo_add(SIMPLE_CLASS, NULL);
Eo *obj2 = eo2_add(SIMPLE_CLASS, NULL); Eo *obj2 = eo_add(SIMPLE_CLASS, NULL);
Eo *wref = NULL, *wref2 = NULL, *wref3 = NULL; Eo *wref = NULL, *wref2 = NULL, *wref3 = NULL;
eo2_do(obj, eo2_wref_add(&wref)); eo_do(obj, eo_wref_add(&wref));
fail_if(!wref); fail_if(!wref);
eo_unref(obj); eo_unref(obj);
fail_if(wref); fail_if(wref);
obj = eo2_add(SIMPLE_CLASS, NULL); obj = eo_add(SIMPLE_CLASS, NULL);
eo2_do(obj, eo2_wref_add(&wref)); eo_do(obj, eo_wref_add(&wref));
eo_ref(obj); eo_ref(obj);
fail_if(!wref); fail_if(!wref);
@ -463,37 +463,37 @@ START_TEST(eo_weak_reference)
eo_unref(obj); eo_unref(obj);
fail_if(wref); fail_if(wref);
obj = eo2_add(SIMPLE_CLASS, NULL); obj = eo_add(SIMPLE_CLASS, NULL);
eo2_do(obj, eo2_wref_add(&wref)); eo_do(obj, eo_wref_add(&wref));
eo2_do(obj, eo2_wref_del(&wref)); eo_do(obj, eo_wref_del(&wref));
fail_if(wref); fail_if(wref);
eo2_do(obj, eo2_wref_add(&wref)); eo_do(obj, eo_wref_add(&wref));
eo2_do(obj2, eo2_wref_del(&wref)); eo_do(obj2, eo_wref_del(&wref));
fail_if(!wref); fail_if(!wref);
eo2_wref_del_safe(&wref); eo_wref_del_safe(&wref);
fail_if(wref); fail_if(wref);
wref = obj; wref = obj;
eo2_do(obj, eo2_wref_del(&wref)); eo_do(obj, eo_wref_del(&wref));
fail_if(wref); fail_if(wref);
wref = wref2 = wref3 = NULL; wref = wref2 = wref3 = NULL;
eo2_do(obj, eo2_wref_add(&wref), eo2_wref_add(&wref2), eo2_wref_add(&wref3)); eo_do(obj, eo_wref_add(&wref), eo_wref_add(&wref2), eo_wref_add(&wref3));
fail_if(!wref); fail_if(!wref);
fail_if(!wref2); fail_if(!wref2);
fail_if(!wref3); fail_if(!wref3);
eo2_do(obj, eo2_wref_del(&wref), eo2_wref_del(&wref2), eo2_wref_del(&wref3)); eo_do(obj, eo_wref_del(&wref), eo_wref_del(&wref2), eo_wref_del(&wref3));
fail_if(wref); fail_if(wref);
fail_if(wref2); fail_if(wref2);
fail_if(wref3); fail_if(wref3);
eo2_do(obj, eo2_wref_add(&wref2), eo2_wref_add(&wref3)); eo_do(obj, eo_wref_add(&wref2), eo_wref_add(&wref3));
wref = obj; wref = obj;
eo2_do(obj, eo2_wref_del(&wref)); eo_do(obj, eo_wref_del(&wref));
fail_if(wref); fail_if(wref);
eo2_do(obj, eo2_wref_del(&wref2), eo2_wref_del(&wref3)); eo_do(obj, eo_wref_del(&wref2), eo_wref_del(&wref3));
eo_unref(obj); eo_unref(obj);
eo_unref(obj2); eo_unref(obj2);
@ -516,59 +516,59 @@ _fake_free_func(void *data)
START_TEST(eo_generic_data) START_TEST(eo_generic_data)
{ {
eo_init(); eo_init();
Eo *obj = eo2_add(SIMPLE_CLASS, NULL); Eo *obj = eo_add(SIMPLE_CLASS, NULL);
void *data = NULL; void *data = NULL;
eo2_do(obj, eo2_base_data_set("test1", (void *) 1, NULL)); eo_do(obj, eo_base_data_set("test1", (void *) 1, NULL));
eo2_do(obj, data = eo2_base_data_get("test1")); eo_do(obj, data = eo_base_data_get("test1"));
fail_if(1 != (intptr_t) data); fail_if(1 != (intptr_t) data);
eo2_do(obj, eo2_base_data_del("test1")); eo_do(obj, eo_base_data_del("test1"));
eo2_do(obj, data = eo2_base_data_get("test1")); eo_do(obj, data = eo_base_data_get("test1"));
fail_if(data); fail_if(data);
eo2_do(obj, eo2_base_data_set("test1", (void *) 1, NULL)); eo_do(obj, eo_base_data_set("test1", (void *) 1, NULL));
eo2_do(obj, eo2_base_data_set("test2", (void *) 2, NULL)); eo_do(obj, eo_base_data_set("test2", (void *) 2, NULL));
eo2_do(obj, data = eo2_base_data_get("test1")); eo_do(obj, data = eo_base_data_get("test1"));
fail_if(1 != (intptr_t) data); fail_if(1 != (intptr_t) data);
eo2_do(obj, data = eo2_base_data_get("test2")); eo_do(obj, data = eo_base_data_get("test2"));
fail_if(2 != (intptr_t) data); fail_if(2 != (intptr_t) data);
eo2_do(obj, data = eo2_base_data_get("test2")); eo_do(obj, data = eo_base_data_get("test2"));
fail_if(2 != (intptr_t) data); fail_if(2 != (intptr_t) data);
eo2_do(obj, eo2_base_data_del("test2")); eo_do(obj, eo_base_data_del("test2"));
eo2_do(obj, data = eo2_base_data_get("test2")); eo_do(obj, data = eo_base_data_get("test2"));
fail_if(data); fail_if(data);
eo2_do(obj, data = eo2_base_data_get("test1")); eo_do(obj, data = eo_base_data_get("test1"));
fail_if(1 != (intptr_t) data); fail_if(1 != (intptr_t) data);
eo2_do(obj, eo2_base_data_del("test1")); eo_do(obj, eo_base_data_del("test1"));
eo2_do(obj, data = eo2_base_data_get("test1")); eo_do(obj, data = eo_base_data_get("test1"));
fail_if(data); fail_if(data);
int a = 0; int a = 0;
eo2_do(obj, eo2_base_data_set("test3", &a, _fake_free_func)); eo_do(obj, eo_base_data_set("test3", &a, _fake_free_func));
eo2_do(obj, data = eo2_base_data_get("test3")); eo_do(obj, data = eo_base_data_get("test3"));
fail_if(&a != data); fail_if(&a != data);
eo2_do(obj, eo2_base_data_get("test3")); eo_do(obj, eo_base_data_get("test3"));
eo2_do(obj, eo2_base_data_del("test3")); eo_do(obj, eo_base_data_del("test3"));
fail_if(a != 1); fail_if(a != 1);
a = 0; a = 0;
eo2_do(obj, eo2_base_data_set("test3", &a, _fake_free_func)); eo_do(obj, eo_base_data_set("test3", &a, _fake_free_func));
eo2_do(obj, eo2_base_data_set("test3", NULL, _fake_free_func)); eo_do(obj, eo_base_data_set("test3", NULL, _fake_free_func));
fail_if(a != 1); fail_if(a != 1);
a = 0; a = 0;
data = (void *) 123; data = (void *) 123;
eo2_do(obj, eo2_base_data_set(NULL, &a, _fake_free_func)); eo_do(obj, eo_base_data_set(NULL, &a, _fake_free_func));
eo2_do(obj, data = eo2_base_data_get(NULL)); eo_do(obj, data = eo_base_data_get(NULL));
fail_if(data); fail_if(data);
eo2_do(obj, eo2_base_data_del(NULL)); eo_do(obj, eo_base_data_del(NULL));
a = 0; a = 0;
eo2_do(obj, eo2_base_data_set("test3", &a, _fake_free_func)); eo_do(obj, eo_base_data_set("test3", &a, _fake_free_func));
eo2_do(obj, eo2_base_data_set("test3", NULL, NULL)); eo_do(obj, eo_base_data_set("test3", NULL, NULL));
fail_if(a != 1); fail_if(a != 1);
eo2_do(obj, eo2_base_data_set("test3", &a, _fake_free_func)); eo_do(obj, eo_base_data_set("test3", &a, _fake_free_func));
eo_unref(obj); eo_unref(obj);
fail_if(a != 2); fail_if(a != 2);
@ -586,7 +586,7 @@ START_TEST(eo_magic_checks)
memset(_buf, 1, sizeof(_buf)); memset(_buf, 1, sizeof(_buf));
Eo *obj = eo2_add(SIMPLE_CLASS, (Eo *) buf); Eo *obj = eo_add(SIMPLE_CLASS, (Eo *) buf);
fail_if(obj); fail_if(obj);
while (1) while (1)
@ -596,28 +596,28 @@ START_TEST(eo_magic_checks)
Eo *wref = NULL; Eo *wref = NULL;
Eo *obj2 = NULL; Eo *obj2 = NULL;
obj = eo2_add((Eo_Class *) buf, NULL); obj = eo_add((Eo_Class *) buf, NULL);
fail_if(obj); fail_if(obj);
obj = eo2_add(SIMPLE_CLASS, NULL); obj = eo_add(SIMPLE_CLASS, NULL);
fail_if(!obj); fail_if(!obj);
eo2_do((Eo *) buf, simple_a_set(++i), a = simple_a_get()); eo_do((Eo *) buf, simple_a_set(++i), a = simple_a_get());
ck_assert_int_ne(i, a); ck_assert_int_ne(i, a);
eo2_do_super((Eo *) buf, SIMPLE_CLASS, simple_a_set(++i)); eo_do_super((Eo *) buf, SIMPLE_CLASS, simple_a_set(++i));
eo2_do_super((Eo *) buf, SIMPLE_CLASS, a = simple_a_get()); eo_do_super((Eo *) buf, SIMPLE_CLASS, a = simple_a_get());
ck_assert_int_ne(i, a); ck_assert_int_ne(i, a);
eo2_do_super(obj, (const Eo_Class *) buf, simple_a_set(++i)); eo_do_super(obj, (const Eo_Class *) buf, simple_a_set(++i));
eo2_do_super(obj, (const Eo_Class *) buf, a = simple_a_get()); eo_do_super(obj, (const Eo_Class *) buf, a = simple_a_get());
ck_assert_int_ne(i, a); ck_assert_int_ne(i, a);
fail_if(eo_class_get((Eo *) buf)); fail_if(eo_class_get((Eo *) buf));
fail_if(eo_class_name_get((Eo_Class*) buf)); fail_if(eo_class_name_get((Eo_Class*) buf));
fail_if(eo_class_get(obj) != SIMPLE_CLASS); fail_if(eo_class_get(obj) != SIMPLE_CLASS);
fail_if(eo_class_get(SIMPLE_CLASS) != EO2_CLASS_CLASS); fail_if(eo_class_get(SIMPLE_CLASS) != EO_CLASS_CLASS);
eo_class_funcs_set((Eo_Class *) buf, NULL); eo_class_funcs_set((Eo_Class *) buf, NULL);
eo2_do((Eo_Class *) buf,(void) NULL); eo_do((Eo_Class *) buf,(void) NULL);
eo2_do_super((Eo_Class *) buf, SIMPLE_CLASS, simple_a_set(++i)); eo_do_super((Eo_Class *) buf, SIMPLE_CLASS, simple_a_set(++i));
eo2_do_super(SIMPLE_CLASS, (Eo_Class *) buf, simple_a_set(++i)); eo_do_super(SIMPLE_CLASS, (Eo_Class *) buf, simple_a_set(++i));
fail_if(eo_class_new(NULL, (Eo_Class *) buf), NULL); fail_if(eo_class_new(NULL, (Eo_Class *) buf), NULL);
eo_xref(obj, (Eo *) buf); eo_xref(obj, (Eo *) buf);
@ -634,9 +634,9 @@ START_TEST(eo_magic_checks)
fail_if(0 != eo_ref_get((Eo *) buf)); fail_if(0 != eo_ref_get((Eo *) buf));
eo2_do((Eo *) buf, eo_do((Eo *) buf,
eo2_wref_add(&wref), eo_wref_add(&wref),
parent = eo2_parent_get()); parent = eo_parent_get());
fail_if(wref); fail_if(wref);
fail_if(parent); fail_if(parent);
@ -650,8 +650,8 @@ START_TEST(eo_magic_checks)
eo_composite_detach(obj, (Eo *) buf); eo_composite_detach(obj, (Eo *) buf);
eo_composite_is((Eo *) buf); eo_composite_is((Eo *) buf);
eo2_do(obj, eo2_event_callback_forwarder_add(NULL, (Eo *) buf)); eo_do(obj, eo_event_callback_forwarder_add(NULL, (Eo *) buf));
eo2_do(obj, eo2_event_callback_forwarder_del(NULL, (Eo *) buf)); eo_do(obj, eo_event_callback_forwarder_del(NULL, (Eo *) buf));
eo_manual_free_set((Eo *) buf, EINA_TRUE); eo_manual_free_set((Eo *) buf, EINA_TRUE);
eo_manual_free((Eo *) buf); eo_manual_free((Eo *) buf);
@ -692,13 +692,13 @@ _class_hi_print(Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED)
return EINA_TRUE; return EINA_TRUE;
} }
EO2_FUNC_BODY(multi_a_print, Eina_Bool, EINA_FALSE); EO_FUNC_BODY(multi_a_print, Eina_Bool, EINA_FALSE);
EO2_FUNC_BODY(multi_class_hi_print, Eina_Bool, EINA_FALSE); EO_FUNC_BODY(multi_class_hi_print, Eina_Bool, EINA_FALSE);
static Eo2_Op_Description _multi_do_op_descs[] = { static Eo_Op_Description _multi_do_op_descs[] = {
EO2_OP_FUNC(multi_a_print, _a_print, "Print property a"), EO_OP_FUNC(multi_a_print, _a_print, "Print property a"),
EO2_OP_FUNC(multi_class_hi_print, _class_hi_print, "Print Hi"), EO_OP_FUNC(multi_class_hi_print, _class_hi_print, "Print Hi"),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
START_TEST(eo_multiple_do) START_TEST(eo_multiple_do)
@ -707,10 +707,10 @@ START_TEST(eo_multiple_do)
/* Usually should be const, not const only for the test... */ /* Usually should be const, not const only for the test... */
static Eo_Class_Description class_desc = { static Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Inherit", "Inherit",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(_multi_do_op_descs), EO_CLASS_DESCRIPTION_OPS(_multi_do_op_descs),
NULL, NULL,
0, 0,
NULL, NULL,
@ -720,17 +720,17 @@ START_TEST(eo_multiple_do)
const Eo_Class *klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL); const Eo_Class *klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL);
fail_if(!klass); fail_if(!klass);
Eo *obj = eo2_add(klass, NULL); Eo *obj = eo_add(klass, NULL);
fail_if(!obj); fail_if(!obj);
Eina_Bool ca, cb, cc; Eina_Bool ca, cb, cc;
ca = cb = cc = EINA_FALSE; ca = cb = cc = EINA_FALSE;
eo2_do(obj, ca = simple_a_print(), cb = multi_a_print(), cc = multi_a_print()); eo_do(obj, ca = simple_a_print(), cb = multi_a_print(), cc = multi_a_print());
fail_if(!(ca && cb && cc)); fail_if(!(ca && cb && cc));
ca = cb = cc = EINA_FALSE; ca = cb = cc = EINA_FALSE;
eo2_do(klass, ca = simple_class_hi_print(), cb = multi_class_hi_print(), cc = multi_class_hi_print()); eo_do(klass, ca = simple_class_hi_print(), cb = multi_class_hi_print(), cc = multi_class_hi_print());
fail_if(!(ca && cb && cc)); fail_if(!(ca && cb && cc));
eo_unref(obj); eo_unref(obj);
@ -739,23 +739,23 @@ START_TEST(eo_multiple_do)
} }
END_TEST END_TEST
START_TEST(eo2_add_do_and_custom) START_TEST(eo_add_do_and_custom)
{ {
Simple_Public_Data *pd = NULL; Simple_Public_Data *pd = NULL;
Eo *obj = NULL; Eo *obj = NULL;
eo_init(); eo_init();
obj = eo2_add_custom(SIMPLE_CLASS, NULL, eo2_constructor()); obj = eo_add_custom(SIMPLE_CLASS, NULL, eo_constructor());
fail_if(!obj); fail_if(!obj);
eo_unref(obj); eo_unref(obj);
obj = eo2_add(SIMPLE_CLASS, NULL, simple_a_set(7)); obj = eo_add(SIMPLE_CLASS, NULL, simple_a_set(7));
fail_if(!obj); fail_if(!obj);
pd = eo_data_scope_get(obj, SIMPLE_CLASS); pd = eo_data_scope_get(obj, SIMPLE_CLASS);
fail_if(pd->a != 7); fail_if(pd->a != 7);
eo_unref(obj); eo_unref(obj);
obj = eo2_add_custom(SIMPLE_CLASS, NULL, eo2_constructor(), simple_a_set(7)); obj = eo_add_custom(SIMPLE_CLASS, NULL, eo_constructor(), simple_a_set(7));
fail_if(!obj); fail_if(!obj);
pd = eo_data_scope_get(obj, SIMPLE_CLASS); pd = eo_data_scope_get(obj, SIMPLE_CLASS);
fail_if(pd->a != 7); fail_if(pd->a != 7);
@ -771,21 +771,21 @@ START_TEST(eo_pointers_indirection)
eo_init(); eo_init();
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Simple", "Simple",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_NOOPS(), EO_CLASS_DESCRIPTION_NOOPS(),
NULL, NULL,
0, 0,
NULL, NULL,
NULL NULL
}; };
const Eo_Class *klass = eo_class_new(&class_desc, EO2_BASE_CLASS, NULL); const Eo_Class *klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL);
fail_if(!klass); fail_if(!klass);
/* Check simple id validity */ /* Check simple id validity */
Eo *obj = eo2_add(klass, NULL); Eo *obj = eo_add(klass, NULL);
fail_if(!obj); fail_if(!obj);
fail_if(!eo_isa(obj, klass)); fail_if(!eo_isa(obj, klass));
obj = (Eo *)((char *)(obj) + 1); obj = (Eo *)((char *)(obj) + 1);
@ -796,10 +796,10 @@ START_TEST(eo_pointers_indirection)
fail_if(eo_isa(obj, klass)); fail_if(eo_isa(obj, klass));
/* Check id invalidity after deletion */ /* Check id invalidity after deletion */
Eo *obj1 = eo2_add(klass, NULL); Eo *obj1 = eo_add(klass, NULL);
fail_if(!obj1); fail_if(!obj1);
eo_unref(obj1); eo_unref(obj1);
Eo *obj2 = eo2_add(klass, NULL); Eo *obj2 = eo_add(klass, NULL);
fail_if(!obj2); fail_if(!obj2);
fail_if(!eo_isa(obj2, klass)); fail_if(!eo_isa(obj2, klass));
fail_if(eo_isa(obj1, klass)); fail_if(eo_isa(obj1, klass));
@ -812,7 +812,7 @@ START_TEST(eo_pointers_indirection)
/* Creation of the objects */ /* Creation of the objects */
for ( obj_id = 0; obj_id < NB_OBJS; obj_id++) for ( obj_id = 0; obj_id < NB_OBJS; obj_id++)
{ {
objs[obj_id] = eo2_add(klass, NULL); objs[obj_id] = eo_add(klass, NULL);
if(!objs[obj_id]) if(!objs[obj_id])
fail_if(!objs[obj_id]); fail_if(!objs[obj_id]);
if(!eo_isa(objs[obj_id], klass)) if(!eo_isa(objs[obj_id], klass))
@ -828,7 +828,7 @@ START_TEST(eo_pointers_indirection)
/* Creation of the deleted objects */ /* Creation of the deleted objects */
for ( obj_id = 0; obj_id < NB_OBJS; obj_id+=2000) for ( obj_id = 0; obj_id < NB_OBJS; obj_id+=2000)
{ {
objs[obj_id] = eo2_add(klass, NULL); objs[obj_id] = eo_add(klass, NULL);
if(!objs[obj_id]) if(!objs[obj_id])
fail_if(!objs[obj_id]); fail_if(!objs[obj_id]);
if(!eo_isa(objs[obj_id], klass)) if(!eo_isa(objs[obj_id], klass))
@ -860,6 +860,6 @@ void eo_test_general(TCase *tc)
tcase_add_test(tc, eo_generic_data); tcase_add_test(tc, eo_generic_data);
tcase_add_test(tc, eo_magic_checks); tcase_add_test(tc, eo_magic_checks);
tcase_add_test(tc, eo_multiple_do); tcase_add_test(tc, eo_multiple_do);
tcase_add_test(tc, eo2_add_do_and_custom); tcase_add_test(tc, eo_add_do_and_custom);
tcase_add_test(tc, eo_pointers_indirection); tcase_add_test(tc, eo_pointers_indirection);
} }

28
src/tests/eo/suite/eo_test_threaded_calls.c
View File

@ -18,9 +18,9 @@ typedef struct
#define THREAD_TEST_CLASS thread_test_class_get() #define THREAD_TEST_CLASS thread_test_class_get()
const Eo_Class *thread_test_class_get(void); const Eo_Class *thread_test_class_get(void);
EO2_FUNC_BODY(thread_test_v_get, int, 0); EO_FUNC_BODY(thread_test_v_get, int, 0);
EO2_VOID_FUNC_BODY(thread_test_try_swap_stack); EO_VOID_FUNC_BODY(thread_test_try_swap_stack);
EO2_VOID_FUNC_BODYV(thread_test_constructor, EO2_FUNC_CALL(v), int v); EO_VOID_FUNC_BODYV(thread_test_constructor, EO_FUNC_CALL(v), int v);
static int static int
_v_get(Eo *obj EINA_UNUSED, void *class_data) _v_get(Eo *obj EINA_UNUSED, void *class_data)
@ -53,30 +53,30 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED, int v)
{ {
Thread_Test_Public_Data *pd = class_data; Thread_Test_Public_Data *pd = class_data;
eo2_do_super(obj, THREAD_TEST_CLASS, eo2_constructor()); eo_do_super(obj, THREAD_TEST_CLASS, eo_constructor());
pd->v = v; pd->v = v;
} }
static Eo2_Op_Description op_descs[] = { static Eo_Op_Description op_descs[] = {
EO2_OP_FUNC(thread_test_constructor, _constructor, "Constructor."), EO_OP_FUNC(thread_test_constructor, _constructor, "Constructor."),
EO2_OP_FUNC(thread_test_v_get, _v_get, "Get property v."), EO_OP_FUNC(thread_test_v_get, _v_get, "Get property v."),
EO2_OP_FUNC(thread_test_try_swap_stack, _try_swap_stack, "Swap call stack frames if it is not thread safe."), EO_OP_FUNC(thread_test_try_swap_stack, _try_swap_stack, "Swap call stack frames if it is not thread safe."),
EO2_OP_SENTINEL EO_OP_SENTINEL
}; };
static const Eo_Class_Description class_desc = { static const Eo_Class_Description class_desc = {
EO2_VERSION, EO_VERSION,
"Thread Test", "Thread Test",
EO_CLASS_TYPE_REGULAR, EO_CLASS_TYPE_REGULAR,
EO2_CLASS_DESCRIPTION_OPS(op_descs), EO_CLASS_DESCRIPTION_OPS(op_descs),
NULL, NULL,
sizeof(Thread_Test_Public_Data), sizeof(Thread_Test_Public_Data),
NULL, NULL,
NULL NULL
}; };
EO_DEFINE_CLASS(thread_test_class_get, &class_desc, EO2_BASE_CLASS, NULL) EO_DEFINE_CLASS(thread_test_class_get, &class_desc, EO_BASE_CLASS, NULL)
static void * static void *
_thread_job(void *data, Eina_Thread t EINA_UNUSED) _thread_job(void *data, Eina_Thread t EINA_UNUSED)
@ -87,9 +87,9 @@ _thread_job(void *data, Eina_Thread t EINA_UNUSED)
if (v == 1) if (v == 1)
eina_spinlock_take(&locks[0]); eina_spinlock_take(&locks[0]);
obj = eo2_add_custom(THREAD_TEST_CLASS, NULL, thread_test_constructor(v)); obj = eo_add_custom(THREAD_TEST_CLASS, NULL, thread_test_constructor(v));
eo2_do(obj, thread_test_try_swap_stack(), v = thread_test_v_get()); eo_do(obj, thread_test_try_swap_stack(), v = thread_test_v_get());
eina_spinlock_release(&locks[1]); eina_spinlock_release(&locks[1]);

4
src/tests/eo/suite/eo_test_value.c
View File

@ -16,10 +16,10 @@ START_TEST(eo_value)
Eina_Value val2, eo_val; Eina_Value val2, eo_val;
void *tmpp = NULL; void *tmpp = NULL;
Eo_Dbg_Info *eo_dbg_info; Eo_Dbg_Info *eo_dbg_info;
Eo *obj = eo2_add(SIMPLE_CLASS, NULL); Eo *obj = eo_add(SIMPLE_CLASS, NULL);
eo_dbg_info = EO_DBG_INFO_LIST_APPEND(NULL, "Root"); eo_dbg_info = EO_DBG_INFO_LIST_APPEND(NULL, "Root");
eo2_do(obj, eo2_dbg_info_get(eo_dbg_info)); eo_do(obj, eo_dbg_info_get(eo_dbg_info));
fail_if(!eo_dbg_info); fail_if(!eo_dbg_info);
ck_assert_str_eq(eo_dbg_info->name, "Root"); ck_assert_str_eq(eo_dbg_info->name, "Root");
str = eina_value_to_string(&eo_dbg_info->value); str = eina_value_to_string(&eo_dbg_info->value);