diff options
44 files changed, 869 insertions, 873 deletions
diff --git a/src/lib/eo/Eo.h b/src/lib/eo/Eo.h index bef8f915b0..6258960f9f 100644 --- a/src/lib/eo/Eo.h +++ b/src/lib/eo/Eo.h @@ -365,14 +365,14 @@ typedef enum _Eo_Class_Type Eo_Class_Type; */ #define EO_VERSION 2 -typedef struct _Eo2_Op_Description +typedef struct _Eo_Op_Description { void *api_func; /**< The EAPI function offering this op. */ void *func; /**< The static function to call for the op. */ Eo_Op op; /**< The op. */ Eo_Op_Type op_type; /**< The type of the Op. */ const char *doc; /**< Explanation about the Op. */ -} Eo2_Op_Description; +} Eo_Op_Description; /** * @struct _Eo_Class_Description @@ -386,7 +386,7 @@ struct _Eo_Class_Description const char *name; /**< The name of the class. */ Eo_Class_Type type; /**< The type of the class. */ struct { - Eo2_Op_Description *descs2; + Eo_Op_Description *descs2; size_t count; } ops; /**< The ops description, should be filled using #EO_CLASS_DESCRIPTION_OPS */ 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); -/************************************ EO2 ************************************/ - -#define EO2_VERSION EO_VERSION - -// computes size of Eo2_Op_Description[] -#define EO2_OP_DESC_SIZE(desc) (sizeof(desc)/sizeof(*desc) - 1) +// computes size of Eo_Op_Description[] +#define EO_OP_DESC_SIZE(desc) (sizeof(desc)/sizeof(*desc) - 1) // Helpers macro to help populating #Eo_Class_Description. -#define EO2_CLASS_DESCRIPTION_NOOPS() { NULL, 0} -#define EO2_CLASS_DESCRIPTION_OPS(op_descs) { op_descs, EO2_OP_DESC_SIZE(op_descs) } +#define EO_CLASS_DESCRIPTION_NOOPS() { NULL, 0} +#define EO_CLASS_DESCRIPTION_OPS(op_descs) { op_descs, EO_OP_DESC_SIZE(op_descs) } // to fetch internal function and object data at once -typedef struct _Eo2_Op_Call_Data +typedef struct _Eo_Op_Call_Data { 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 *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 Eo2_Hook_Call eo2_hook_call_post; +EAPI extern Eo_Hook_Call eo_hook_call_pre; +EAPI extern Eo_Hook_Call eo_hook_call_post; -// to pass the internal function call to EO2_FUNC_BODY (as Func parameter) -#define EO2_FUNC_CALL(...) __VA_ARGS__ +// to pass the internal function call to EO_FUNC_BODY (as Func parameter) +#define EO_FUNC_CALL(...) __VA_ARGS__ -#define EO2_HOOK_CALL_PREPARE(Hook) \ +#define EO_HOOK_CALL_PREPARE(Hook) \ if (Hook) \ Hook(call.klass, call.obj, call.func); -#define EO2_HOOK_CALL_PREPAREV(Hook, ...) \ +#define EO_HOOK_CALL_PREPAREV(Hook, ...) \ if (Hook) \ Hook(call.klass, call.obj, call.func, __VA_ARGS__); // cache OP id, get real fct and object data then do the call -#define EO2_FUNC_COMMON_OP(Name, DefRet) \ - Eo2_Op_Call_Data call; \ +#define EO_FUNC_COMMON_OP(Name, DefRet) \ + Eo_Op_Call_Data call; \ static Eo_Op op = EO_NOOP; \ if (op == EO_NOOP) \ - op = _eo2_api_op_id_get((void*) Name, __FILE__, __LINE__); \ - if (!_eo2_call_resolve(#Name, op, &call, __FILE__, __LINE__)) return DefRet; \ - _Eo2_##Name##_func _func_ = (_Eo2_##Name##_func) call.func; \ + op = _eo_api_op_id_get((void*) Name, __FILE__, __LINE__); \ + if (!_eo_call_resolve(#Name, op, &call, __FILE__, __LINE__)) return DefRet; \ + _Eo_##Name##_func _func_ = (_Eo_##Name##_func) call.func; \ // to define an EAPI function -#define EO2_FUNC_BODY(Name, Ret, DefRet) \ +#define EO_FUNC_BODY(Name, Ret, DefRet) \ Ret \ Name(void) \ { \ - typedef Ret (*_Eo2_##Name##_func)(Eo *, void *obj_data); \ + typedef Ret (*_Eo_##Name##_func)(Eo *, void *obj_data); \ Ret _r; \ - EO2_FUNC_COMMON_OP(Name, DefRet); \ - EO2_HOOK_CALL_PREPARE(eo2_hook_call_pre); \ + EO_FUNC_COMMON_OP(Name, DefRet); \ + EO_HOOK_CALL_PREPARE(eo_hook_call_pre); \ _r = _func_(call.obj, call.data); \ - EO2_HOOK_CALL_PREPARE(eo2_hook_call_post); \ + EO_HOOK_CALL_PREPARE(eo_hook_call_post); \ return _r; \ } -#define EO2_VOID_FUNC_BODY(Name) \ +#define EO_VOID_FUNC_BODY(Name) \ void \ Name(void) \ { \ - typedef void (*_Eo2_##Name##_func)(Eo *, void *obj_data); \ - EO2_FUNC_COMMON_OP(Name, ); \ - EO2_HOOK_CALL_PREPARE(eo2_hook_call_pre); \ + typedef void (*_Eo_##Name##_func)(Eo *, void *obj_data); \ + EO_FUNC_COMMON_OP(Name, ); \ + EO_HOOK_CALL_PREPARE(eo_hook_call_pre); \ _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 \ 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; \ - EO2_FUNC_COMMON_OP(Name, DefRet); \ - EO2_HOOK_CALL_PREPAREV(eo2_hook_call_pre, Arguments); \ + EO_FUNC_COMMON_OP(Name, DefRet); \ + EO_HOOK_CALL_PREPAREV(eo_hook_call_pre, 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; \ } -#define EO2_VOID_FUNC_BODYV(Name, Arguments, ...) \ +#define EO_VOID_FUNC_BODYV(Name, Arguments, ...) \ void \ Name(__VA_ARGS__) \ { \ - typedef void (*_Eo2_##Name##_func)(Eo *, void *obj_data, __VA_ARGS__); \ - EO2_FUNC_COMMON_OP(Name, ); \ - EO2_HOOK_CALL_PREPAREV(eo2_hook_call_pre, Arguments); \ + typedef void (*_Eo_##Name##_func)(Eo *, void *obj_data, __VA_ARGS__); \ + EO_FUNC_COMMON_OP(Name, ); \ + EO_HOOK_CALL_PREPAREV(eo_hook_call_pre, 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 -#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 EO2_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 EO2_OP_CLASS_FUNC_OVERRIDE(_api, _private) {_api, _private, EO2_OP_OVERRIDE, EO_OP_TYPE_CLASS, NULL} -#define EO2_OP_SENTINEL { NULL, NULL, 0, EO_OP_TYPE_INVALID, NULL} +#define EO_OP_FUNC(_api, _private, _doc) {_api, _private, EO_NOOP, EO_OP_TYPE_REGULAR, _doc} +#define EO_OP_CLASS_FUNC(_api, _private, _doc) {_api, _private, EO_NOOP, EO_OP_TYPE_CLASS, _doc} +#define EO_OP_FUNC_OVERRIDE(_api, _private) {_api, _private, EO_OP_OVERRIDE, EO_OP_TYPE_REGULAR, NULL} +#define EO_OP_CLASS_FUNC_OVERRIDE(_api, _private) {_api, _private, EO_OP_OVERRIDE, EO_OP_TYPE_CLASS, NULL} +#define EO_OP_SENTINEL { NULL, NULL, 0, EO_OP_TYPE_INVALID, NULL} // 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 -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 -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); +// start of eo_do barrier, gets the object pointer and ref it, put it on the stask +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 -EAPI void _eo2_do_end(const Eo **ojb); +// end of the eo_do barrier, unref the obj, move the stack pointer +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, -#define _eo2_do_common(eoid, clsid, is_super, ...) \ +#define _eo_do_common(eoid, clsid, is_super, ...) \ do \ { \ 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__; \ (void) _id_clean_; \ } \ } 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 */ -#define eo2_add(klass, parent, ...) \ +#define eo_add(klass, parent, ...) \ ({ \ const Eo_Class *_tmp_klass = klass; \ - Eo *_tmp_obj = _eo2_add_internal_start(__FILE__, __LINE__, _tmp_klass, parent); \ - eo2_do(_tmp_obj, \ - eo2_constructor(); \ + Eo *_tmp_obj = _eo_add_internal_start(__FILE__, __LINE__, _tmp_klass, parent); \ + eo_do(_tmp_obj, \ + eo_constructor(); \ __VA_ARGS__; \ - _tmp_obj = _eo2_add_internal_end(__FILE__, __LINE__, _tmp_obj); \ + _tmp_obj = _eo_add_internal_end(__FILE__, __LINE__, _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 */ -#define eo2_add_custom(klass, parent, ...) \ +#define eo_add_custom(klass, parent, ...) \ ({ \ const Eo_Class *_tmp_klass = klass; \ - Eo *_tmp_obj = _eo2_add_internal_start(__FILE__, __LINE__, _tmp_klass, parent); \ - eo2_do(_tmp_obj, \ + Eo *_tmp_obj = _eo_add_internal_start(__FILE__, __LINE__, _tmp_klass, parent); \ + eo_do(_tmp_obj, \ __VA_ARGS__; \ - _tmp_obj = _eo2_add_internal_end(__FILE__, __LINE__, _tmp_obj); \ + _tmp_obj = _eo_add_internal_end(__FILE__, __LINE__, _tmp_obj); \ ); \ _tmp_obj; \ }) -EAPI Eo * _eo2_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_start(const char *file, int line, const Eo_Class *klass_id, Eo *parent); +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. @@ -918,12 +914,12 @@ EAPI Eina_Bool eo_composite_is(const Eo *comp_obj); * @def 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 * @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 * 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 * @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 @@ -960,7 +956,7 @@ typedef void (*eo_base_data_free_func)(void *); * @see #eo_base_data_get * @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. @@ -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_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. * @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. @@ -985,7 +981,7 @@ EAPI void eo2_dbg_info_get(Eo_Dbg_Info *root_node); * @see #eo_base_data_set * @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 @@ -998,7 +994,7 @@ EAPI void eo2_base_data_del(const char *key); * @see eo_del() * @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 @@ -1006,7 +1002,7 @@ EAPI void eo2_parent_set(Eo *parent); * * @see eo_parent_set() */ -EAPI Eo *eo2_parent_get(void); +EAPI Eo *eo_parent_get(void); /** * @brief Get an iterator on all childrens @@ -1015,7 +1011,7 @@ EAPI Eo *eo2_parent_get(void); * * @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. @@ -1028,7 +1024,7 @@ EAPI Eina_Iterator *eo2_children_iterator_new(void); * * @see #eo_wref_del */ -EAPI void eo2_wref_add(Eo **wref); +EAPI void eo_wref_add(Eo **wref); /** * @brief Delete the weak reference passed. @@ -1036,7 +1032,7 @@ EAPI void eo2_wref_add(Eo **wref); * * @see #eo_wref_add */ -EAPI void eo2_wref_del(Eo **wref); +EAPI void eo_wref_del(Eo **wref); /** * @def eo_weak_ref @@ -1050,9 +1046,9 @@ EAPI void eo2_wref_del(Eo **wref); * @see eo_weak_unref * @see eo_wref_add */ -#define eo2_weak_ref(wref) \ +#define eo_weak_ref(wref) \ do { \ - if (*wref) eo2_do(*wref, eo2_wref_add(wref)); \ + if (*wref) eo_do(*wref, eo_wref_add(wref)); \ } while (0) /** @@ -1068,9 +1064,9 @@ EAPI void eo2_wref_del(Eo **wref); * @see eo_wref_del * @see eo_wref_del_safe */ -#define eo2_weak_unref(wref) \ +#define eo_weak_unref(wref) \ do { \ - if (*wref) eo2_do(*wref, eo2_wref_del(wref)); \ + if (*wref) eo_do(*wref, eo_wref_del(wref)); \ } while (0) /** @@ -1083,7 +1079,7 @@ EAPI void eo2_wref_del(Eo **wref); * * @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. @@ -1092,7 +1088,7 @@ EAPI void eo2_wref_del(Eo **wref); * * @see #eo_destructor */ -EAPI void eo2_constructor(void); +EAPI void eo_constructor(void); /** * @brief Call the object's destructor. @@ -1101,7 +1097,7 @@ EAPI void eo2_constructor(void); * * @see #eo_constructor */ -EAPI void eo2_destructor(void); +EAPI void eo_destructor(void); /** * @addtogroup Eo_Events Eo's Event Handling @@ -1192,7 +1188,7 @@ struct _Eo_Callback_Array_Item * * @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. @@ -1201,7 +1197,7 @@ EAPI void eo2_event_callback_forwarder_add(const Eo_Event_Description *desc, Eo * * @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. @@ -1210,7 +1206,7 @@ EAPI void eo2_event_callback_forwarder_del(const Eo_Event_Description *desc, Eo * * @see #eo_event_thaw */ -EAPI void eo2_event_freeze(void); +EAPI void eo_event_freeze(void); /** * @brief thaw events of object. @@ -1219,7 +1215,7 @@ EAPI void eo2_event_freeze(void); * * @see #eo_event_freeze */ -EAPI void eo2_event_thaw(void); +EAPI void eo_event_thaw(void); /** * @brief return freeze events of object. @@ -1231,7 +1227,7 @@ EAPI void eo2_event_thaw(void); * @see #eo_event_freeze * @see #eo_event_thaw */ -EAPI int eo2_event_freeze_get(void); +EAPI int eo_event_freeze_get(void); /** * @brief freeze events of object. @@ -1241,7 +1237,7 @@ EAPI int eo2_event_freeze_get(void); * @see #eo_event_freeze * @see #eo_event_global_thaw */ -EAPI void eo2_event_global_freeze(void); +EAPI void eo_event_global_freeze(void); /** * @brief thaw events of object. @@ -1251,7 +1247,7 @@ EAPI void eo2_event_global_freeze(void); * @see #eo_event_thaw * @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. @@ -1264,7 +1260,7 @@ EAPI void eo2_event_global_thaw(void); * @see #eo_event_global_freeze * @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) @@ -1277,8 +1273,8 @@ EAPI int eo2_event_global_freeze_get(void); * * @see eo_event_callback_priority_add() */ -#define eo2_event_callback_add(desc, cb, data) \ - eo2_event_callback_priority_add(desc, \ +#define eo_event_callback_add(desc, cb, data) \ + eo_event_callback_priority_add(desc, \ EO_CALLBACK_PRIORITY_DEFAULT, cb, data) /** @@ -1292,7 +1288,7 @@ EAPI int eo2_event_global_freeze_get(void); * * @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_Event_Cb func, 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. * */ -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, 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() */ -#define eo2_event_callback_array_add(array, data) \ - eo2_event_callback_array_priority_add(array, \ +#define eo_event_callback_array_add(array, data) \ + eo_event_callback_array_priority_add(array, \ 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 */ -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, 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. * */ -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); /** @@ -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[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); /** * @} diff --git a/src/lib/eo/eo.c b/src/lib/eo/eo.c index 9f4222a789..70e88efa02 100644 --- a/src/lib/eo/eo.c +++ b/src/lib/eo/eo.c @@ -184,12 +184,12 @@ _eo_op_class_get(Eo_Op op) return NULL; } -static const Eo2_Op_Description * -_eo2_op_id_desc_get(Eo_Op op) +static const Eo_Op_Description * +_eo_op_id_desc_get(Eo_Op op) { unsigned int i; const _Eo_Class *klass; - const Eo2_Op_Description *op_descs; + const Eo_Op_Description *op_descs; if (op == EO_NOOP) return NULL; @@ -213,12 +213,12 @@ _eo2_op_id_desc_get(Eo_Op op) static const char * _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; } 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; @@ -245,16 +245,16 @@ _eo2_kls_itr_next(const _Eo_Class *orig_kls, const _Eo_Class *cur_klass, Eo_Op o return NULL; } -/************************************ EO2 ************************************/ +/************************************ EO ************************************/ -EAPI Eo2_Hook_Call eo2_hook_call_pre = NULL; -EAPI Eo2_Hook_Call eo2_hook_call_post = NULL; +EAPI Eo_Hook_Call eo_hook_call_pre = NULL; +EAPI Eo_Hook_Call eo_hook_call_post = NULL; // FIXME: Thread Local Storage -#define EO2_INVALID_DATA (void *) -1 -#define EO2_CALL_STACK_DEPTH 30 +#define EO_INVALID_DATA (void *) -1 +#define EO_CALL_STACK_DEPTH 30 -typedef struct _Eo2_Stack_Frame +typedef struct _Eo_Stack_Frame { const Eo *eo_id; union { @@ -263,27 +263,27 @@ typedef struct _Eo2_Stack_Frame } o; const _Eo_Class *cur_klass; 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 { - Eo2_Stack_Frame *frames; - Eo2_Stack_Frame *frame_ptr; - Eo2_Stack_Frame *last_frame; - Eo2_Stack_Frame *shrink_frame; -} Eo2_Call_Stack; +typedef struct _Eo_Call_Stack { + Eo_Stack_Frame *frames; + Eo_Stack_Frame *frame_ptr; + Eo_Stack_Frame *last_frame; + Eo_Stack_Frame *shrink_frame; +} Eo_Call_Stack; -static Eo2_Call_Stack * -_eo2_call_stack_create() +static Eo_Call_Stack * +_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) 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) { free(stack); @@ -292,16 +292,16 @@ _eo2_call_stack_create() // first frame is never used 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; return stack; } 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; @@ -310,24 +310,24 @@ _eo2_call_stack_free(void *ptr) free(stack); } -static inline Eo2_Call_Stack * -_eo2_call_stack_get() +static inline Eo_Call_Stack * +_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; - stack = _eo2_call_stack_create(); + stack = _eo_call_stack_create(); if (!stack) { - EINA_LOG_ERR("Could not alloc eo2 call stack."); + EINA_LOG_ERR("Could not alloc eo call stack."); 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."); - _eo2_call_stack_free(stack); + EINA_LOG_ERR("Could not set eo call stack in TLS key."); + _eo_call_stack_free(stack); return NULL; } @@ -335,7 +335,7 @@ _eo2_call_stack_get() } 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; int frame_offset; @@ -348,7 +348,7 @@ _eo2_call_stack_resize(Eo2_Call_Stack *stack, Eina_Bool grow) next_sz = sz >> 1; 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) { CRI("unable to resize call stack, abort."); @@ -360,7 +360,7 @@ _eo2_call_stack_resize(Eo2_Call_Stack *stack, Eina_Bool grow) if (grow) frame_offset = (sz >> 1); - if (next_sz == EO2_CALL_STACK_DEPTH) + if (next_sz == EO_CALL_STACK_DEPTH) frame_offset = 0; else frame_offset = (next_sz >> 1); @@ -368,22 +368,22 @@ _eo2_call_stack_resize(Eo2_Call_Stack *stack, Eina_Bool grow) } static inline Eina_Bool -_eo2_do_internal(const Eo *eo_id, const Eo_Class *cur_klass_id, - Eina_Bool is_super, Eo2_Stack_Frame *fptr, Eo2_Stack_Frame *pfptr) +_eo_do_internal(const Eo *eo_id, const Eo_Class *cur_klass_id, + Eina_Bool is_super, Eo_Stack_Frame *fptr, Eo_Stack_Frame *pfptr) { 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 (pfptr) { - memcpy(fptr, pfptr, sizeof(Eo2_Stack_Frame)); + memcpy(fptr, pfptr, sizeof(Eo_Stack_Frame)); if (!is_klass) _eo_ref(fptr->o.obj); } else { fptr->eo_id = eo_id; - fptr->obj_data = EO2_INVALID_DATA; + fptr->obj_data = EO_INVALID_DATA; if (is_klass) { 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); if (fptr->cur_klass == cur_klass) - fptr->obj_data = EO2_INVALID_DATA; + fptr->obj_data = EO_INVALID_DATA; fptr->cur_klass = cur_klass; } else @@ -413,20 +413,20 @@ _eo2_do_internal(const Eo *eo_id, const Eo_Class *cur_klass_id, } 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; - Eo2_Call_Stack *stack = _eo2_call_stack_get(); + Eo_Stack_Frame *fptr, *pfptr; + Eo_Call_Stack *stack = _eo_call_stack_get(); 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; pfptr = ((eo_id) && (fptr->eo_id == eo_id) ? fptr : NULL); 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; 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 -_eo2_do_end(const Eo **eo_id EINA_UNUSED) +_eo_do_end(const Eo **eo_id EINA_UNUSED) { - Eo2_Stack_Frame *fptr; - Eo2_Call_Stack *stack = _eo2_call_stack_get(); + Eo_Stack_Frame *fptr; + Eo_Call_Stack *stack = _eo_call_stack_get(); fptr = stack->frame_ptr; if (!_eo_is_a_class(fptr->eo_id) && fptr->o.obj) _eo_unref(fptr->o.obj); - fptr->obj_data = EO2_INVALID_DATA; + fptr->obj_data = EO_INVALID_DATA; if (fptr == stack->frames) { @@ -456,20 +456,20 @@ _eo2_do_end(const Eo **eo_id EINA_UNUSED) stack->frame_ptr--; if (fptr == stack->shrink_frame) - _eo2_call_stack_resize(stack, EINA_FALSE); + _eo_call_stack_resize(stack, EINA_FALSE); } 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 op_type_funcs *func; Eina_Bool is_obj; 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); 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 (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) 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; 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); call->data = fptr->obj_data; @@ -582,14 +582,14 @@ end2: } -static inline const Eo2_Op_Description * -_eo2_api_desc_get(const void *api_func, const _Eo_Class *klass, const _Eo_Class **extns) +static inline const Eo_Op_Description * +_eo_api_desc_get(const void *api_func, const _Eo_Class *klass, const _Eo_Class **extns) { int imin, imax, imid; const _Eo_Class *cur_klass; const _Eo_Class **kls_itr = NULL; - const Eo2_Op_Description *op_desc; - const Eo2_Op_Description *op_descs; + const Eo_Op_Description *op_desc; + const Eo_Op_Description *op_descs; 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++) { 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; } } @@ -630,11 +630,11 @@ _eo2_api_desc_get(const void *api_func, const _Eo_Class *klass, const _Eo_Class } 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; - 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); @@ -643,7 +643,7 @@ _eo2_api_op_id_get(const void *api_func, const char *file, int line) else 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) { @@ -656,24 +656,24 @@ _eo2_api_op_id_get(const void *api_func, const char *file, int line) } 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; - op1 = (Eo2_Op_Description *) p1; - op2 = (Eo2_Op_Description *) p2; + const Eo_Op_Description *op1, *op2; + op1 = (Eo_Op_Description *) p1; + op2 = (Eo_Op_Description *) p2; if (op1->api_func > op2->api_func) return -1; else if (op1->api_func < op2->api_func) return 1; else return 0; } EAPI Eina_Bool -_eo2_class_funcs_set(_Eo_Class *klass) +_eo_class_funcs_set(_Eo_Class *klass) { int op_id; const void *last_api_func; - const Eo2_Op_Description *api_desc; - Eo2_Op_Description *op_desc; - Eo2_Op_Description *op_descs; + const Eo_Op_Description *api_desc; + Eo_Op_Description *op_desc; + Eo_Op_Description *op_descs; op_id = klass->base_id; op_descs = klass->desc->ops.descs2; @@ -682,7 +682,7 @@ _eo2_class_funcs_set(_Eo_Class *klass) 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; 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_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) { @@ -732,7 +732,7 @@ _eo2_class_funcs_set(_Eo_Class *klass) } 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; @@ -780,16 +780,16 @@ _eo2_add_internal_start(const char *file, int line, const Eo_Class *klass_id, Eo _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); } 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; - Eo2_Call_Stack *stack = _eo2_call_stack_get(); + Eo_Stack_Frame *fptr; + Eo_Call_Stack *stack = _eo_call_stack_get(); 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; ERR("in %s:%d: Object of class '%s' - Not all of the object constructors have been executed.", 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); return NULL; @@ -835,7 +835,7 @@ eo_class_get(const Eo *eo_id) if (_eo_is_a_class(eo_id)) { 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); @@ -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->iterators.trash_lock); @@ -1408,7 +1408,7 @@ EAPI void eo_del(const Eo *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); } @@ -1658,13 +1658,13 @@ eo_init(void) EINA_LOG_STATE_INIT); /* bootstrap EO_CLASS_CLASS */ - (void) eo2_class_class_get(); + (void) eo_class_class_get(); - if (_eo2_call_stack_key != 0) - WRN("_eo2_call_stack_key already set, this should not happen."); + if (_eo_call_stack_key != 0) + WRN("_eo_call_stack_key already set, this should not happen."); 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."); return EINA_FALSE; @@ -1699,8 +1699,8 @@ eo_shutdown(void) eina_spinlock_free(&_eo_class_creation_lock); - if (_eo2_call_stack_key != 0) - eina_tls_free(_eo2_call_stack_key); + if (_eo_call_stack_key != 0) + eina_tls_free(_eo_call_stack_key); _eo_free_ids_tables(); @@ -1743,7 +1743,7 @@ eo_composite_attach(Eo *comp_obj_id, Eo *parent_id) comp_obj->composite = EINA_TRUE; *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; } @@ -1765,7 +1765,7 @@ eo_composite_detach(Eo *comp_obj_id, Eo *parent_id) { comp_obj->composite = EINA_FALSE; *comp_itr = NULL; - eo2_do(comp_obj_id, eo2_parent_set(NULL)); + eo_do(comp_obj_id, eo_parent_set(NULL)); return EINA_TRUE; } } diff --git a/src/lib/eo/eo2_base_class.c b/src/lib/eo/eo2_base_class.c index 936cabedbb..e41433d538 100644 --- a/src/lib/eo/eo2_base_class.c +++ b/src/lib/eo/eo2_base_class.c @@ -68,7 +68,7 @@ _data_set(Eo *obj, void *class_data, 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)); if (!node) return; @@ -78,7 +78,7 @@ _data_set(Eo *obj, void *class_data, pd->generic_data = eina_inlist_prepend(pd->generic_data, 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); static void * @@ -102,7 +102,7 @@ _data_get(Eo *obj EINA_UNUSED, void *class_data, const char *key) 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 _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; - 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) { 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) { 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)) { @@ -161,7 +161,7 @@ _parent_set(Eo *obj, void *class_data, Eo *parent_id) 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 * _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; } -EAPI EO2_FUNC_BODY(eo2_parent_get, Eo *, NULL); +EAPI EO_FUNC_BODY(eo_parent_get, Eo *, NULL); /* Children accessor */ 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; } -EAPI EO2_FUNC_BODY(eo2_children_iterator_new, Eina_Iterator *, NULL); +EAPI EO_FUNC_BODY(eo_children_iterator_new, Eina_Iterator *, NULL); static void _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 */ 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 _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. */ @@ -325,7 +325,7 @@ _wref_add(Eo *obj, void *class_data, Eo **wref) pd->wrefs[count] = NULL; *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 _wref_del(Eo *obj, void *class_data, Eo **wref) @@ -386,7 +386,7 @@ _wref_del(Eo *obj, void *class_data, Eo **wref) *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 _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}}; - 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, - EO2_FUNC_CALL(desc, priority, func, user_data), +EAPI EO_VOID_FUNC_BODYV(eo_event_callback_priority_add, + EO_FUNC_CALL(desc, priority, func, user_data), const Eo_Event_Description *desc, Eo_Callback_Priority priority, Eo_Event_Cb func, @@ -566,15 +566,15 @@ _ev_cb_del(Eo *obj, void *class_data, cb->delete_me = EINA_TRUE; pd->deletions_waiting = EINA_TRUE; _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; } } 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, - EO2_FUNC_CALL(desc, func, user_data), +EAPI EO_VOID_FUNC_BODYV(eo_event_callback_del, + EO_FUNC_CALL(desc, func, user_data), const Eo_Event_Description *desc, Eo_Event_Cb func, const void *user_data); @@ -597,11 +597,11 @@ _ev_cb_array_priority_add(Eo *obj, void *class_data, _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, - EO2_FUNC_CALL(array, priority, user_data), +EAPI EO_VOID_FUNC_BODYV(eo_event_callback_array_priority_add, + EO_FUNC_CALL(array, priority, user_data), const Eo_Callback_Array_Item *array, Eo_Callback_Priority priority, const void *user_data); @@ -622,15 +622,15 @@ _ev_cb_array_del(Eo *obj, void *class_data, pd->deletions_waiting = EINA_TRUE; _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; } } 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, - EO2_FUNC_CALL(array, user_data), +EAPI EO_VOID_FUNC_BODYV(eo_event_callback_array_del, + EO_FUNC_CALL(array, user_data), const Eo_Callback_Array_Item *array, const void *user_data); @@ -702,9 +702,9 @@ end: return ret; } -EAPI EO2_FUNC_BODYV(eo2_event_callback_call, Eina_Bool, +EAPI EO_FUNC_BODYV(eo_event_callback_call, Eina_Bool, EINA_FALSE, - EO2_FUNC_CALL(desc, event_info), + EO_FUNC_CALL(desc, event_info), const Eo_Event_Description *desc, 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; 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; } @@ -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); */ - 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, - EO2_FUNC_CALL(desc, new_obj), +EAPI EO_VOID_FUNC_BODYV(eo_event_callback_forwarder_add, + EO_FUNC_CALL(desc, new_obj), const Eo_Event_Description *desc, 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); */ - 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, - EO2_FUNC_CALL(desc, new_obj), +EAPI EO_VOID_FUNC_BODYV(eo_event_callback_forwarder_del, + EO_FUNC_CALL(desc, new_obj), const Eo_Event_Description *desc, Eo *new_obj); @@ -757,7 +757,7 @@ _ev_freeze(Eo *obj EINA_UNUSED, void *class_data) Private_Data *pd = (Private_Data *) class_data; pd->event_freeze_count++; } -EAPI EO2_VOID_FUNC_BODY(eo2_event_freeze); +EAPI EO_VOID_FUNC_BODY(eo_event_freeze); static void _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); } } -EAPI EO2_VOID_FUNC_BODY(eo2_event_thaw); +EAPI EO_VOID_FUNC_BODY(eo_event_thaw); static int _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; } -EAPI EO2_FUNC_BODY(eo2_event_freeze_get, int, 0); +EAPI EO_FUNC_BODY(eo_event_freeze_get, int, 0); static void _ev_global_freeze(const Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED) { event_freeze_count++; } -EAPI EO2_VOID_FUNC_BODY(eo2_event_global_freeze); +EAPI EO_VOID_FUNC_BODY(eo_event_global_freeze); static void _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."); } } -EAPI EO2_VOID_FUNC_BODY(eo2_event_global_thaw); +EAPI EO_VOID_FUNC_BODY(eo_event_global_thaw); static int _ev_global_freeze_get(const Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED) { 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 */ EAPI void -eo2_dbg_info_free(Eo_Dbg_Info *info) +eo_dbg_info_free(Eo_Dbg_Info *info) { eina_value_flush(&(info->value)); free(info); @@ -888,7 +888,7 @@ _eo_dbg_info_pget(const Eina_Value_Type *type EINA_UNUSED, const void *_mem, voi 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, sizeof(Eo_Dbg_Info *), "Eo_Dbg_Info_Ptr", @@ -903,17 +903,17 @@ static const Eina_Value_Type _EO2_DBG_INFO_TYPE = { _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 */ /* EO_BASE_CLASS stuff */ -#define MY_CLASS EO2_BASE_CLASS +#define MY_CLASS EO_BASE_CLASS /* FIXME: Set proper type descriptions. */ -// FIXME: eo2 multiple definition +// FIXME: eo multiple definition /* EAPI const Eo_Event_Description _EO_EV_CALLBACK_ADD = */ /* EO_EVENT_DESCRIPTION("callback,add", "A callback was added."); */ /* 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); } -EAPI EO2_VOID_FUNC_BODY(eo2_constructor); +EAPI EO_VOID_FUNC_BODY(eo_constructor); static void _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)); 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); _wref_destruct(class_data); @@ -947,7 +947,7 @@ _destructor(Eo *obj, void *class_data) _eo_condtor_done(obj); } -EAPI EO2_VOID_FUNC_BODY(eo2_destructor); +EAPI EO_VOID_FUNC_BODY(eo_destructor); static void _class_constructor(Eo_Class *klass EINA_UNUSED) @@ -955,35 +955,35 @@ _class_constructor(Eo_Class *klass EINA_UNUSED) event_freeze_count = 0; } -static Eo2_Op_Description op_descs [] = { - EO2_OP_FUNC(eo2_constructor, _constructor, "Constructor."), - EO2_OP_FUNC(eo2_destructor, _destructor, "Destructor."), - EO2_OP_FUNC(eo2_parent_set, _parent_set, "Set parent."), - EO2_OP_FUNC(eo2_parent_get, _parent_get, "Get parent."), - EO2_OP_FUNC(eo2_children_iterator_new, _children_iterator_new, "Get Children Iterator."), - EO2_OP_FUNC(eo2_base_data_set, _data_set, "Set data for key."), - EO2_OP_FUNC(eo2_base_data_get, _data_get, "Get data for key."), - EO2_OP_FUNC(eo2_base_data_del, _data_del, "Del key."), - EO2_OP_FUNC(eo2_wref_add, _wref_add, "Add a weak ref to the object."), - EO2_OP_FUNC(eo2_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."), - EO2_OP_FUNC(eo2_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."), - EO2_OP_FUNC(eo2_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."), - EO2_OP_FUNC(eo2_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."), - EO2_OP_FUNC(eo2_event_freeze, _ev_freeze, "Freezes events."), - EO2_OP_FUNC(eo2_event_thaw, _ev_thaw, "Thaws events."), - EO2_OP_FUNC(eo2_event_freeze_get, _ev_freeze_get, "Get event freeze counter."), - EO2_OP_FUNC(eo2_event_global_freeze, _ev_global_freeze, "Freezes events globally."), - EO2_OP_FUNC(eo2_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."), - EO2_OP_FUNC(eo2_dbg_info_get, _dbg_info_get, "Get debug info list for obj."), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs [] = { + EO_OP_FUNC(eo_constructor, _constructor, "Constructor."), + EO_OP_FUNC(eo_destructor, _destructor, "Destructor."), + EO_OP_FUNC(eo_parent_set, _parent_set, "Set parent."), + EO_OP_FUNC(eo_parent_get, _parent_get, "Get parent."), + EO_OP_FUNC(eo_children_iterator_new, _children_iterator_new, "Get Children Iterator."), + EO_OP_FUNC(eo_base_data_set, _data_set, "Set data for key."), + EO_OP_FUNC(eo_base_data_get, _data_get, "Get data for key."), + EO_OP_FUNC(eo_base_data_del, _data_del, "Del key."), + EO_OP_FUNC(eo_wref_add, _wref_add, "Add a weak ref to the object."), + EO_OP_FUNC(eo_wref_del, _wref_del, "Delete the weak ref."), + EO_OP_FUNC(eo_event_callback_priority_add, _ev_cb_priority_add, "Add an event callback with a priority."), + EO_OP_FUNC(eo_event_callback_del, _ev_cb_del, "Delete an event callback"), + EO_OP_FUNC(eo_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_del, _ev_cb_array_del, "Delete an event callback array"), + EO_OP_FUNC(eo_event_callback_call, _ev_cb_call, "Call the event callbacks for an event."), + EO_OP_FUNC(eo_event_callback_forwarder_add, _ev_cb_forwarder_add, "Add an event forwarder."), + EO_OP_FUNC(eo_event_callback_forwarder_del, _ev_cb_forwarder_del, "Delete an event forwarder."), + EO_OP_FUNC(eo_event_freeze, _ev_freeze, "Freezes events."), + EO_OP_FUNC(eo_event_thaw, _ev_thaw, "Thaws events."), + EO_OP_FUNC(eo_event_freeze_get, _ev_freeze_get, "Get event freeze counter."), + EO_OP_FUNC(eo_event_global_freeze, _ev_global_freeze, "Freezes events globally."), + EO_OP_FUNC(eo_event_global_thaw, _ev_global_thaw, "Thaws events globally."), + EO_OP_FUNC(eo_event_global_freeze_get, _ev_global_freeze_get, "Get global event freeze counter."), + EO_OP_FUNC(eo_dbg_info_get, _dbg_info_get, "Get debug info list for obj."), + EO_OP_SENTINEL }; -// FIXME: eo2 +// FIXME: eo static const Eo_Event_Description *event_desc[] = { EO_EV_CALLBACK_ADD, EO_EV_CALLBACK_DEL, @@ -992,14 +992,14 @@ static const Eo_Event_Description *event_desc[] = { }; static const Eo_Class_Description class_desc = { - EO2_VERSION, - "Eo2_Base", + EO_VERSION, + "Eo_Base", EO_CLASS_TYPE_REGULAR_NO_INSTANT, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), event_desc, sizeof(Private_Data), _class_constructor, NULL }; -EO_DEFINE_CLASS(eo2_base_class_get, &class_desc, NULL, NULL) +EO_DEFINE_CLASS(eo_base_class_get, &class_desc, NULL, NULL) diff --git a/src/lib/eo/eo2_class_class.c b/src/lib/eo/eo2_class_class.c index a0cab0a813..43c2ffeb8f 100644 --- a/src/lib/eo/eo2_class_class.c +++ b/src/lib/eo/eo2_class_class.c @@ -5,14 +5,14 @@ #include "Eo.h" static const Eo_Class_Description class_desc = { - EO2_VERSION, - "Eo2_Abstract_Class", + EO_VERSION, + "Eo_Abstract_Class", EO_CLASS_TYPE_REGULAR_NO_INSTANT, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, NULL }; -EO_DEFINE_CLASS(eo2_class_class_get, &class_desc, NULL, NULL) +EO_DEFINE_CLASS(eo_class_class_get, &class_desc, NULL, NULL) diff --git a/src/lib/eo/eo_private.h b/src/lib/eo/eo_private.h index ebe16682f4..dd486b4fa0 100644 --- a/src/lib/eo/eo_private.h +++ b/src/lib/eo/eo_private.h @@ -109,7 +109,7 @@ struct _Eo_Object /* [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 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; - 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); 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)) { diff --git a/src/tests/eo/access/access_inherit.c b/src/tests/eo/access/access_inherit.c index 6db73134de..46db0c22ad 100644 --- a/src/tests/eo/access/access_inherit.c +++ b/src/tests/eo/access/access_inherit.c @@ -16,18 +16,18 @@ _prot_print(Eo *obj, void *class_data EINA_UNUSED) 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[] = { - EO2_OP_FUNC(inherit_prot_print, _prot_print, "Print protected var x1."), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC(inherit_prot_print, _prot_print, "Print protected var x1."), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Inherit", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, NULL, diff --git a/src/tests/eo/access/access_main.c b/src/tests/eo/access/access_main.c index 3f624f9acd..61cd381167 100644 --- a/src/tests/eo/access/access_main.c +++ b/src/tests/eo/access/access_main.c @@ -13,9 +13,9 @@ main(int argc, char *argv[]) (void) argv; 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); printf("Pub: %d\n", pd->public_x2); diff --git a/src/tests/eo/access/access_simple.c b/src/tests/eo/access/access_simple.c index 59997f3a78..2eeb8cc570 100644 --- a/src/tests/eo/access/access_simple.c +++ b/src/tests/eo/access/access_simple.c @@ -27,14 +27,14 @@ _a_set(Eo *obj, void *class_data, int a) pd->protected.protected_x1 = a + 1; 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[] = { - EO2_OP_FUNC(simple_a_set, _a_set, "Set property A"), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC(simple_a_set, _a_set, "Set property A"), + EO_OP_SENTINEL }; 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 = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), event_desc, sizeof(Private_Data), 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) diff --git a/src/tests/eo/composite_objects/composite_objects_comp.c b/src/tests/eo/composite_objects/composite_objects_comp.c index 32f22da68a..c711ffe28f 100644 --- a/src/tests/eo/composite_objects/composite_objects_comp.c +++ b/src/tests/eo/composite_objects/composite_objects_comp.c @@ -14,7 +14,7 @@ static int _a_get(Eo *obj, void *class_data EINA_UNUSED) { 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; } @@ -22,37 +22,37 @@ _a_get(Eo *obj, void *class_data EINA_UNUSED) static void _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); - 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(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); } -static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), - EO2_OP_FUNC_OVERRIDE(simple_a_get, _a_get), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor), + EO_OP_FUNC_OVERRIDE(simple_a_get, _a_get), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Comp", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, 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); diff --git a/src/tests/eo/composite_objects/composite_objects_main.c b/src/tests/eo/composite_objects/composite_objects_main.c index b71c4cd585..ecf5983cb0 100644 --- a/src/tests/eo/composite_objects/composite_objects_main.c +++ b/src/tests/eo/composite_objects/composite_objects_main.c @@ -30,27 +30,27 @@ main(int argc, char *argv[]) (void) argv; eo_init(); - Eo *obj = eo2_add(COMP_CLASS, NULL); - eo2_do(obj, eo2_event_callback_add(EV_A_CHANGED, _a_changed_cb, NULL)); + Eo *obj = eo_add(COMP_CLASS, 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, SIMPLE_CLASS)); int a = 0; - eo2_do(obj, simple_a_set(1)); + eo_do(obj, simple_a_set(1)); fail_if(!cb_called); - eo2_do(obj, a = simple_a_get()); + eo_do(obj, a = simple_a_get()); fail_if(a != 1); /* disable the callback forwarder, and fail if it's still called. */ 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); - 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; - eo2_do(obj, simple_a_set(2)); + eo_do(obj, simple_a_set(2)); fail_if(cb_called); fail_if(!eo_composite_is(simple)); diff --git a/src/tests/eo/composite_objects/composite_objects_simple.c b/src/tests/eo/composite_objects/composite_objects_simple.c index e44df196fb..c4490da8c0 100644 --- a/src/tests/eo/composite_objects/composite_objects_simple.c +++ b/src/tests/eo/composite_objects/composite_objects_simple.c @@ -17,7 +17,7 @@ _a_set(Eo *obj, void *class_data, int a) printf("%s %d\n", eo_class_name_get(MY_CLASS), 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 @@ -27,13 +27,13 @@ _a_get(Eo *obj EINA_UNUSED, void *class_data) return pd->a; } -EAPI EO2_VOID_FUNC_BODYV(simple_a_set, EO2_FUNC_CALL(a), int a); -EAPI EO2_FUNC_BODY(simple_a_get, int, 0); +EAPI EO_VOID_FUNC_BODYV(simple_a_set, EO_FUNC_CALL(a), int a); +EAPI EO_FUNC_BODY(simple_a_get, int, 0); -static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC(simple_a_set, _a_set, "Set property A"), - EO2_OP_FUNC(simple_a_get, _a_get, "Get property A"), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC(simple_a_set, _a_set, "Set property A"), + EO_OP_FUNC(simple_a_get, _a_get, "Get property A"), + EO_OP_SENTINEL }; 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 = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), event_desc, sizeof(Simple_Public_Data), 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); diff --git a/src/tests/eo/constructors/constructors_main.c b/src/tests/eo/constructors/constructors_main.c index e40ec915a4..7b7da023f1 100644 --- a/src/tests/eo/constructors/constructors_main.c +++ b/src/tests/eo/constructors/constructors_main.c @@ -24,14 +24,14 @@ main(int argc, char *argv[]) (void) argv; eo_init(); - Eo *obj = eo2_add(SIMPLE_CLASS, NULL); + Eo *obj = eo_add(SIMPLE_CLASS, NULL); 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; - 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(b != 2); @@ -39,14 +39,14 @@ main(int argc, char *argv[]) fail_if(my_init_count != 0); - obj = eo2_add(SIMPLE2_CLASS, NULL); + obj = eo_add(SIMPLE2_CLASS, NULL); fail_if(obj); - obj = eo2_add(SIMPLE3_CLASS, NULL); + obj = eo_add(SIMPLE3_CLASS, NULL); fail_if(obj); my_init_count = 0; - obj = eo2_add(SIMPLE4_CLASS, NULL); + obj = eo_add(SIMPLE4_CLASS, NULL); fail_if(my_init_count != 2); @@ -54,23 +54,23 @@ main(int argc, char *argv[]) fail_if(my_init_count != 0); - obj = eo2_add(SIMPLE5_CLASS, NULL); + obj = eo_add(SIMPLE5_CLASS, NULL); fail_if(!obj); eo_unref(obj); - obj = eo2_add(SIMPLE6_CLASS, NULL); + obj = eo_add(SIMPLE6_CLASS, NULL); fail_if(!obj); eo_unref(obj); - obj = eo2_add(SIMPLE7_CLASS, NULL); + obj = eo_add(SIMPLE7_CLASS, NULL); fail_if(obj); 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(my_init_count != 2); - eo2_do(obj, a = simple_a_get()); + eo_do(obj, a = simple_a_get()); fail_if(a != 7); eo_unref(obj); diff --git a/src/tests/eo/constructors/constructors_mixin.c b/src/tests/eo/constructors/constructors_mixin.c index 69a957aee2..3076802143 100644 --- a/src/tests/eo/constructors/constructors_mixin.c +++ b/src/tests/eo/constructors/constructors_mixin.c @@ -12,7 +12,7 @@ static void _add_and_print_set(Eo *obj, void *class_data EINA_UNUSED, int x) { 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); } @@ -21,7 +21,7 @@ extern int my_init_count; static void _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++; } @@ -29,30 +29,30 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED) static void _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--; } -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[] = { - EO2_OP_FUNC(mixin_add_and_print, _add_and_print_set, "Add A + B + param and print it"), - EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), - EO2_OP_FUNC_OVERRIDE(eo2_destructor, _destructor), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC(mixin_add_and_print, _add_and_print_set, "Add A + B + param and print it"), + EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor), + EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Mixin", EO_CLASS_TYPE_MIXIN, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, 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); diff --git a/src/tests/eo/constructors/constructors_simple.c b/src/tests/eo/constructors/constructors_simple.c index dfa51bf75e..3441d44451 100644 --- a/src/tests/eo/constructors/constructors_simple.c +++ b/src/tests/eo/constructors/constructors_simple.c @@ -31,8 +31,8 @@ _##name##_set(Eo *obj EINA_UNUSED, void *class_data, int name) \ pd->name = name; \ printf("%s %d\n", __func__, pd->name); \ } \ -EO2_VOID_FUNC_BODYV(simple_##name##_set, EO2_FUNC_CALL(name), int name); \ -EO2_FUNC_BODY(simple_##name##_get, int, 0); +EO_VOID_FUNC_BODYV(simple_##name##_set, EO_FUNC_CALL(name), int name); \ +EO_FUNC_BODY(simple_##name##_get, int, 0); _GET_SET_FUNC(a) _GET_SET_FUNC(b) @@ -44,7 +44,7 @@ _simple_constructor(Eo *obj, void *class_data, int a) { Private_Data *pd = class_data; - eo2_do_super(obj, MY_CLASS, eo2_constructor()); + eo_do_super(obj, MY_CLASS, eo_constructor()); pd->a = a; printf("%s %d\n", __func__, pd->a); @@ -55,7 +55,7 @@ _simple_constructor(Eo *obj, void *class_data, int a) static void _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++; } @@ -63,7 +63,7 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED) static void _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--; } @@ -80,30 +80,30 @@ _class_destructor(Eo_Class *klass EINA_UNUSED) free(class_var); } -EO2_VOID_FUNC_BODYV(simple_constructor, EO2_FUNC_CALL(a), int a); - -static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), - EO2_OP_FUNC_OVERRIDE(eo2_destructor, _destructor), - EO2_OP_FUNC(simple_constructor, _simple_constructor, "Construct and set A."), - EO2_OP_FUNC(simple_a_set, _a_set, "Set property a"), - EO2_OP_FUNC(simple_a_get, _a_get, "Get property a"), - EO2_OP_FUNC(simple_b_set, _b_set, "Set property b"), - EO2_OP_FUNC(simple_b_get, _b_get, "Get property b"), - EO2_OP_SENTINEL +EO_VOID_FUNC_BODYV(simple_constructor, EO_FUNC_CALL(a), int a); + +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor), + EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor), + EO_OP_FUNC(simple_constructor, _simple_constructor, "Construct and set A."), + EO_OP_FUNC(simple_a_set, _a_set, "Set property a"), + EO_OP_FUNC(simple_a_get, _a_get, "Get property a"), + EO_OP_FUNC(simple_b_set, _b_set, "Set property b"), + EO_OP_FUNC(simple_b_get, _b_get, "Get property b"), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Private_Data), _class_constructor, _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); diff --git a/src/tests/eo/constructors/constructors_simple2.c b/src/tests/eo/constructors/constructors_simple2.c index b7b4aaef2d..06c9e1d87a 100644 --- a/src/tests/eo/constructors/constructors_simple2.c +++ b/src/tests/eo/constructors/constructors_simple2.c @@ -11,26 +11,26 @@ static void _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); } -static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple2", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, 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); diff --git a/src/tests/eo/constructors/constructors_simple3.c b/src/tests/eo/constructors/constructors_simple3.c index 233005eecb..79ef940c8c 100644 --- a/src/tests/eo/constructors/constructors_simple3.c +++ b/src/tests/eo/constructors/constructors_simple3.c @@ -14,21 +14,21 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) (void) obj; } -static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple3", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, 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); diff --git a/src/tests/eo/constructors/constructors_simple4.c b/src/tests/eo/constructors/constructors_simple4.c index 71fca13476..a7f627b09f 100644 --- a/src/tests/eo/constructors/constructors_simple4.c +++ b/src/tests/eo/constructors/constructors_simple4.c @@ -10,10 +10,10 @@ #define MY_CLASS SIMPLE4_CLASS static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple4", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, diff --git a/src/tests/eo/constructors/constructors_simple5.c b/src/tests/eo/constructors/constructors_simple5.c index b64b969819..bbfbafd00e 100644 --- a/src/tests/eo/constructors/constructors_simple5.c +++ b/src/tests/eo/constructors/constructors_simple5.c @@ -14,21 +14,21 @@ _destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) (void) obj; } -static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC_OVERRIDE(eo2_destructor, _destructor), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple5", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, 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); diff --git a/src/tests/eo/constructors/constructors_simple6.c b/src/tests/eo/constructors/constructors_simple6.c index 7a23eb31d4..71e29953f4 100644 --- a/src/tests/eo/constructors/constructors_simple6.c +++ b/src/tests/eo/constructors/constructors_simple6.c @@ -11,26 +11,26 @@ static void _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); } -static Eo2_Op_Description op_descs [] = { - EO2_OP_FUNC_OVERRIDE(eo2_destructor, _destructor), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs [] = { + EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple6", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, 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); diff --git a/src/tests/eo/constructors/constructors_simple7.c b/src/tests/eo/constructors/constructors_simple7.c index fb4a731261..cd0298948d 100644 --- a/src/tests/eo/constructors/constructors_simple7.c +++ b/src/tests/eo/constructors/constructors_simple7.c @@ -15,19 +15,19 @@ static void _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) { /* 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 [] = { - EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs [] = { + EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple7", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, NULL, diff --git a/src/tests/eo/function_overrides/function_overrides_inherit.c b/src/tests/eo/function_overrides/function_overrides_inherit.c index 641c07c49e..3a767f9e1a 100644 --- a/src/tests/eo/function_overrides/function_overrides_inherit.c +++ b/src/tests/eo/function_overrides/function_overrides_inherit.c @@ -9,10 +9,10 @@ #define MY_CLASS INHERIT_CLASS static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Inherit", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, diff --git a/src/tests/eo/function_overrides/function_overrides_inherit2.c b/src/tests/eo/function_overrides/function_overrides_inherit2.c index 6a2369a6fc..a892aaf96e 100644 --- a/src/tests/eo/function_overrides/function_overrides_inherit2.c +++ b/src/tests/eo/function_overrides/function_overrides_inherit2.c @@ -15,11 +15,11 @@ static void _a_set(Eo *obj, void *class_data EINA_UNUSED, int a) { printf("%s %d\n", eo_class_name_get(MY_CLASS), a); - eo2_do(obj, simple_a_print()); - eo2_do_super(obj, MY_CLASS, simple_a_set(a + 1)); + eo_do(obj, simple_a_print()); + eo_do_super(obj, MY_CLASS, simple_a_set(a + 1)); 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); } @@ -28,7 +28,7 @@ _print(Eo *obj, void *class_data EINA_UNUSED) { Eina_Bool called = EINA_FALSE; printf("Hey\n"); - eo2_do_super(obj, MY_CLASS, called = inherit2_print()); + eo_do_super(obj, MY_CLASS, called = inherit2_print()); fail_if(called); return EINA_TRUE; @@ -47,31 +47,31 @@ _class_print(Eo_Class *klass, void *data EINA_UNUSED) { Eina_Bool called = EINA_FALSE; 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); - eo2_do_super(klass, MY_CLASS, called = simple_class_print2()); + eo_do_super(klass, MY_CLASS, called = simple_class_print2()); fail_if(!called); return EINA_TRUE; } -EAPI EO2_FUNC_BODY(inherit2_print, Eina_Bool, EINA_FALSE); -EAPI EO2_FUNC_BODY(inherit2_print2, Eina_Bool, EINA_FALSE); +EAPI EO_FUNC_BODY(inherit2_print, Eina_Bool, EINA_FALSE); +EAPI EO_FUNC_BODY(inherit2_print2, Eina_Bool, EINA_FALSE); -static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC(inherit2_print, _print, "Print hey"), - EO2_OP_FUNC(inherit2_print2, _print2, "Print hey2"), - EO2_OP_CLASS_FUNC_OVERRIDE(simple_class_print, _class_print), - EO2_OP_FUNC_OVERRIDE(simple_a_set, _a_set), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC(inherit2_print, _print, "Print hey"), + EO_OP_FUNC(inherit2_print2, _print2, "Print hey2"), + EO_OP_CLASS_FUNC_OVERRIDE(simple_class_print, _class_print), + EO_OP_FUNC_OVERRIDE(simple_a_set, _a_set), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Inherit2", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, NULL, diff --git a/src/tests/eo/function_overrides/function_overrides_inherit3.c b/src/tests/eo/function_overrides/function_overrides_inherit3.c index 68214b7b26..d8b6190098 100644 --- a/src/tests/eo/function_overrides/function_overrides_inherit3.c +++ b/src/tests/eo/function_overrides/function_overrides_inherit3.c @@ -13,19 +13,19 @@ static void _a_set(Eo *obj, void *class_data EINA_UNUSED, int 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[] = { - EO2_OP_FUNC_OVERRIDE(simple_a_set, _a_set), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(simple_a_set, _a_set), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Inherit3", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, NULL, diff --git a/src/tests/eo/function_overrides/function_overrides_main.c b/src/tests/eo/function_overrides/function_overrides_main.c index 17aab2910d..920595c077 100644 --- a/src/tests/eo/function_overrides/function_overrides_main.c +++ b/src/tests/eo/function_overrides/function_overrides_main.c @@ -18,57 +18,57 @@ main(int argc, char *argv[]) eo_init(); 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); fail_if(pd->a != 2); 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); fail_if(pd->a != 3); eo_unref(obj); - obj = eo2_add(INHERIT2_CLASS, NULL); - eo2_do(obj, called = inherit2_print()); + obj = eo_add(INHERIT2_CLASS, NULL); + eo_do(obj, called = inherit2_print()); fail_if(!called); - eo2_do(obj, called = inherit2_print(), called = inherit2_print()); + eo_do(obj, called = inherit2_print(), called = inherit2_print()); fail_if(!called); eo_unref(obj); - obj = eo2_add(SIMPLE_CLASS, NULL); - eo2_do(obj, called = inherit2_print()); + obj = eo_add(SIMPLE_CLASS, NULL); + eo_do(obj, called = inherit2_print()); fail_if(called); #ifdef EO_DEBUG - eo2_do(obj, called = simple_class_print()); + eo_do(obj, called = simple_class_print()); fail_if(called); #endif - eo2_do(SIMPLE_CLASS, called = simple_class_print()); + eo_do(SIMPLE_CLASS, called = simple_class_print()); fail_if(!called); - eo2_do(INHERIT_CLASS, called = simple_class_print()); + eo_do(INHERIT_CLASS, called = simple_class_print()); fail_if(!called); - eo2_do(INHERIT2_CLASS, called = simple_class_print()); + eo_do(INHERIT2_CLASS, called = simple_class_print()); fail_if(!called); - eo2_do(INHERIT3_CLASS, called = simple_class_print()); + eo_do(INHERIT3_CLASS, called = simple_class_print()); fail_if(!called); #ifdef EO_DEBUG - eo2_do(SIMPLE_CLASS, called = simple_a_print()); + eo_do(SIMPLE_CLASS, called = simple_a_print()); fail_if(called); #endif - eo2_do_super(obj, SIMPLE_CLASS, eo2_constructor()); - eo2_do_super(obj, SIMPLE_CLASS, eo2_destructor()); + eo_do_super(obj, SIMPLE_CLASS, eo_constructor()); + eo_do_super(obj, SIMPLE_CLASS, eo_destructor()); eo_unref(obj); diff --git a/src/tests/eo/function_overrides/function_overrides_simple.c b/src/tests/eo/function_overrides/function_overrides_simple.c index 1e2ef0e6f7..ce6590b143 100644 --- a/src/tests/eo/function_overrides/function_overrides_simple.c +++ b/src/tests/eo/function_overrides/function_overrides_simple.c @@ -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)); 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); - eo2_do_super(klass, MY_CLASS, called = simple_class_print2()); + eo_do_super(klass, MY_CLASS, called = simple_class_print2()); fail_if(called); return EINA_TRUE; @@ -51,29 +51,29 @@ _class_print2(Eo_Class *klass, void *class_data EINA_UNUSED) return EINA_TRUE; } -EAPI EO2_VOID_FUNC_BODYV(simple_a_set, EO2_FUNC_CALL(a), int a); -EAPI EO2_FUNC_BODY(simple_a_print, Eina_Bool, EINA_FALSE); -EAPI EO2_FUNC_BODY(simple_class_print, Eina_Bool, EINA_FALSE); -EAPI EO2_FUNC_BODY(simple_class_print2, Eina_Bool, EINA_FALSE); - -static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC(simple_a_set, _a_set, "Set property A"), - EO2_OP_FUNC(simple_a_print, _a_print, "Print property A"), - EO2_OP_FUNC(simple_class_print, _class_print, "Print class name."), - EO2_OP_FUNC(simple_class_print2, _class_print2, "Print2 class name."), - EO2_OP_SENTINEL +EAPI EO_VOID_FUNC_BODYV(simple_a_set, EO_FUNC_CALL(a), int a); +EAPI EO_FUNC_BODY(simple_a_print, Eina_Bool, EINA_FALSE); +EAPI EO_FUNC_BODY(simple_class_print, Eina_Bool, EINA_FALSE); +EAPI EO_FUNC_BODY(simple_class_print2, Eina_Bool, EINA_FALSE); + +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC(simple_a_set, _a_set, "Set property A"), + EO_OP_FUNC(simple_a_print, _a_print, "Print property A"), + EO_OP_FUNC(simple_class_print, _class_print, "Print class name."), + EO_OP_FUNC(simple_class_print2, _class_print2, "Print2 class name."), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Simple_Public_Data), 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); diff --git a/src/tests/eo/interface/interface_interface.c b/src/tests/eo/interface/interface_interface.c index eac93cd2b0..7a58a3b8fa 100644 --- a/src/tests/eo/interface/interface_interface.c +++ b/src/tests/eo/interface/interface_interface.c @@ -8,18 +8,18 @@ #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[] = { - EO2_OP_FUNC(interface_ab_sum_get, NULL, "Get the sum of a and b."), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC(interface_ab_sum_get, NULL, "Get the sum of a and b."), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Interface", EO_CLASS_TYPE_INTERFACE, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, NULL, diff --git a/src/tests/eo/interface/interface_interface2.c b/src/tests/eo/interface/interface_interface2.c index 198850da05..5e29c1712b 100644 --- a/src/tests/eo/interface/interface_interface2.c +++ b/src/tests/eo/interface/interface_interface2.c @@ -9,18 +9,18 @@ #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[] = { - EO2_OP_FUNC(interface2_ab_sum_get2, NULL, "Print the sum of a and b."), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC(interface2_ab_sum_get2, NULL, "Print the sum of a and b."), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Interface2", EO_CLASS_TYPE_INTERFACE, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, NULL, diff --git a/src/tests/eo/interface/interface_main.c b/src/tests/eo/interface/interface_main.c index 6fe9de131f..40936d42e7 100644 --- a/src/tests/eo/interface/interface_main.c +++ b/src/tests/eo/interface/interface_main.c @@ -16,18 +16,18 @@ main(int argc, char *argv[]) (void) argv; 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; - 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); 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); - 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); eo_unref(obj); diff --git a/src/tests/eo/interface/interface_simple.c b/src/tests/eo/interface/interface_simple.c index 32cd9cb31b..e4bd477357 100644 --- a/src/tests/eo/interface/interface_simple.c +++ b/src/tests/eo/interface/interface_simple.c @@ -30,8 +30,8 @@ _##name##_set(Eo *obj EINA_UNUSED, void *class_data, int name) \ pd->name = name; \ printf("%s %d\n", __func__, pd->name); \ } \ -EO2_VOID_FUNC_BODYV(simple_##name##_set, EO2_FUNC_CALL(name), int name); \ -EO2_FUNC_BODY(simple_##name##_get, int, 0); +EO_VOID_FUNC_BODYV(simple_##name##_set, EO_FUNC_CALL(name), int name); \ +EO_FUNC_BODY(simple_##name##_get, int, 0); _GET_SET_FUNC(a) _GET_SET_FUNC(b) @@ -40,7 +40,7 @@ static int _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED) { 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__); return a + b; } @@ -49,30 +49,30 @@ static int _ab_sum_get2(Eo *obj, void *class_data EINA_UNUSED) { 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__); return a + b + 1; } -static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC(simple_a_set, _a_set, "Set property a"), - EO2_OP_FUNC(simple_a_get, _a_get, "Get property a"), - EO2_OP_FUNC(simple_b_set, _b_set, "Set property b"), - EO2_OP_FUNC(simple_b_get, _b_get, "Get property b"), - EO2_OP_FUNC_OVERRIDE(interface_ab_sum_get, _ab_sum_get), - EO2_OP_FUNC_OVERRIDE(interface2_ab_sum_get2, _ab_sum_get2), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC(simple_a_set, _a_set, "Set property a"), + EO_OP_FUNC(simple_a_get, _a_get, "Get property a"), + EO_OP_FUNC(simple_b_set, _b_set, "Set property b"), + EO_OP_FUNC(simple_b_get, _b_get, "Get property b"), + EO_OP_FUNC_OVERRIDE(interface_ab_sum_get, _ab_sum_get), + EO_OP_FUNC_OVERRIDE(interface2_ab_sum_get2, _ab_sum_get2), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Private_Data), 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); diff --git a/src/tests/eo/mixin/mixin_inherit.c b/src/tests/eo/mixin/mixin_inherit.c index 4578b54039..521acbe721 100644 --- a/src/tests/eo/mixin/mixin_inherit.c +++ b/src/tests/eo/mixin/mixin_inherit.c @@ -13,22 +13,22 @@ static int _a_get(Eo *obj, void *class_data EINA_UNUSED) { 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); return ret; } -static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC_OVERRIDE(simple_a_get, _a_get), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(simple_a_get, _a_get), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Inherit", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, NULL, diff --git a/src/tests/eo/mixin/mixin_main.c b/src/tests/eo/mixin/mixin_main.c index a0221b3bf0..6ab6af288e 100644 --- a/src/tests/eo/mixin/mixin_main.c +++ b/src/tests/eo/mixin/mixin_main.c @@ -18,15 +18,15 @@ main(int argc, char *argv[]) (void) argv; 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; - 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... */ - 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); fail_if(pd2->count != 6); @@ -36,8 +36,8 @@ main(int argc, char *argv[]) eo_unref(obj); - obj = eo2_add(INHERIT_CLASS, NULL); - eo2_do(obj, simple_a_set(5), a = simple_a_get()); + obj = eo_add(INHERIT_CLASS, NULL); + eo_do(obj, simple_a_set(5), a = simple_a_get()); printf("%d\n", a); fail_if(a != 5); diff --git a/src/tests/eo/mixin/mixin_mixin.c b/src/tests/eo/mixin/mixin_mixin.c index 0392e9099c..073ad3b988 100644 --- a/src/tests/eo/mixin/mixin_mixin.c +++ b/src/tests/eo/mixin/mixin_mixin.c @@ -12,7 +12,7 @@ static int _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED) { 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__); return a + b; } @@ -20,34 +20,34 @@ _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED) static void _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 _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[] = { - EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), - EO2_OP_FUNC_OVERRIDE(eo2_destructor, _destructor), - EO2_OP_FUNC(mixin_ab_sum_get, _ab_sum_get, "Get the sum of a and b."), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor), + EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor), + EO_OP_FUNC(mixin_ab_sum_get, _ab_sum_get, "Get the sum of a and b."), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Mixin", EO_CLASS_TYPE_MIXIN, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, 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) diff --git a/src/tests/eo/mixin/mixin_mixin2.c b/src/tests/eo/mixin/mixin_mixin2.c index 621715ea86..6df0a85fec 100644 --- a/src/tests/eo/mixin/mixin_mixin2.c +++ b/src/tests/eo/mixin/mixin_mixin2.c @@ -18,14 +18,14 @@ _ab_sum_get(Eo *obj, void *class_data) Mixin2_Public_Data *pd = (Mixin2_Public_Data *) class_data; int sum = 0; 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; pd->count += 2; { 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); } @@ -35,27 +35,27 @@ _ab_sum_get(Eo *obj, void *class_data) static void _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 _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[] = { - EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), - EO2_OP_FUNC_OVERRIDE(eo2_destructor, _destructor), - EO2_OP_FUNC_OVERRIDE(mixin_ab_sum_get, _ab_sum_get), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor), + EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor), + EO_OP_FUNC_OVERRIDE(mixin_ab_sum_get, _ab_sum_get), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Mixin2", EO_CLASS_TYPE_MIXIN, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Mixin2_Public_Data), NULL, diff --git a/src/tests/eo/mixin/mixin_mixin3.c b/src/tests/eo/mixin/mixin_mixin3.c index 1a90847e1f..6d0d99d4f8 100644 --- a/src/tests/eo/mixin/mixin_mixin3.c +++ b/src/tests/eo/mixin/mixin_mixin3.c @@ -18,14 +18,14 @@ _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED) Mixin3_Public_Data *pd = (Mixin3_Public_Data *) class_data; int sum = 0; 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; pd->count += 3; { 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); } @@ -35,27 +35,27 @@ _ab_sum_get(Eo *obj, void *class_data EINA_UNUSED) static void _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 _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[] = { - EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), - EO2_OP_FUNC_OVERRIDE(eo2_destructor, _destructor), - EO2_OP_FUNC_OVERRIDE(mixin_ab_sum_get, _ab_sum_get), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor), + EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor), + EO_OP_FUNC_OVERRIDE(mixin_ab_sum_get, _ab_sum_get), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Mixin3", EO_CLASS_TYPE_MIXIN, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Mixin3_Public_Data), NULL, diff --git a/src/tests/eo/mixin/mixin_mixin4.c b/src/tests/eo/mixin/mixin_mixin4.c index efd9e42990..f4e312f77b 100644 --- a/src/tests/eo/mixin/mixin_mixin4.c +++ b/src/tests/eo/mixin/mixin_mixin4.c @@ -12,10 +12,10 @@ #define MY_CLASS MIXIN4_CLASS static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Mixin4", EO_CLASS_TYPE_MIXIN, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, diff --git a/src/tests/eo/mixin/mixin_simple.c b/src/tests/eo/mixin/mixin_simple.c index 879728964f..5da36be987 100644 --- a/src/tests/eo/mixin/mixin_simple.c +++ b/src/tests/eo/mixin/mixin_simple.c @@ -31,31 +31,31 @@ _##name##_set(Eo *obj EINA_UNUSED, void *class_data, int name) \ pd->name = name; \ printf("%s %d\n", __func__, pd->name); \ } \ -EO2_VOID_FUNC_BODYV(simple_##name##_set, EO2_FUNC_CALL(name), int name); \ -EO2_FUNC_BODY(simple_##name##_get, int, 0); +EO_VOID_FUNC_BODYV(simple_##name##_set, EO_FUNC_CALL(name), int name); \ +EO_FUNC_BODY(simple_##name##_get, int, 0); _GET_SET_FUNC(a) _GET_SET_FUNC(b) -static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC(simple_a_set, _a_set, "Set property a"), - EO2_OP_FUNC(simple_a_get, _a_get, "Get property a"), - EO2_OP_FUNC(simple_b_set, _b_set, "Set property b"), - EO2_OP_FUNC(simple_b_get, _b_get, "Get property b"), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC(simple_a_set, _a_set, "Set property a"), + EO_OP_FUNC(simple_a_get, _a_get, "Get property a"), + EO_OP_FUNC(simple_b_set, _b_set, "Set property b"), + EO_OP_FUNC(simple_b_get, _b_get, "Get property b"), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Private_Data), 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); diff --git a/src/tests/eo/signals/signals_main.c b/src/tests/eo/signals/signals_main.c index 17f6af1b54..eb0784febd 100644 --- a/src/tests/eo/signals/signals_main.c +++ b/src/tests/eo/signals/signals_main.c @@ -29,8 +29,8 @@ _a_changed_cb(void *data, Eo *obj, const Eo_Event_Description *desc, void *event cb_count++; - eo2_do(obj, eo2_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_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _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. */ return (cb_count != 3); @@ -43,136 +43,136 @@ main(int argc, char *argv[]) (void) argv; 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); /* 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)); - 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 *) 2)); + 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. */ - 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. */ - 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); - 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); - 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); - 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); - 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); - 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); /* Freeze/thaw. */ int fcount = 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); - eo2_do(obj, fcount = eo2_event_freeze_get()); + eo_do(obj, fcount = eo_event_freeze_get()); fail_if(fcount != 0); - eo2_do(obj, eo2_event_freeze()); - eo2_do(obj, fcount = eo2_event_freeze_get()); + eo_do(obj, eo_event_freeze()); + eo_do(obj, fcount = eo_event_freeze_get()); fail_if(fcount != 1); - eo2_do(obj, eo2_event_freeze()); - eo2_do(obj, fcount = eo2_event_freeze_get()); + eo_do(obj, eo_event_freeze()); + eo_do(obj, fcount = eo_event_freeze_get()); 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); - eo2_do(obj, simple_a_set(2)); + eo_do(obj, simple_a_set(2)); fail_if(cb_count != 0); - eo2_do(obj, eo2_event_thaw()); - eo2_do(obj, fcount = eo2_event_freeze_get()); + eo_do(obj, eo_event_thaw()); + eo_do(obj, fcount = eo_event_freeze_get()); fail_if(fcount != 1); - eo2_do(obj, eo2_event_thaw()); - eo2_do(obj, fcount = eo2_event_freeze_get()); + eo_do(obj, eo_event_thaw()); + eo_do(obj, fcount = eo_event_freeze_get()); fail_if(fcount != 0); - eo2_do(obj, simple_a_set(3)); + eo_do(obj, simple_a_set(3)); fail_if(cb_count != 2); cb_count = 0; - eo2_do(obj, eo2_event_thaw()); - eo2_do(obj, fcount = eo2_event_freeze_get()); + eo_do(obj, eo_event_thaw()); + eo_do(obj, fcount = eo_event_freeze_get()); fail_if(fcount != 0); - eo2_do(obj, eo2_event_freeze()); - eo2_do(obj, fcount = eo2_event_freeze_get()); + eo_do(obj, eo_event_freeze()); + eo_do(obj, fcount = eo_event_freeze_get()); fail_if(fcount != 1); - eo2_do(obj, simple_a_set(2)); + eo_do(obj, simple_a_set(2)); fail_if(cb_count != 0); - eo2_do(obj, eo2_event_thaw()); - eo2_do(obj, fcount = eo2_event_freeze_get()); + eo_do(obj, eo_event_thaw()); + eo_do(obj, fcount = eo_event_freeze_get()); 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); - 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); /* Global Freeze/thaw. */ fcount = 0; 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); - 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); - eo2_do(EO2_BASE_CLASS, eo2_event_global_freeze()); - eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); + eo_do(EO_BASE_CLASS, eo_event_global_freeze()); + eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get()); fail_if(fcount != 1); - eo2_do(EO2_BASE_CLASS, eo2_event_global_freeze()); - eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); + eo_do(EO_BASE_CLASS, eo_event_global_freeze()); + eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get()); 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); - eo2_do(obj, simple_a_set(2)); + eo_do(obj, simple_a_set(2)); fail_if(cb_count != 0); - eo2_do(EO2_BASE_CLASS, eo2_event_global_thaw()); - eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); + eo_do(EO_BASE_CLASS, eo_event_global_thaw()); + eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get()); fail_if(fcount != 1); - eo2_do(EO2_BASE_CLASS, eo2_event_global_thaw()); - eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); + eo_do(EO_BASE_CLASS, eo_event_global_thaw()); + eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get()); fail_if(fcount != 0); - eo2_do(obj, simple_a_set(3)); + eo_do(obj, simple_a_set(3)); fail_if(cb_count != 2); cb_count = 0; - eo2_do(EO2_BASE_CLASS, eo2_event_global_thaw()); - eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); + eo_do(EO_BASE_CLASS, eo_event_global_thaw()); + eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get()); fail_if(fcount != 0); - eo2_do(EO2_BASE_CLASS, eo2_event_global_freeze()); - eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); + eo_do(EO_BASE_CLASS, eo_event_global_freeze()); + eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get()); fail_if(fcount != 1); - eo2_do(obj, simple_a_set(2)); + eo_do(obj, simple_a_set(2)); fail_if(cb_count != 0); - eo2_do(EO2_BASE_CLASS, eo2_event_global_thaw()); - eo2_do(EO2_BASE_CLASS, fcount = eo2_event_global_freeze_get()); + eo_do(EO_BASE_CLASS, eo_event_global_thaw()); + eo_do(EO_BASE_CLASS, fcount = eo_event_global_freeze_get()); fail_if(fcount != 0); diff --git a/src/tests/eo/signals/signals_simple.c b/src/tests/eo/signals/signals_simple.c index 1de1ad9e34..6786aae8fb 100644 --- a/src/tests/eo/signals/signals_simple.c +++ b/src/tests/eo/signals/signals_simple.c @@ -23,7 +23,7 @@ _a_set(Eo *obj, void *class_data, int a) pd->a = 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 @@ -63,20 +63,20 @@ _cb_deled(void *data, Eo *obj, const Eo_Event_Description *desc, void *event_inf static void _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)); - eo2_do(obj, eo2_event_callback_add(EO_EV_CALLBACK_DEL, _cb_deled, NULL)); + eo_do(obj, eo_event_callback_add(EO_EV_CALLBACK_ADD, _cb_added, 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[] = { - EO2_OP_FUNC_OVERRIDE(eo2_constructor, _constructor), - EO2_OP_FUNC(simple_a_set, _a_set, "Set property a"), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor), + EO_OP_FUNC(simple_a_set, _a_set, "Set property a"), + EO_OP_SENTINEL }; @@ -86,15 +86,15 @@ static const Eo_Event_Description *event_desc[] = { }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), event_desc, sizeof(Private_Data), 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); diff --git a/src/tests/eo/suite/eo_test_call_errors.c b/src/tests/eo/suite/eo_test_call_errors.c index 76a60ffc53..08e1635a7d 100644 --- a/src/tests/eo/suite/eo_test_call_errors.c +++ b/src/tests/eo/suite/eo_test_call_errors.c @@ -16,11 +16,11 @@ START_TEST(eo_pure_virtual_fct_call) eo_init(); 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); - TEST_EO_ERROR("_eo2_call_resolve", "in %s:%d: you called a pure virtual func '%s' (%d)."); - eo2_do(obj, simple_pure_virtual()); + TEST_EO_ERROR("_eo_call_resolve", "in %s:%d: you called a pure virtual func '%s' (%d)."); + eo_do(obj, simple_pure_virtual()); fail_unless(ctx.did); eo_unref(obj); @@ -34,11 +34,11 @@ START_TEST(eo_api_not_implemented_call) eo_init(); 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); - TEST_EO_ERROR("_eo2_api_op_id_get", "in %s:%d: unable to resolve %s api func %p."); - eo2_do(obj, simple_no_implementation()); + TEST_EO_ERROR("_eo_api_op_id_get", "in %s:%d: unable to resolve %s api func %p."); + eo_do(obj, simple_no_implementation()); fail_unless(ctx.did); eo_unref(obj); @@ -52,11 +52,11 @@ START_TEST(eo_op_not_found_in_super) eo_init(); 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); - TEST_EO_ERROR("_eo2_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)); + TEST_EO_ERROR("_eo_call_resolve", "in %s:%d: func '%s' (%d) could not be resolved for class '%s' for super of '%s'."); + eo_do_super(obj, SIMPLE_CLASS, simple_a_set(10)); fail_unless(ctx.did); eo_unref(obj); diff --git a/src/tests/eo/suite/eo_test_class_errors.c b/src/tests/eo/suite/eo_test_class_errors.c index cbea8e1b2d..36a85151cc 100644 --- a/src/tests/eo/suite/eo_test_class_errors.c +++ b/src/tests/eo/suite/eo_test_class_errors.c @@ -21,10 +21,10 @@ START_TEST(eo_inherit_errors) const Eo_Class *klass_simple; static const Eo_Class_Description class_desc_simple = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -32,10 +32,10 @@ START_TEST(eo_inherit_errors) }; static const Eo_Class_Description class_desc_mixin = { - EO2_VERSION, + EO_VERSION, "Mixin", EO_CLASS_TYPE_MIXIN, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -43,10 +43,10 @@ START_TEST(eo_inherit_errors) }; static Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "General", EO_CLASS_TYPE_MIXIN, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -56,7 +56,7 @@ START_TEST(eo_inherit_errors) klass_mixin = eo_class_new(&class_desc_mixin, NULL, NULL); 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); 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; static const Eo_Class_Description class_desc_simple = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -100,10 +100,10 @@ START_TEST(eo_inconsistent_mro) }; static const Eo_Class_Description class_desc_mixin = { - EO2_VERSION, + EO_VERSION, "Mixin", EO_CLASS_TYPE_MIXIN, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -111,10 +111,10 @@ START_TEST(eo_inconsistent_mro) }; static const Eo_Class_Description class_desc_mixin2 = { - EO2_VERSION, + EO_VERSION, "Mixin2", EO_CLASS_TYPE_MIXIN, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -122,10 +122,10 @@ START_TEST(eo_inconsistent_mro) }; static const Eo_Class_Description class_desc_mixin3 = { - EO2_VERSION, + EO_VERSION, "Mixin3", EO_CLASS_TYPE_MIXIN, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -142,14 +142,14 @@ START_TEST(eo_inconsistent_mro) fail_if(!klass_mixin3); 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_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); - 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); eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); @@ -168,10 +168,10 @@ START_TEST(eo_bad_interface) const Eo_Class *klass; static Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Interface", EO_CLASS_TYPE_INTERFACE, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 10, NULL, @@ -216,22 +216,22 @@ START_TEST(eo_null_api) const Eo_Class *klass; - static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC(NULL, _null_fct, "NULL API function"), - EO2_OP_SENTINEL + static Eo_Op_Description op_descs[] = { + EO_OP_FUNC(NULL, _null_fct, "NULL API function"), + EO_OP_SENTINEL }; static Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, 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); fail_if(klass); fail_unless(ctx.did); @@ -249,22 +249,22 @@ START_TEST(eo_wrong_override) const Eo_Class *klass; - static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC_OVERRIDE(null_fct, _null_fct), - EO2_OP_SENTINEL + static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(null_fct, _null_fct), + EO_OP_SENTINEL }; static Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, 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); fail_if(klass); fail_unless(ctx.did); @@ -282,23 +282,23 @@ START_TEST(eo_api_redefined) const Eo_Class *klass; - static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC(null_fct, _null_fct, "API function"), - EO2_OP_FUNC(null_fct, NULL, "Redefining API function"), - EO2_OP_SENTINEL + static Eo_Op_Description op_descs[] = { + EO_OP_FUNC(null_fct, _null_fct, "API function"), + EO_OP_FUNC(null_fct, NULL, "Redefining API function"), + EO_OP_SENTINEL }; static Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, 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); fail_if(klass); fail_unless(ctx.did); @@ -316,16 +316,16 @@ START_TEST(eo_dich_func_override) const Eo_Class *klass; - static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC_OVERRIDE(simple_a_set, _null_fct), - EO2_OP_FUNC_OVERRIDE(simple_a_set, NULL), - EO2_OP_SENTINEL + static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(simple_a_set, _null_fct), + EO_OP_FUNC_OVERRIDE(simple_a_set, NULL), + EO_OP_SENTINEL }; static Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, NULL, diff --git a/src/tests/eo/suite/eo_test_class_simple.c b/src/tests/eo/suite/eo_test_class_simple.c index 89cd14e073..5b8c2e06ac 100644 --- a/src/tests/eo/suite/eo_test_class_simple.c +++ b/src/tests/eo/suite/eo_test_class_simple.c @@ -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); 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 @@ -45,7 +45,7 @@ _class_hi_print(Eo_Class *klass, void *data EINA_UNUSED) 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 _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) { count++; - eo2_do(obj, simple_recursive(n)); + eo_do(obj, simple_recursive(n)); } else count = 0; @@ -64,39 +64,39 @@ _recursive(Eo *obj, void *class_data EINA_UNUSED, int n) static void _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_APPEND(group, "Test", EINA_VALUE_TYPE_INT, 8); } -EO2_VOID_FUNC_BODYV(simple_a_set, EO2_FUNC_CALL(a), int a); -EO2_FUNC_BODY(simple_a_get, int, 0); -EO2_FUNC_BODY(simple_a_print, Eina_Bool, EINA_FALSE); -EO2_FUNC_BODY(simple_class_hi_print, Eina_Bool, EINA_FALSE); -EO2_VOID_FUNC_BODY(simple_pure_virtual); -EO2_VOID_FUNC_BODY(simple_no_implementation); - -static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC_OVERRIDE(eo2_dbg_info_get, _dbg_info_get), - EO2_OP_FUNC(simple_a_set, _a_set, "Set property a"), - EO2_OP_FUNC(simple_a_get, _a_get, "Get property a"), - EO2_OP_FUNC(simple_a_print, _a_print, "Print property a"), - EO2_OP_CLASS_FUNC(simple_class_hi_print, _class_hi_print, "Print property a"), - EO2_OP_FUNC(simple_recursive, _recursive, "Recursive function"), - EO2_OP_FUNC(simple_pure_virtual, NULL, "Pure Virtual function"), - EO2_OP_SENTINEL +EO_VOID_FUNC_BODYV(simple_a_set, EO_FUNC_CALL(a), int a); +EO_FUNC_BODY(simple_a_get, int, 0); +EO_FUNC_BODY(simple_a_print, Eina_Bool, EINA_FALSE); +EO_FUNC_BODY(simple_class_hi_print, Eina_Bool, EINA_FALSE); +EO_VOID_FUNC_BODY(simple_pure_virtual); +EO_VOID_FUNC_BODY(simple_no_implementation); + +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(eo_dbg_info_get, _dbg_info_get), + EO_OP_FUNC(simple_a_set, _a_set, "Set property a"), + EO_OP_FUNC(simple_a_get, _a_get, "Get property a"), + EO_OP_FUNC(simple_a_print, _a_print, "Print property a"), + EO_OP_CLASS_FUNC(simple_class_hi_print, _class_hi_print, "Print property a"), + EO_OP_FUNC(simple_recursive, _recursive, "Recursive function"), + EO_OP_FUNC(simple_pure_virtual, NULL, "Pure Virtual function"), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Simple_Public_Data), 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) diff --git a/src/tests/eo/suite/eo_test_general.c b/src/tests/eo/suite/eo_test_general.c index e0a95c6cc8..a5e9f3340c 100644 --- a/src/tests/eo/suite/eo_test_general.c +++ b/src/tests/eo/suite/eo_test_general.c @@ -11,13 +11,13 @@ START_TEST(eo_simple) { eo_init(); - Eo *obj = eo2_add(EO2_BASE_CLASS, NULL); + Eo *obj = eo_add(EO_BASE_CLASS, NULL); fail_if(obj); - obj = eo2_add(SIMPLE_CLASS, NULL); + obj = eo_add(SIMPLE_CLASS, NULL); fail_if(!obj); - eo2_do(obj, eo2_constructor()); - eo2_do(obj, eo2_destructor()); + eo_do(obj, eo_constructor()); + eo_do(obj, eo_destructor()); eo_unref(obj); eo_shutdown(); @@ -27,10 +27,10 @@ END_TEST START_TEST(eo_stack) { eo_init(); - Eo *obj = eo2_add(SIMPLE_CLASS, NULL); + Eo *obj = eo_add(SIMPLE_CLASS, NULL); fail_if(!obj); - eo2_do(obj, simple_recursive(123)); + eo_do(obj, simple_recursive(123)); eo_unref(obj); @@ -94,23 +94,23 @@ START_TEST(eo_signals) { EO_EV_DEL, _eo_signals_eo_del_cb }, { NULL, NULL } }; - Eo *obj = eo2_add(SIMPLE_CLASS, NULL); - - eo2_do(obj, eo2_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)); - eo2_do(obj, eo2_event_callback_array_priority_add(callbacks, -100, (void *) 1)); - eo2_do(obj, eo2_event_callback_array_add(callbacks, (void *) 3)); - eo2_do(obj, eo2_event_callback_array_priority_add(callbacks, -50, (void *) 2)); - eo2_do(obj, simple_a_set(1)); + Eo *obj = eo_add(SIMPLE_CLASS, NULL); + + eo_do(obj, eo_event_callback_add(EO_EV_CALLBACK_ADD, _eo_signals_cb_added_deled, callbacks)); + eo_do(obj, eo_event_callback_add(EO_EV_CALLBACK_DEL, _eo_signals_cb_added_deled, callbacks)); + eo_do(obj, eo_event_callback_array_priority_add(callbacks, -100, (void *) 1)); + eo_do(obj, eo_event_callback_array_add(callbacks, (void *) 3)); + eo_do(obj, eo_event_callback_array_priority_add(callbacks, -50, (void *) 2)); + eo_do(obj, simple_a_set(1)); ck_assert_int_eq(_eo_signals_cb_flag, 0x3); - eo2_do(obj, eo2_event_callback_array_del(callbacks, (void *) 1)); - eo2_do(obj, eo2_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 *) 1)); + eo_do(obj, eo_event_callback_array_del(callbacks, (void *) 2)); + eo_do(obj, eo_event_callback_array_del(callbacks, (void *) 3)); /* 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; - eo2_do(obj, simple_a_set(1)); + eo_do(obj, simple_a_set(1)); ck_assert_int_eq(_eo_signals_cb_flag, 0x0); eo_unref(obj); @@ -125,20 +125,20 @@ START_TEST(eo_data_fetch) /* Usually should be const, not const only for the test... */ static Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple2", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 10, 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); - Eo *obj = eo2_add(klass, NULL); + Eo *obj = eo_add(klass, NULL); fail_if(!obj); #ifdef EO_DEBUG fail_if(eo_data_scope_get(obj, SIMPLE_CLASS)); @@ -146,10 +146,10 @@ START_TEST(eo_data_fetch) eo_unref(obj); 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); - obj = eo2_add(klass, NULL); + obj = eo_add(klass, NULL); fail_if(!obj); fail_if(eo_data_scope_get(obj, klass)); eo_unref(obj); @@ -167,10 +167,10 @@ START_TEST(eo_isa_tests) { /* Usually should be const, not const only for the test... */ static Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Iface", EO_CLASS_TYPE_INTERFACE, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -184,10 +184,10 @@ START_TEST(eo_isa_tests) { /* Usually should be const, not const only for the test... */ static Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Mixin", EO_CLASS_TYPE_MIXIN, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -201,36 +201,36 @@ START_TEST(eo_isa_tests) { /* Usually should be const, not const only for the test... */ static Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple2", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 10, 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); } - Eo *obj = eo2_add(klass, NULL); + Eo *obj = eo_add(klass, NULL); fail_if(!obj); fail_if(eo_isa(obj, SIMPLE_CLASS)); fail_if(!eo_isa(obj, iface)); fail_if(!eo_isa(obj, mixin)); 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); - obj = eo2_add(SIMPLE_CLASS, NULL); + obj = eo_add(SIMPLE_CLASS, NULL); fail_if(!obj); fail_if(eo_isa(obj, klass)); fail_if(eo_isa(obj, iface)); fail_if(eo_isa(obj, mixin)); 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_shutdown(); @@ -242,13 +242,13 @@ START_TEST(eo_composite_tests) { eo_init(); - Eo *obj = eo2_add(SIMPLE_CLASS, NULL); + Eo *obj = eo_add(SIMPLE_CLASS, NULL); fail_if(!obj); - Eo *obj2 = eo2_add(SIMPLE_CLASS, NULL); + Eo *obj2 = eo_add(SIMPLE_CLASS, NULL); fail_if(!obj2); 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)); eo_unref(obj2); @@ -267,21 +267,21 @@ _man_con(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED) { if (_man_should_con) 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 _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) eo_manual_free_set(obj, EINA_FALSE); } -static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC_OVERRIDE(eo2_constructor, _man_con), - EO2_OP_FUNC_OVERRIDE(eo2_destructor, _man_des), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(eo_constructor, _man_con), + EO_OP_FUNC_OVERRIDE(eo_destructor, _man_des), + EO_OP_SENTINEL }; START_TEST(eo_man_free) @@ -290,35 +290,35 @@ START_TEST(eo_man_free) /* Usually should be const, not const only for the test... */ static Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple2", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 10, 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); cur_klass = klass; - Eo *obj = eo2_add(klass, NULL); + Eo *obj = eo_add(klass, NULL); fail_if(!obj); eo_unref(obj); - obj = eo2_add(klass, NULL); + obj = eo_add(klass, NULL); fail_if(!obj); fail_if(eo_manual_free(obj)); eo_unref(obj); _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; fail_if(!klass); - obj = eo2_add(klass, NULL); + obj = eo_add(klass, NULL); fail_if(!obj); fail_if(eo_manual_free(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_manual_free(obj)); - obj = eo2_add(klass, NULL); + obj = eo_add(klass, NULL); fail_if(!obj); eo_unref(obj); fail_if(!eo_destructed_is(obj)); fail_if(!eo_manual_free(obj)); _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; fail_if(!klass); - obj = eo2_add(klass, NULL); + obj = eo_add(klass, NULL); fail_if(!obj); fail_if(eo_manual_free(obj)); eo_unref(obj); - obj = eo2_add(klass, NULL); + obj = eo_add(klass, NULL); fail_if(!obj); eo_manual_free_set(obj, EINA_TRUE); eo_unref(obj); @@ -351,7 +351,7 @@ START_TEST(eo_man_free) eo_unref(obj); fail_if(!eo_manual_free(obj)); - obj = eo2_add(klass, NULL); + obj = eo_add(klass, NULL); fail_if(!obj); eo_manual_free_set(obj, EINA_TRUE); eo_unref(obj); @@ -369,9 +369,9 @@ END_TEST START_TEST(eo_refs) { eo_init(); - Eo *obj = eo2_add(SIMPLE_CLASS, NULL); - Eo *obj2 = eo2_add(SIMPLE_CLASS, NULL); - Eo *obj3 = eo2_add(SIMPLE_CLASS, NULL); + Eo *obj = eo_add(SIMPLE_CLASS, NULL); + Eo *obj2 = eo_add(SIMPLE_CLASS, NULL); + Eo *obj3 = eo_add(SIMPLE_CLASS, NULL); eo_xref(obj, obj2); fail_if(eo_ref_get(obj) != 2); @@ -406,11 +406,11 @@ START_TEST(eo_refs) eo_unref(obj3); /* Check hierarchy */ - obj = eo2_add(SIMPLE_CLASS, NULL); - obj2 = eo2_add(SIMPLE_CLASS, obj); + obj = eo_add(SIMPLE_CLASS, NULL); + obj2 = eo_add(SIMPLE_CLASS, obj); Eo *wref = NULL; - eo2_do(obj2, eo2_wref_add(&wref)); + eo_do(obj2, eo_wref_add(&wref)); fail_if(!wref); eo_unref(obj2); @@ -422,13 +422,13 @@ START_TEST(eo_refs) fail_if(wref); /* Just check it doesn't seg atm. */ - obj = eo2_add(SIMPLE_CLASS, NULL); + obj = eo_add(SIMPLE_CLASS, NULL); eo_ref(obj); eo_unref(obj); eo_unref(obj); - obj = eo2_add(SIMPLE_CLASS, NULL); - obj2 = eo2_add(SIMPLE_CLASS, obj); + obj = eo_add(SIMPLE_CLASS, NULL); + obj2 = eo_add(SIMPLE_CLASS, obj); eo_unref(obj2); eo_ref(obj2); eo_del(obj2); @@ -442,17 +442,17 @@ START_TEST(eo_weak_reference) { eo_init(); - Eo *obj = eo2_add(SIMPLE_CLASS, NULL); - Eo *obj2 = eo2_add(SIMPLE_CLASS, NULL); + Eo *obj = eo_add(SIMPLE_CLASS, NULL); + Eo *obj2 = eo_add(SIMPLE_CLASS, 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); eo_unref(obj); fail_if(wref); - obj = eo2_add(SIMPLE_CLASS, NULL); - eo2_do(obj, eo2_wref_add(&wref)); + obj = eo_add(SIMPLE_CLASS, NULL); + eo_do(obj, eo_wref_add(&wref)); eo_ref(obj); fail_if(!wref); @@ -463,37 +463,37 @@ START_TEST(eo_weak_reference) eo_unref(obj); fail_if(wref); - obj = eo2_add(SIMPLE_CLASS, NULL); + obj = eo_add(SIMPLE_CLASS, NULL); - eo2_do(obj, eo2_wref_add(&wref)); - eo2_do(obj, eo2_wref_del(&wref)); + eo_do(obj, eo_wref_add(&wref)); + eo_do(obj, eo_wref_del(&wref)); fail_if(wref); - eo2_do(obj, eo2_wref_add(&wref)); - eo2_do(obj2, eo2_wref_del(&wref)); + eo_do(obj, eo_wref_add(&wref)); + eo_do(obj2, eo_wref_del(&wref)); fail_if(!wref); - eo2_wref_del_safe(&wref); + eo_wref_del_safe(&wref); fail_if(wref); wref = obj; - eo2_do(obj, eo2_wref_del(&wref)); + eo_do(obj, eo_wref_del(&wref)); fail_if(wref); 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(!wref2); 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(wref2); 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; - eo2_do(obj, eo2_wref_del(&wref)); + eo_do(obj, eo_wref_del(&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(obj2); @@ -516,59 +516,59 @@ _fake_free_func(void *data) START_TEST(eo_generic_data) { eo_init(); - Eo *obj = eo2_add(SIMPLE_CLASS, NULL); + Eo *obj = eo_add(SIMPLE_CLASS, NULL); void *data = NULL; - eo2_do(obj, eo2_base_data_set("test1", (void *) 1, NULL)); - eo2_do(obj, data = eo2_base_data_get("test1")); + eo_do(obj, eo_base_data_set("test1", (void *) 1, NULL)); + eo_do(obj, data = eo_base_data_get("test1")); fail_if(1 != (intptr_t) data); - eo2_do(obj, eo2_base_data_del("test1")); - eo2_do(obj, data = eo2_base_data_get("test1")); + eo_do(obj, eo_base_data_del("test1")); + eo_do(obj, data = eo_base_data_get("test1")); fail_if(data); - eo2_do(obj, eo2_base_data_set("test1", (void *) 1, NULL)); - eo2_do(obj, eo2_base_data_set("test2", (void *) 2, NULL)); - eo2_do(obj, data = eo2_base_data_get("test1")); + eo_do(obj, eo_base_data_set("test1", (void *) 1, NULL)); + eo_do(obj, eo_base_data_set("test2", (void *) 2, NULL)); + eo_do(obj, data = eo_base_data_get("test1")); 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); - eo2_do(obj, data = eo2_base_data_get("test2")); + eo_do(obj, data = eo_base_data_get("test2")); fail_if(2 != (intptr_t) data); - eo2_do(obj, eo2_base_data_del("test2")); - eo2_do(obj, data = eo2_base_data_get("test2")); + eo_do(obj, eo_base_data_del("test2")); + eo_do(obj, data = eo_base_data_get("test2")); 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); - eo2_do(obj, eo2_base_data_del("test1")); - eo2_do(obj, data = eo2_base_data_get("test1")); + eo_do(obj, eo_base_data_del("test1")); + eo_do(obj, data = eo_base_data_get("test1")); fail_if(data); int a = 0; - eo2_do(obj, eo2_base_data_set("test3", &a, _fake_free_func)); - eo2_do(obj, data = eo2_base_data_get("test3")); + eo_do(obj, eo_base_data_set("test3", &a, _fake_free_func)); + eo_do(obj, data = eo_base_data_get("test3")); fail_if(&a != data); - eo2_do(obj, eo2_base_data_get("test3")); - eo2_do(obj, eo2_base_data_del("test3")); + eo_do(obj, eo_base_data_get("test3")); + eo_do(obj, eo_base_data_del("test3")); fail_if(a != 1); a = 0; - eo2_do(obj, eo2_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", &a, _fake_free_func)); + eo_do(obj, eo_base_data_set("test3", NULL, _fake_free_func)); fail_if(a != 1); a = 0; data = (void *) 123; - eo2_do(obj, eo2_base_data_set(NULL, &a, _fake_free_func)); - eo2_do(obj, data = eo2_base_data_get(NULL)); + eo_do(obj, eo_base_data_set(NULL, &a, _fake_free_func)); + eo_do(obj, data = eo_base_data_get(NULL)); fail_if(data); - eo2_do(obj, eo2_base_data_del(NULL)); + eo_do(obj, eo_base_data_del(NULL)); a = 0; - eo2_do(obj, eo2_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", &a, _fake_free_func)); + eo_do(obj, eo_base_data_set("test3", NULL, NULL)); 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); fail_if(a != 2); @@ -586,7 +586,7 @@ START_TEST(eo_magic_checks) memset(_buf, 1, sizeof(_buf)); - Eo *obj = eo2_add(SIMPLE_CLASS, (Eo *) buf); + Eo *obj = eo_add(SIMPLE_CLASS, (Eo *) buf); fail_if(obj); while (1) @@ -596,28 +596,28 @@ START_TEST(eo_magic_checks) Eo *wref = NULL; Eo *obj2 = NULL; - obj = eo2_add((Eo_Class *) buf, NULL); + obj = eo_add((Eo_Class *) buf, NULL); fail_if(obj); - obj = eo2_add(SIMPLE_CLASS, NULL); + obj = eo_add(SIMPLE_CLASS, NULL); 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); - eo2_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, simple_a_set(++i)); + eo_do_super((Eo *) buf, SIMPLE_CLASS, a = simple_a_get()); ck_assert_int_ne(i, a); - eo2_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, simple_a_set(++i)); + eo_do_super(obj, (const Eo_Class *) buf, a = simple_a_get()); ck_assert_int_ne(i, a); fail_if(eo_class_get((Eo *) buf)); fail_if(eo_class_name_get((Eo_Class*) buf)); 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); - eo2_do((Eo_Class *) buf,(void) NULL); - eo2_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((Eo_Class *) buf,(void) NULL); + eo_do_super((Eo_Class *) buf, SIMPLE_CLASS, 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); eo_xref(obj, (Eo *) buf); @@ -634,9 +634,9 @@ START_TEST(eo_magic_checks) fail_if(0 != eo_ref_get((Eo *) buf)); - eo2_do((Eo *) buf, - eo2_wref_add(&wref), - parent = eo2_parent_get()); + eo_do((Eo *) buf, + eo_wref_add(&wref), + parent = eo_parent_get()); fail_if(wref); fail_if(parent); @@ -650,8 +650,8 @@ START_TEST(eo_magic_checks) eo_composite_detach(obj, (Eo *) buf); eo_composite_is((Eo *) buf); - eo2_do(obj, eo2_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_add(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((Eo *) buf); @@ -692,13 +692,13 @@ _class_hi_print(Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED) return EINA_TRUE; } -EO2_FUNC_BODY(multi_a_print, Eina_Bool, EINA_FALSE); -EO2_FUNC_BODY(multi_class_hi_print, Eina_Bool, EINA_FALSE); +EO_FUNC_BODY(multi_a_print, Eina_Bool, EINA_FALSE); +EO_FUNC_BODY(multi_class_hi_print, Eina_Bool, EINA_FALSE); -static Eo2_Op_Description _multi_do_op_descs[] = { - EO2_OP_FUNC(multi_a_print, _a_print, "Print property a"), - EO2_OP_FUNC(multi_class_hi_print, _class_hi_print, "Print Hi"), - EO2_OP_SENTINEL +static Eo_Op_Description _multi_do_op_descs[] = { + EO_OP_FUNC(multi_a_print, _a_print, "Print property a"), + EO_OP_FUNC(multi_class_hi_print, _class_hi_print, "Print Hi"), + EO_OP_SENTINEL }; START_TEST(eo_multiple_do) @@ -707,10 +707,10 @@ START_TEST(eo_multiple_do) /* Usually should be const, not const only for the test... */ static Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Inherit", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(_multi_do_op_descs), + EO_CLASS_DESCRIPTION_OPS(_multi_do_op_descs), NULL, 0, NULL, @@ -720,17 +720,17 @@ START_TEST(eo_multiple_do) const Eo_Class *klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL); fail_if(!klass); - Eo *obj = eo2_add(klass, NULL); + Eo *obj = eo_add(klass, NULL); fail_if(!obj); Eina_Bool ca, cb, cc; 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)); 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)); eo_unref(obj); @@ -739,23 +739,23 @@ START_TEST(eo_multiple_do) } END_TEST -START_TEST(eo2_add_do_and_custom) +START_TEST(eo_add_do_and_custom) { Simple_Public_Data *pd = NULL; Eo *obj = NULL; eo_init(); - obj = eo2_add_custom(SIMPLE_CLASS, NULL, eo2_constructor()); + obj = eo_add_custom(SIMPLE_CLASS, NULL, eo_constructor()); fail_if(!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); pd = eo_data_scope_get(obj, SIMPLE_CLASS); fail_if(pd->a != 7); 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); pd = eo_data_scope_get(obj, SIMPLE_CLASS); fail_if(pd->a != 7); @@ -771,21 +771,21 @@ START_TEST(eo_pointers_indirection) eo_init(); static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_NOOPS(), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, 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); /* Check simple id validity */ - Eo *obj = eo2_add(klass, NULL); + Eo *obj = eo_add(klass, NULL); fail_if(!obj); fail_if(!eo_isa(obj, klass)); obj = (Eo *)((char *)(obj) + 1); @@ -796,10 +796,10 @@ START_TEST(eo_pointers_indirection) fail_if(eo_isa(obj, klass)); /* Check id invalidity after deletion */ - Eo *obj1 = eo2_add(klass, NULL); + Eo *obj1 = eo_add(klass, NULL); fail_if(!obj1); eo_unref(obj1); - Eo *obj2 = eo2_add(klass, NULL); + Eo *obj2 = eo_add(klass, NULL); fail_if(!obj2); fail_if(!eo_isa(obj2, klass)); fail_if(eo_isa(obj1, klass)); @@ -812,7 +812,7 @@ START_TEST(eo_pointers_indirection) /* Creation of the objects */ 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]) fail_if(!objs[obj_id]); if(!eo_isa(objs[obj_id], klass)) @@ -828,7 +828,7 @@ START_TEST(eo_pointers_indirection) /* Creation of the deleted objects */ 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]) fail_if(!objs[obj_id]); 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_magic_checks); 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); } diff --git a/src/tests/eo/suite/eo_test_threaded_calls.c b/src/tests/eo/suite/eo_test_threaded_calls.c index a954463e46..951b6551b4 100644 --- a/src/tests/eo/suite/eo_test_threaded_calls.c +++ b/src/tests/eo/suite/eo_test_threaded_calls.c @@ -18,9 +18,9 @@ typedef struct #define THREAD_TEST_CLASS thread_test_class_get() const Eo_Class *thread_test_class_get(void); -EO2_FUNC_BODY(thread_test_v_get, int, 0); -EO2_VOID_FUNC_BODY(thread_test_try_swap_stack); -EO2_VOID_FUNC_BODYV(thread_test_constructor, EO2_FUNC_CALL(v), int v); +EO_FUNC_BODY(thread_test_v_get, int, 0); +EO_VOID_FUNC_BODY(thread_test_try_swap_stack); +EO_VOID_FUNC_BODYV(thread_test_constructor, EO_FUNC_CALL(v), int v); static int _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; - eo2_do_super(obj, THREAD_TEST_CLASS, eo2_constructor()); + eo_do_super(obj, THREAD_TEST_CLASS, eo_constructor()); pd->v = v; } -static Eo2_Op_Description op_descs[] = { - EO2_OP_FUNC(thread_test_constructor, _constructor, "Constructor."), - EO2_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."), - EO2_OP_SENTINEL +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC(thread_test_constructor, _constructor, "Constructor."), + EO_OP_FUNC(thread_test_v_get, _v_get, "Get property v."), + EO_OP_FUNC(thread_test_try_swap_stack, _try_swap_stack, "Swap call stack frames if it is not thread safe."), + EO_OP_SENTINEL }; static const Eo_Class_Description class_desc = { - EO2_VERSION, + EO_VERSION, "Thread Test", EO_CLASS_TYPE_REGULAR, - EO2_CLASS_DESCRIPTION_OPS(op_descs), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Thread_Test_Public_Data), 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 * _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) 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]); diff --git a/src/tests/eo/suite/eo_test_value.c b/src/tests/eo/suite/eo_test_value.c index 5715457657..afdec776ce 100644 --- a/src/tests/eo/suite/eo_test_value.c +++ b/src/tests/eo/suite/eo_test_value.c @@ -16,10 +16,10 @@ START_TEST(eo_value) Eina_Value val2, eo_val; void *tmpp = NULL; 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"); - 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); ck_assert_str_eq(eo_dbg_info->name, "Root"); str = eina_value_to_string(&eo_dbg_info->value); |