diff --git a/TODO-eo2 b/TODO-eo2 new file mode 100644 index 0000000000..8c62c83d4e --- /dev/null +++ b/TODO-eo2 @@ -0,0 +1,32 @@ + +- eo_composite_attach + maybe check that the class of comp_obj is part of parent extensions + +- Eo2_Call_Stack + grow/shrink + stack push and pop functions + per thread stack + +- Remove the memset in do_end? Waste of cpu... + +- cleanup EO2_VERSION specific code in eo.c and eo_private.c + +- Move the Op_Descs to be set using a function inside the class_constructor + check if it works ASIS on windows + if it does, do nothing + +- Rediscuss the whole attribute cleanup thing. I'm not sure we want that as everything breaks if that isn't there. Embedded old gcc? + +- function name from pointer + dladdr backtrace ?? + +- Get rid of some of the EO2_VOID_FUNC_BODY? + +- Add line number to errors (like in eo1...) + +- A bit annoying that we don't get type checks on the callbacks, fix that? That's really dangerous! + +- Get all the optimisations cedric has been doing to Eo1? I think that's where the children thing got lost... + - Make sure all the improvements have been migrated... + +- Fix all the FIXME diff --git a/src/Makefile_Eo.am b/src/Makefile_Eo.am index 230ff9e794..7c2b093b38 100644 --- a/src/Makefile_Eo.am +++ b/src/Makefile_Eo.am @@ -10,8 +10,8 @@ lib_eo_libeo_la_SOURCES = \ lib/eo/eo.c \ lib/eo/eo_ptr_indirection.c \ lib/eo/eo_ptr_indirection.h \ -lib/eo/eo_class_class.c \ lib/eo/eo_base_class.c \ +lib/eo/eo_class_class.c \ lib/eo/eo_private.h lib_eo_libeo_la_CPPFLAGS = -I$(top_builddir)/src/lib/efl @EO_CFLAGS@ @@ -91,9 +91,13 @@ tests/eo/suite/eo_test_class_simple.c \ tests/eo/suite/eo_test_class_simple.h \ tests/eo/suite/eo_suite.c \ tests/eo/suite/eo_suite.h \ +tests/eo/suite/eo_error_msgs.h \ +tests/eo/suite/eo_error_msgs.c \ tests/eo/suite/eo_test_class_errors.c \ +tests/eo/suite/eo_test_call_errors.c \ tests/eo/suite/eo_test_general.c \ tests/eo/suite/eo_test_value.c \ +tests/eo/suite/eo_test_threaded_calls.c \ tests/eo/suite/eo_test_init.c tests_eo_eo_suite_CPPFLAGS = -I$(top_builddir)/src/lib/efl \ -DTESTS_BUILD_DIR=\"$(top_builddir)/src/tests/eo\" \ diff --git a/src/benchmarks/eo/class_simple.c b/src/benchmarks/eo/class_simple.c index 2e8dc3f621..05d025ec97 100644 --- a/src/benchmarks/eo/class_simple.c +++ b/src/benchmarks/eo/class_simple.c @@ -46,5 +46,5 @@ static const Eo_Class_Description class_desc = { NULL }; -EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, NULL) +EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_CLASS, NULL) diff --git a/src/bin/eolian/common_funcs.h b/src/bin/eolian/common_funcs.h index c8a800eefb..ace92e6fca 100644 --- a/src/bin/eolian/common_funcs.h +++ b/src/bin/eolian/common_funcs.h @@ -3,7 +3,7 @@ #include -//#define EO +#define EO extern int _eolian_gen_log_dom; diff --git a/src/bin/eolian/eo1_generator.c b/src/bin/eolian/eo1_generator.c index 669125b1cf..ce4ffd6f37 100644 --- a/src/bin/eolian/eo1_generator.c +++ b/src/bin/eolian/eo1_generator.c @@ -167,7 +167,6 @@ eo1_fundef_generate(const char *classname, Eolian_Function func, Eolian_Function char *fsuffix = ""; rettype = eolian_function_return_type_get(func, ftype); - if (rettype && !strcmp(rettype, "void")) rettype = NULL; if (ftype == EOLIAN_PROP_GET) { fsuffix = "_get"; @@ -468,7 +467,6 @@ eo1_bind_func_generate(const char *classname, Eolian_Function funcid, Eolian_Fun Eina_Strbuf *full_params = eina_strbuf_new(); /* variables types + names */ rettype = eolian_function_return_type_get(funcid, ftype); - if (rettype && !strcmp(rettype, "void")) rettype = NULL; retname = "ret"; if (ftype == EOLIAN_PROP_GET) { diff --git a/src/examples/ecore/ecore_audio_playback.c b/src/examples/ecore/ecore_audio_playback.c index 6c93fd565a..56bfa070f9 100644 --- a/src/examples/ecore/ecore_audio_playback.c +++ b/src/examples/ecore/ecore_audio_playback.c @@ -266,7 +266,7 @@ main(int argc, const char *argv[]) { if (!strncmp(val, "freq=", 5)) { freq = atoi(&val[5]); - eo_do(in, eo_base_data_set(ECORE_AUDIO_ATTR_TONE_FREQ, &freq, NULL)); + eo_do(in, eo_key_data_set(ECORE_AUDIO_ATTR_TONE_FREQ, &freq, NULL)); } else if (!strncmp(val, "duration=", 9)) { eo_do(in, ecore_audio_obj_in_length_set(atof(&val[9]))); } diff --git a/src/examples/eo/evas/evas_evas_obj.c b/src/examples/eo/evas/evas_evas_obj.c index 01f48a544b..768d3d4ea6 100644 --- a/src/examples/eo/evas/evas_evas_obj.c +++ b/src/examples/eo/evas/evas_evas_obj.c @@ -143,4 +143,4 @@ static const Eo_Class_Description class_desc = { NULL }; -EO_DEFINE_CLASS(evas_object_class_get, &class_desc, EO_BASE_CLASS, NULL) +EO_DEFINE_CLASS(evas_object_class_get, &class_desc, EO_CLASS, NULL) diff --git a/src/examples/eo/evas/evas_evas_obj.h b/src/examples/eo/evas/evas_evas_obj.h index 7aa761c648..cda796023d 100644 --- a/src/examples/eo/evas/evas_evas_obj.h +++ b/src/examples/eo/evas/evas_evas_obj.h @@ -76,7 +76,7 @@ static inline Evas_Object * eo_evas_object_get(const Eo *obj) { void *data; - eo_do((Eo *) obj, eo_base_data_get(EXEVAS_OBJ_STR, &data)); + eo_do((Eo *) obj, eo_key_data_get(EXEVAS_OBJ_STR, &data)); return data; } @@ -84,7 +84,7 @@ eo_evas_object_get(const Eo *obj) static inline void eo_evas_object_set(Eo *obj, Evas_Object *evas_obj) { - eo_do(obj, eo_base_data_set(EXEVAS_OBJ_STR, evas_obj, NULL)); + eo_do(obj, eo_key_data_set(EXEVAS_OBJ_STR, evas_obj, NULL)); } #endif diff --git a/src/examples/eo/isa/eo_isa_simple.c b/src/examples/eo/isa/eo_isa_simple.c index 789c5f4711..67f47fd5f9 100644 --- a/src/examples/eo/isa/eo_isa_simple.c +++ b/src/examples/eo/isa/eo_isa_simple.c @@ -75,4 +75,4 @@ static const Eo_Class_Description class_desc = { NULL }; -EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, INTERFACE_CLASS, MIXIN_CLASS, NULL); +EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_CLASS, INTERFACE_CLASS, MIXIN_CLASS, NULL); diff --git a/src/examples/eo/simple/simple_simple.c b/src/examples/eo/simple/simple_simple.c index a172bce3fc..42eb1f75b2 100644 --- a/src/examples/eo/simple/simple_simple.c +++ b/src/examples/eo/simple/simple_simple.c @@ -75,4 +75,4 @@ static const Eo_Class_Description class_desc = { NULL }; -EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, INTERFACE_CLASS, MIXIN_CLASS, NULL); +EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_CLASS, INTERFACE_CLASS, MIXIN_CLASS, NULL); diff --git a/src/lib/ecore/ecore_timer.c b/src/lib/ecore/ecore_timer.c index cbd87eae1a..2de040edd0 100644 --- a/src/lib/ecore/ecore_timer.c +++ b/src/lib/ecore/ecore_timer.c @@ -431,7 +431,7 @@ ecore_timer_freeze_get(Ecore_Timer *timer) { int r = 0; - eo_do(timer, eo_event_freeze_get(&r)); + eo_do(timer, r = eo_event_freeze_get()); return !!r; } diff --git a/src/lib/ecore_audio/ecore_audio.eo b/src/lib/ecore_audio/ecore_audio.eo index b5dcf99b33..ace7e801b6 100644 --- a/src/lib/ecore_audio/ecore_audio.eo +++ b/src/lib/ecore_audio/ecore_audio.eo @@ -110,7 +110,7 @@ class Ecore_Audio (Eo_Base) params { Ecore_Audio_Vio *vio; /*The @ref Ecore_Audio_Vio struct with the function callbacks*/ void *data; /*User data to pass to the VIO functions*/ - eo_base_data_free_func free_func; /*This function takes care to clean up @ref data when he VIO is destroyed. NULL means do nothing.*/ + eo_key_data_free_func free_func; /*This function takes care to clean up @ref data when he VIO is destroyed. NULL means do nothing.*/ } } } diff --git a/src/lib/ecore_audio/ecore_audio_in_tone.eo b/src/lib/ecore_audio/ecore_audio_in_tone.eo index 6b3e489368..d0970519b8 100644 --- a/src/lib/ecore_audio/ecore_audio_in_tone.eo +++ b/src/lib/ecore_audio/ecore_audio_in_tone.eo @@ -3,10 +3,10 @@ class Ecore_Audio_In_Tone (Ecore_Audio_In) eo_prefix: ecore_audio_obj_in_tone; implements { Eo_Base::constructor; - Eo_Base::data_set; - Eo_Base::data_get; + Eo_Base::key_data_set; + Eo_Base::key_data_get; Ecore_Audio_In::length::set; Ecore_Audio_In::seek; Ecore_Audio_In::read_internal; } -} \ No newline at end of file +} diff --git a/src/lib/ecore_audio/ecore_audio_obj.h b/src/lib/ecore_audio/ecore_audio_obj.h index b473a55f11..153a638292 100644 --- a/src/lib/ecore_audio/ecore_audio_obj.h +++ b/src/lib/ecore_audio/ecore_audio_obj.h @@ -175,7 +175,7 @@ enum Ecore_Audio_Obj_Sub_Ids * @param[in] free_func This function takes care to clean up @ref data when * the VIO is destroyed. NULL means do nothing. */ -#define ecore_audio_obj_vio_set(vio, data, free_func) ECORE_AUDIO_OBJ_ID(ECORE_AUDIO_OBJ_SUB_ID_VIO_SET), EO_TYPECHECK(Ecore_Audio_Vio *, vio), EO_TYPECHECK(void *, data), EO_TYPECHECK(eo_base_data_free_func, free_func) +#define ecore_audio_obj_vio_set(vio, data, free_func) ECORE_AUDIO_OBJ_ID(ECORE_AUDIO_OBJ_SUB_ID_VIO_SET), EO_TYPECHECK(Ecore_Audio_Vio *, vio), EO_TYPECHECK(void *, data), EO_TYPECHECK(eo_key_data_free_func, free_func) #endif /** diff --git a/src/lib/ecore_audio/ecore_audio_obj_in.c b/src/lib/ecore_audio/ecore_audio_obj_in.c index f77374f551..970e2adba3 100644 --- a/src/lib/ecore_audio/ecore_audio_obj_in.c +++ b/src/lib/ecore_audio/ecore_audio_obj_in.c @@ -27,7 +27,7 @@ _ecore_audio_in_speed_set(Eo *eo_obj EINA_UNUSED, Ecore_Audio_Input *obj, double obj->speed = speed; - eo_do(eo_obj, eo_event_callback_call(ECORE_AUDIO_IN_EVENT_IN_SAMPLERATE_CHANGED, NULL, NULL)); + eo_do(eo_obj, eo_event_callback_call(ECORE_AUDIO_IN_EVENT_IN_SAMPLERATE_CHANGED, NULL)); } EOLIAN static double @@ -41,7 +41,7 @@ _ecore_audio_in_samplerate_set(Eo *eo_obj EINA_UNUSED, Ecore_Audio_Input *obj, i { obj->samplerate = samplerate; - eo_do(eo_obj, eo_event_callback_call(ECORE_AUDIO_IN_EVENT_IN_SAMPLERATE_CHANGED, NULL, NULL)); + eo_do(eo_obj, eo_event_callback_call(ECORE_AUDIO_IN_EVENT_IN_SAMPLERATE_CHANGED, NULL)); } EOLIAN static int @@ -88,8 +88,8 @@ _ecore_audio_in_remaining_get(Eo *eo_obj, Ecore_Audio_Input *obj) { if (!obj->seekable) return -1; else { - double ret; - eo_do(eo_obj, ecore_audio_obj_in_seek(0, SEEK_CUR, &ret)); + double ret = 0.0; + eo_do(eo_obj, ret = ecore_audio_obj_in_seek(0, SEEK_CUR)); return obj->length - ret; } } @@ -104,14 +104,14 @@ _ecore_audio_in_read(Eo *eo_obj, Ecore_Audio_Input *obj, void *buf, size_t len) memset(buf, 0, len); len_read = len; } else { - eo_do(eo_obj, ecore_audio_obj_in_read_internal(buf, len, &len_read)); + eo_do(eo_obj, len_read = ecore_audio_obj_in_read_internal(buf, len)); if (len_read == 0) { if (!obj->looped || !obj->seekable) { - eo_do(eo_obj, eo_event_callback_call(ECORE_AUDIO_IN_EVENT_IN_STOPPED, NULL, NULL)); + eo_do(eo_obj, eo_event_callback_call(ECORE_AUDIO_IN_EVENT_IN_STOPPED, NULL)); } else { - eo_do(eo_obj, ecore_audio_obj_in_seek(0, SEEK_SET, NULL)); - eo_do(eo_obj, ecore_audio_obj_in_read_internal(buf, len, &len_read)); - eo_do(eo_obj, eo_event_callback_call(ECORE_AUDIO_IN_EVENT_IN_LOOPED, NULL, NULL)); + eo_do(eo_obj, ecore_audio_obj_in_seek(0, SEEK_SET)); + eo_do(eo_obj, len_read = ecore_audio_obj_in_read_internal(buf, len)); + eo_do(eo_obj, eo_event_callback_call(ECORE_AUDIO_IN_EVENT_IN_LOOPED, NULL)); } } @@ -149,7 +149,7 @@ static void _free_vio(Ecore_Audio_Object *ea_obj) } EOLIAN static void -_ecore_audio_in_ecore_audio_vio_set(Eo *eo_obj, Ecore_Audio_Input *obj, Ecore_Audio_Vio *vio, void *data, eo_base_data_free_func free_func) +_ecore_audio_in_ecore_audio_vio_set(Eo *eo_obj, Ecore_Audio_Input *obj, Ecore_Audio_Vio *vio, void *data, eo_key_data_free_func free_func) { Ecore_Audio_Object *ea_obj = eo_data_scope_get(eo_obj, ECORE_AUDIO_OBJ_CLASS); @@ -182,7 +182,7 @@ EOLIAN static void _ecore_audio_in_eo_base_destructor(Eo *eo_obj, Ecore_Audio_Input *obj) { if(obj->output) - eo_do(obj->output, ecore_audio_obj_out_input_detach(eo_obj, NULL)); + eo_do(obj->output, ecore_audio_obj_out_input_detach(eo_obj)); eo_do_super(eo_obj, MY_CLASS, eo_destructor()); } diff --git a/src/lib/ecore_audio/ecore_audio_obj_in_sndfile.c b/src/lib/ecore_audio/ecore_audio_obj_in_sndfile.c index d18908da79..6860f9dd5a 100644 --- a/src/lib/ecore_audio/ecore_audio_obj_in_sndfile.c +++ b/src/lib/ecore_audio/ecore_audio_obj_in_sndfile.c @@ -142,7 +142,7 @@ static void _free_vio(Ecore_Audio_Object *ea_obj) } EOLIAN static void -_ecore_audio_in_sndfile_ecore_audio_vio_set(Eo *eo_obj, Ecore_Audio_In_Sndfile_Data *obj, Ecore_Audio_Vio *vio, void *data, eo_base_data_free_func free_func) +_ecore_audio_in_sndfile_ecore_audio_vio_set(Eo *eo_obj, Ecore_Audio_In_Sndfile_Data *obj, Ecore_Audio_Vio *vio, void *data, eo_key_data_free_func free_func) { Ecore_Audio_Object *ea_obj = eo_data_scope_get(eo_obj, ECORE_AUDIO_OBJ_CLASS); Ecore_Audio_Input *in_obj = eo_data_scope_get(eo_obj, ECORE_AUDIO_OBJ_IN_CLASS); diff --git a/src/lib/ecore_audio/ecore_audio_obj_in_tone.c b/src/lib/ecore_audio/ecore_audio_obj_in_tone.c index 60f634881f..749772f401 100644 --- a/src/lib/ecore_audio/ecore_audio_obj_in_tone.c +++ b/src/lib/ecore_audio/ecore_audio_obj_in_tone.c @@ -83,26 +83,26 @@ _ecore_audio_in_tone_ecore_audio_in_length_set(Eo *eo_obj, Ecore_Audio_In_Tone_D } EOLIAN static void -_ecore_audio_in_tone_eo_base_data_set(Eo *eo_obj, Ecore_Audio_In_Tone_Data *obj, const char *key, const void *val, eo_base_data_free_func func) +_ecore_audio_in_tone_eo_base_key_data_set(Eo *eo_obj, Ecore_Audio_In_Tone_Data *obj, const char *key, const void *val, eo_key_data_free_func func) { if (!key) return; if (!strcmp(key, ECORE_AUDIO_ATTR_TONE_FREQ)) { obj->freq = *(int *)val; } else { - eo_do_super(eo_obj, MY_CLASS, eo_base_data_set(key, val, func)); + eo_do_super(eo_obj, MY_CLASS, eo_key_data_set(key, val, func)); } } EOLIAN static void* -_ecore_audio_in_tone_eo_base_data_get(Eo *eo_obj, Ecore_Audio_In_Tone_Data *obj, const char *key) +_ecore_audio_in_tone_eo_base_key_data_get(Eo *eo_obj, Ecore_Audio_In_Tone_Data *obj, const char *key) { if (!strcmp(key, ECORE_AUDIO_ATTR_TONE_FREQ)) { return (void *) (intptr_t) obj->freq; } else { void *ret = NULL; - eo_do_super(eo_obj, MY_CLASS, eo_base_data_get(key, &ret)); + eo_do_super(eo_obj, MY_CLASS, ret = eo_key_data_get(key)); return ret; } } diff --git a/src/lib/ecore_audio/ecore_audio_obj_in_tone.h b/src/lib/ecore_audio/ecore_audio_obj_in_tone.h index 6bfd505a28..738f49a55a 100644 --- a/src/lib/ecore_audio/ecore_audio_obj_in_tone.h +++ b/src/lib/ecore_audio/ecore_audio_obj_in_tone.h @@ -37,7 +37,7 @@ extern "C" /** * @brief The frequency of the tone in Hz * - * Set with @ref eo_base_data_set() + * Set with @ref eo_key_data_set() */ #define ECORE_AUDIO_ATTR_TONE_FREQ "ecore_audio_freq" diff --git a/src/lib/ecore_audio/ecore_audio_obj_out.c b/src/lib/ecore_audio/ecore_audio_obj_out.c index 40d16004e9..495e05c701 100644 --- a/src/lib/ecore_audio/ecore_audio_obj_out.c +++ b/src/lib/ecore_audio/ecore_audio_obj_out.c @@ -25,7 +25,7 @@ static Eina_Bool _write_cb(void *data) Ecore_Audio_Output *out_obj = eo_data_scope_get(eo_obj, ECORE_AUDIO_OBJ_OUT_CLASS); Ecore_Audio_Object *ea_obj = eo_data_scope_get(eo_obj, ECORE_AUDIO_OBJ_CLASS); - ssize_t written, bread; + ssize_t written, bread = 0; float buf[1024]; if (!ea_obj->vio || !ea_obj->vio->vio->write) @@ -34,7 +34,7 @@ static Eina_Bool _write_cb(void *data) /* FIXME: Multiple inputs */ in = eina_list_data_get(out_obj->inputs); - eo_do(in, ecore_audio_obj_in_read(buf, 4*1024, &bread)); + eo_do(in, bread = ecore_audio_obj_in_read(buf, 4*1024)); if (bread == 0) { ea_obj->paused = EINA_TRUE; @@ -61,7 +61,7 @@ _ecore_audio_out_input_attach(Eo *eo_obj, Ecore_Audio_Output *obj, Eo *input) if (in->output == eo_obj) return EINA_FALSE; - if (in->output) eo_do(in->output, ecore_audio_obj_out_input_detach(input, NULL)); + if (in->output) eo_do(in->output, ecore_audio_obj_out_input_detach(input)); in->output = eo_obj; /* TODO: Send event */ @@ -113,7 +113,7 @@ static void _free_vio(Ecore_Audio_Object *ea_obj) } EOLIAN static void -_ecore_audio_out_ecore_audio_vio_set(Eo *eo_obj, Ecore_Audio_Output *_pd EINA_UNUSED, Ecore_Audio_Vio *vio, void *data, eo_base_data_free_func free_func) +_ecore_audio_out_ecore_audio_vio_set(Eo *eo_obj, Ecore_Audio_Output *_pd EINA_UNUSED, Ecore_Audio_Vio *vio, void *data, eo_key_data_free_func free_func) { Ecore_Audio_Object *ea_obj = eo_data_scope_get(eo_obj, ECORE_AUDIO_OBJ_CLASS); @@ -144,7 +144,7 @@ _ecore_audio_out_eo_base_destructor(Eo *eo_obj, Ecore_Audio_Output *obj) Eo *in; EINA_LIST_FOREACH_SAFE(obj->inputs, cur, tmp, in) { - eo_do(eo_obj, ecore_audio_obj_out_input_detach(in, NULL)); + eo_do(eo_obj, ecore_audio_obj_out_input_detach(in)); } eo_do_super(eo_obj, MY_CLASS, eo_destructor()); diff --git a/src/lib/ecore_audio/ecore_audio_obj_out_pulse.c b/src/lib/ecore_audio/ecore_audio_obj_out_pulse.c index 8e7fc6d900..d958d2153b 100644 --- a/src/lib/ecore_audio/ecore_audio_obj_out_pulse.c +++ b/src/lib/ecore_audio/ecore_audio_obj_out_pulse.c @@ -46,7 +46,7 @@ EOLIAN static void _ecore_audio_out_pulse_ecore_audio_volume_set(Eo *eo_obj, Ecore_Audio_Out_Pulse_Data *_pd EINA_UNUSED, double volume) { Eo *in; - pa_stream *stream; + pa_stream *stream = NULL; Eina_List *input; uint32_t idx; pa_cvolume pa_volume; @@ -60,7 +60,7 @@ _ecore_audio_out_pulse_ecore_audio_volume_set(Eo *eo_obj, Ecore_Audio_Out_Pulse_ eo_do_super(eo_obj, MY_CLASS, ecore_audio_obj_volume_set(volume)); EINA_LIST_FOREACH(out_obj->inputs, input, in) { - eo_do(in, eo_base_data_get("pulse_data", (void **)&stream)); + eo_do(in, stream = eo_key_data_get("pulse_data")); idx = pa_stream_get_index(stream); pa_operation_unref(pa_context_set_sink_input_volume(class_vars.context, idx, &pa_volume, NULL, NULL)); } @@ -72,12 +72,12 @@ static void _write_cb(pa_stream *stream, size_t len, void *data) Eo *in = data; void *buf; - ssize_t bread; + ssize_t bread = 0; size_t wlen = len; pa_stream_begin_write(stream, &buf, &wlen); - eo_do(in, ecore_audio_obj_in_read(buf, wlen, &bread)); + eo_do(in, bread = ecore_audio_obj_in_read(buf, wlen)); pa_stream_write(stream, buf, bread, NULL, 0, PA_SEEK_RELATIVE); if (bread < (int)len) @@ -88,14 +88,14 @@ static void _write_cb(pa_stream *stream, size_t len, void *data) static Eina_Bool _update_samplerate_cb(void *data EINA_UNUSED, Eo *eo_obj, const Eo_Event_Description *desc EINA_UNUSED, void *event_info EINA_UNUSED) { - pa_stream *stream; - int samplerate; - double speed; + pa_stream *stream = NULL; + int samplerate = 0; + double speed = 0; - eo_do(eo_obj, ecore_audio_obj_in_samplerate_get(&samplerate)); - eo_do(eo_obj, ecore_audio_obj_in_speed_get(&speed)); + eo_do(eo_obj, samplerate = ecore_audio_obj_in_samplerate_get()); + eo_do(eo_obj, speed = ecore_audio_obj_in_speed_get()); - eo_do(eo_obj, eo_base_data_get("pulse_data", (void **)&stream)); + eo_do(eo_obj, stream = eo_key_data_get("pulse_data")); pa_operation_unref(pa_stream_update_sample_rate(stream, samplerate * speed, NULL, NULL)); @@ -104,35 +104,35 @@ static Eina_Bool _update_samplerate_cb(void *data EINA_UNUSED, Eo *eo_obj, const static Eina_Bool _input_attach_internal(Eo *eo_obj, Eo *in) { - const char *name; + const char *name = NULL; pa_sample_spec ss; - double speed; + double speed = 0; pa_stream *stream; - Eina_Bool ret; + Eina_Bool ret = EINA_FALSE; Ecore_Audio_Object *ea_obj = eo_data_scope_get(eo_obj, ECORE_AUDIO_OBJ_CLASS); - eo_do_super(eo_obj, MY_CLASS, ecore_audio_obj_out_input_attach(in, &ret)); + eo_do_super(eo_obj, MY_CLASS, ret = ecore_audio_obj_out_input_attach(in)); if (!ret) return EINA_FALSE; ss.format = PA_SAMPLE_FLOAT32LE; - eo_do(in, ecore_audio_obj_in_samplerate_get((int *)&ss.rate)); - eo_do(in, ecore_audio_obj_in_speed_get(&speed)); - eo_do(in, ecore_audio_obj_in_channels_get((int *)&ss.channels)); - eo_do(in, ecore_audio_obj_name_get(&name)); + eo_do(in, ss.rate = ecore_audio_obj_in_samplerate_get()); + eo_do(in, speed = ecore_audio_obj_in_speed_get()); + eo_do(in, ss.channels = ecore_audio_obj_in_channels_get()); + eo_do(in, name = ecore_audio_obj_name_get()); ss.rate = ss.rate * speed; stream = pa_stream_new(class_vars.context, name, &ss, NULL); if (!stream) { ERR("Could not create stream"); - eo_do_super(eo_obj, MY_CLASS, ecore_audio_obj_out_input_detach(in, NULL)); + eo_do_super(eo_obj, MY_CLASS, ecore_audio_obj_out_input_detach(in)); return EINA_FALSE; } eo_do(in, eo_event_callback_add(ECORE_AUDIO_IN_EVENT_IN_SAMPLERATE_CHANGED, _update_samplerate_cb, eo_obj)); - eo_do(in, eo_base_data_set("pulse_data", stream, NULL)); + eo_do(in, eo_key_data_set("pulse_data", stream, NULL)); pa_stream_set_write_callback(stream, _write_cb, in); @@ -178,14 +178,14 @@ static void _drain_cb(pa_stream *stream, int success EINA_UNUSED, void *data EIN EOLIAN static Eina_Bool _ecore_audio_out_pulse_ecore_audio_out_input_detach(Eo *eo_obj, Ecore_Audio_Out_Pulse_Data *_pd EINA_UNUSED, Eo *in) { - pa_stream *stream; - Eina_Bool ret2; + pa_stream *stream = NULL; + Eina_Bool ret2 = EINA_FALSE; - eo_do_super(eo_obj, MY_CLASS, ecore_audio_obj_out_input_detach(in, &ret2)); + eo_do_super(eo_obj, MY_CLASS, ret2 = ecore_audio_obj_out_input_detach(in)); if (!ret2) return EINA_FALSE; - eo_do(in, eo_base_data_get("pulse_data", (void **)&stream)); + eo_do(in, stream = eo_key_data_get("pulse_data")); pa_stream_set_write_callback(stream, NULL, NULL); pa_operation_unref(pa_stream_drain(stream, _drain_cb, NULL)); @@ -210,12 +210,12 @@ static void _state_cb(pa_context *context, void *data EINA_UNUSED) if (state == PA_CONTEXT_READY) { DBG("PA context ready."); EINA_LIST_FOREACH(class_vars.outputs, out, eo_obj) { - eo_do(eo_obj, eo_event_callback_call(ECORE_AUDIO_OUT_PULSE_EVENT_CONTEXT_READY, NULL, NULL)); + eo_do(eo_obj, eo_event_callback_call(ECORE_AUDIO_OUT_PULSE_EVENT_CONTEXT_READY, NULL)); } } else if ((state == PA_CONTEXT_FAILED) || (state == PA_CONTEXT_TERMINATED)) { DBG("PA context fail."); EINA_LIST_FOREACH(class_vars.outputs, out, eo_obj) { - eo_do(eo_obj, eo_event_callback_call(ECORE_AUDIO_OUT_PULSE_EVENT_CONTEXT_FAIL, NULL, NULL)); + eo_do(eo_obj, eo_event_callback_call(ECORE_AUDIO_OUT_PULSE_EVENT_CONTEXT_FAIL, NULL)); } } else { DBG("Connection state %i", state); @@ -241,7 +241,7 @@ static void _state_job(void *data EINA_UNUSED) } // the callback here can delete things in the list.. EINA_LIST_FOREACH(class_vars.outputs, out, eo_obj) { - eo_do(eo_obj, eo_event_callback_call(ECORE_AUDIO_OUT_PULSE_EVENT_CONTEXT_FAIL, NULL, NULL)); + eo_do(eo_obj, eo_event_callback_call(ECORE_AUDIO_OUT_PULSE_EVENT_CONTEXT_FAIL, NULL)); } // now unref everything safely EINA_LIST_FOREACH_SAFE(class_vars.outputs, out, tmp, eo_obj) { diff --git a/src/lib/ecore_audio/ecore_audio_obj_out_sndfile.c b/src/lib/ecore_audio/ecore_audio_obj_out_sndfile.c index d1ca3b5263..5e0e02f061 100644 --- a/src/lib/ecore_audio/ecore_audio_obj_out_sndfile.c +++ b/src/lib/ecore_audio/ecore_audio_obj_out_sndfile.c @@ -37,13 +37,13 @@ static Eina_Bool _write_cb(void *data) Ecore_Audio_Output *out_obj = eo_data_scope_get(eo_obj, ECORE_AUDIO_OBJ_OUT_CLASS); Ecore_Audio_Object *ea_obj = eo_data_scope_get(eo_obj, ECORE_AUDIO_OBJ_CLASS); - ssize_t written, bread; + ssize_t written, bread = 0; float buf[1024]; /* TODO: Support mixing of multiple inputs */ in = eina_list_data_get(out_obj->inputs); - eo_do(in, ecore_audio_obj_in_read(buf, 4*1024, &bread)); + eo_do(in, bread = ecore_audio_obj_in_read(buf, 4*1024)); if (bread == 0) { sf_write_sync(obj->handle); @@ -64,21 +64,21 @@ _ecore_audio_out_sndfile_ecore_audio_out_input_attach(Eo *eo_obj, Ecore_Audio_Ou { Ecore_Audio_Object *ea_obj = eo_data_scope_get(eo_obj, ECORE_AUDIO_OBJ_CLASS); Ecore_Audio_Output *out_obj = eo_data_scope_get(eo_obj, ECORE_AUDIO_OBJ_OUT_CLASS); - Eina_Bool ret2; + Eina_Bool ret2 = EINA_FALSE; - eo_do_super(eo_obj, MY_CLASS, ecore_audio_obj_out_input_attach(in, &ret2)); + eo_do_super(eo_obj, MY_CLASS, ret2 = ecore_audio_obj_out_input_attach(in)); if (!ret2) return EINA_FALSE; - eo_do(in, ecore_audio_obj_in_samplerate_get(&obj->sfinfo.samplerate)); - eo_do(in, ecore_audio_obj_in_channels_get(&obj->sfinfo.channels)); + eo_do(in, obj->sfinfo.samplerate = ecore_audio_obj_in_samplerate_get()); + eo_do(in, obj->sfinfo.channels = ecore_audio_obj_in_channels_get()); obj->handle = sf_open(ea_obj->source, SFM_WRITE, &obj->sfinfo); if (!obj->handle) { eina_stringshare_del(ea_obj->source); ea_obj->source = NULL; - eo_do_super(eo_obj, MY_CLASS, ecore_audio_obj_out_input_detach(in, NULL)); + eo_do_super(eo_obj, MY_CLASS, ecore_audio_obj_out_input_detach(in)); return EINA_FALSE; } @@ -165,7 +165,7 @@ _ecore_audio_out_sndfile_eo_base_constructor(Eo *eo_obj, Ecore_Audio_Out_Sndfile eo_do_super(eo_obj, MY_CLASS, eo_constructor()); - eo_do(eo_obj, ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_OGG, NULL)); + eo_do(eo_obj, ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_OGG)); // FIXME: Use writer from output out_obj->need_writer = EINA_FALSE; diff --git a/src/lib/ecore_audio/ecore_audio_private.h b/src/lib/ecore_audio/ecore_audio_private.h index b997ea8e03..36a06f5f4c 100644 --- a/src/lib/ecore_audio/ecore_audio_private.h +++ b/src/lib/ecore_audio/ecore_audio_private.h @@ -94,7 +94,7 @@ struct _Ecore_Audio_Module struct _Ecore_Audio_Vio_Internal { Ecore_Audio_Vio *vio; void *data; - eo_base_data_free_func free_func; + eo_key_data_free_func free_func; }; typedef struct _Ecore_Audio_Vio_Internal Ecore_Audio_Vio_Internal; diff --git a/src/lib/edje/edje_edit.c b/src/lib/edje/edje_edit.c index db301f1078..6120ff0adb 100644 --- a/src/lib/edje/edje_edit.c +++ b/src/lib/edje/edje_edit.c @@ -193,7 +193,7 @@ _edje_edit_edje_file_set(Eo *obj, Edje_Edit *eed, const char *file, const char * * groups). */ Eina_Bool int_ret = EINA_FALSE; - eo_do_super(obj, MY_CLASS, edje_obj_file_set(file, group, &int_ret)); + eo_do_super(obj, MY_CLASS, int_ret = edje_obj_file_set(file, group)); if (!int_ret) return ret; diff --git a/src/lib/edje/edje_multisense.c b/src/lib/edje/edje_multisense.c index 07653a15ea..7fc8fc54ed 100644 --- a/src/lib/edje/edje_multisense.c +++ b/src/lib/edje/edje_multisense.c @@ -264,7 +264,7 @@ _edje_multisense_internal_sound_tone_play(Edje *ed, const char *tone_name, const { in = eo_add(ECORE_AUDIO_OBJ_IN_TONE_CLASS, NULL); eo_do(in, ecore_audio_obj_name_set("tone")); - eo_do(in, eo_base_data_set(ECORE_AUDIO_ATTR_TONE_FREQ, &tone->value, NULL)); + eo_do(in, eo_key_data_set(ECORE_AUDIO_ATTR_TONE_FREQ, &tone->value, NULL)); eo_do(in, ecore_audio_obj_in_length_set(duration)); eo_do(in, eo_event_callback_add(ECORE_AUDIO_IN_EVENT_IN_STOPPED, _play_finished, NULL)); diff --git a/src/lib/edje/edje_program.c b/src/lib/edje/edje_program.c index 1a2126c5ad..46bb3fdfe0 100644 --- a/src/lib/edje/edje_program.c +++ b/src/lib/edje/edje_program.c @@ -78,7 +78,7 @@ edje_object_signal_callback_del(Evas_Object *obj, const char *emission, const ch { if (!obj) return NULL; void *ret = NULL; - eo_do(obj, edje_obj_signal_callback_del(emission, source, (Edje_Signal_Cb)func, NULL, &ret)); + eo_do(obj, ret = edje_obj_signal_callback_del(emission, source, (Edje_Signal_Cb)func, NULL)); return ret; } @@ -107,7 +107,7 @@ edje_object_signal_callback_del_full(Evas_Object *obj, const char *emission, con { if (!obj) return NULL; void *ret = NULL; - eo_do(obj, edje_obj_signal_callback_del(emission, source, func, data, &ret)); + eo_do(obj, ret = edje_obj_signal_callback_del(emission, source, func, data)); return ret; } diff --git a/src/lib/edje/edje_smart.c b/src/lib/edje/edje_smart.c index 536356edb7..a4de77fc0c 100644 --- a/src/lib/edje/edje_smart.c +++ b/src/lib/edje/edje_smart.c @@ -52,8 +52,8 @@ _edje_eo_base_dbg_info_get(Eo *eo_obj, Edje *_pd EINA_UNUSED, Eo_Dbg_Info *root) EO_DBG_INFO_APPEND(group, "File", EINA_VALUE_TYPE_STRING, file); EO_DBG_INFO_APPEND(group, "Group", EINA_VALUE_TYPE_STRING, edje_group); - Edje_Load_Error error; - eo_do(eo_obj, edje_obj_load_error_get(&error)); + Edje_Load_Error error = EDJE_LOAD_ERROR_NONE; + eo_do(eo_obj, error = edje_obj_load_error_get()); if (error != EDJE_LOAD_ERROR_NONE) { EO_DBG_INFO_APPEND(group, "Error", EINA_VALUE_TYPE_STRING, @@ -363,4 +363,4 @@ _edje_mmap_set(Eo *obj, Edje *_pd EINA_UNUSED, const Eina_File *f, const char *g return ret; } -#include "edje.eo.c" \ No newline at end of file +#include "edje.eo.c" diff --git a/src/lib/eo/Eo.h b/src/lib/eo/Eo.h index 7f77b393cf..6e6979942d 100644 --- a/src/lib/eo/Eo.h +++ b/src/lib/eo/Eo.h @@ -229,20 +229,6 @@ EAPI void eo_dbg_info_free(Eo_Dbg_Info *info); * @} */ -/** - * @def EO_TYPECHECK(type, x) - * - * Checks x is castable to type "type" and casts it to it. - * @param type The C type to check against. - * @param x the variable to test and cast. - */ -#define EO_TYPECHECK(type, x) \ - ({ \ - type __x; \ - __x = x; \ - (type) __x; \ - }) - /** * @typedef Eo_Op * The Eo operation type id. @@ -255,15 +241,6 @@ typedef unsigned int Eo_Op; */ #define EO_NOOP ((Eo_Op) 0) -/** - * @typedef eo_op_func_type - * The type of the Op functions. This is the type of the functions used by - * Eo. - * - * @see eo_op_func_type_class - */ -typedef void (*eo_op_func_type)(Eo *, void *class_data, va_list *list); - /** * @addtogroup Eo_Events Eo's Event Handling * @{ @@ -382,71 +359,20 @@ enum _Eo_Class_Type */ typedef enum _Eo_Class_Type Eo_Class_Type; -/** - * @struct _Eo_Op_Func_Description - * Used to associate an Op with a func. - * @see eo_class_funcs_set - */ -struct _Eo_Op_Func_Description -{ - Eo_Op op; /**< The op */ - eo_op_func_type func; /**< The function to call for the op. */ - Eo_Op_Type op_type; /**< The type of the op */ -}; - -/** - * @typedef Eo_Op_Func_Description - * A convenience typedef for #_Eo_Op_Func_Description - */ -typedef struct _Eo_Op_Func_Description Eo_Op_Func_Description; - -/** - * @def EO_OP_FUNC(op, func) - * A convenience macro to be used when populating the #Eo_Op_Func_Description - * array. - */ -#define EO_OP_FUNC(op, func) { op, EO_TYPECHECK(eo_op_func_type, func), EO_OP_TYPE_REGULAR } - -/** - * @def EO_OP_FUNC_CLASS(op, func) - * A convenience macro to be used when populating the #Eo_Op_Func_Description - * array. - * The same as #EO_OP_FUNC but for class functions. - * - * @see EO_OP_FUNC - */ -#define EO_OP_FUNC_CLASS(op, func) { op, EO_TYPECHECK(eo_op_func_type, func), EO_OP_TYPE_CLASS } - -/** - * @def EO_OP_FUNC_SENTINEL - * A convenience macro to be used when populating the #Eo_Op_Func_Description - * array. It must appear at the end of the ARRAY. - */ -#define EO_OP_FUNC_SENTINEL { 0, NULL, EO_OP_TYPE_INVALID } - -/** - * @struct _Eo_Op_Description - * This struct holds the description of a specific op. - */ -struct _Eo_Op_Description -{ - Eo_Op sub_op; /**< The sub_id of the op in it's class. */ - const char *name; /**< The name of the op. */ - const char *doc; /**< Explanation about the Op. */ - Eo_Op_Type op_type; /**< The type of the Op. */ -}; - -/** - * @typedef Eo_Op_Description - * A convenience typedef for #_Eo_Op_Description - */ -typedef struct _Eo_Op_Description Eo_Op_Description; - /** * @def EO_VERSION * The current version of EO. */ -#define EO_VERSION 1 +#define EO_VERSION 2 + +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. */ +} Eo_Op_Description; /** * @struct _Eo_Class_Description @@ -460,8 +386,7 @@ struct _Eo_Class_Description const char *name; /**< The name of the class. */ Eo_Class_Type type; /**< The type of the class. */ struct { - Eo_Op *base_op_id; - const Eo_Op_Description *descs; + 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. */ @@ -476,60 +401,6 @@ struct _Eo_Class_Description */ typedef struct _Eo_Class_Description Eo_Class_Description; -/** - * @def EO_CLASS_DESCRIPTION_OPS(base_op_id, op_descs, count) - * An helper macro to help populating #Eo_Class_Description. - * @param base_op_id A pointer to the base op id of the class. - * @param op_descs the op descriptions array. - * @param count the number of ops in the op descriptions array. - */ -#define EO_CLASS_DESCRIPTION_OPS(base_op_id, op_descs, count) { base_op_id, op_descs, count } - -/** - * @def EO_OP_DESCRIPTION(op, doc) - * An helper macro to help populating #Eo_Op_Description - * @param sub_id The sub id of the op being described. - * @param doc Additional doc for the op. - * @see Eo_Op_Description - * @see EO_OP_DESCRIPTION_CLASS - * @see EO_OP_DESCRIPTION_SENTINEL - */ -#define EO_OP_DESCRIPTION(sub_id, doc) { sub_id, #sub_id, doc, EO_OP_TYPE_REGULAR } - -/** - * @def EO_OP_DESCRIPTION_CLASS(op, doc) - * An helper macro to help populating #Eo_Op_Description - * This macro is the same as EO_OP_DESCRIPTION but indicates that the op's - * implementation is of type CLASS. - * @param sub_id The sub id of the op being described. - * @param doc Additional doc for the op. - * @see Eo_Op_Description - * @see EO_OP_DESCRIPTION - * @see EO_OP_DESCRIPTION_SENTINEL - */ -#define EO_OP_DESCRIPTION_CLASS(sub_id, doc) { sub_id, #sub_id, doc, EO_OP_TYPE_CLASS } - -/** - * @def EO_OP_DESCRIPTION_SENTINEL - * An helper macro to help populating #Eo_Op_Description - * Should be placed at the end of the array. - * @see Eo_Op_Description - * @see EO_OP_DESCRIPTION - */ -#define EO_OP_DESCRIPTION_SENTINEL { 0, NULL, NULL, EO_OP_TYPE_INVALID } - -/** - * @def EO_PARAMETER_GET - * An helper macro to get parameter with less mistake - */ -#define EO_PARAMETER_GET(Type, Name, List) Type Name = va_arg(*List, Type); - -/** - * @def EO_PARAMETER_ENUM_GET - * An helper macro to get parameter that are enum with less mistake (require to ask an int) - */ -#define EO_PARAMETER_ENUM_GET(Type, Name, List) Type Name = va_arg(*List, int); - /** * @brief Create a new class. * @param desc the class description to create the class with. @@ -554,15 +425,6 @@ EAPI const Eo_Class *eo_class_new(const Eo_Class_Description *desc, const Eo_Cla */ EAPI Eina_Bool eo_isa(const Eo *obj, const Eo_Class *klass); -/** - * @brief Sets the OP functions for a class. - * @param klass the class to set the functions to. - * @param func_descs a NULL terminated array of #Eo_Op_Func_Description - * - * Should be called from within the class constructor. - */ -EAPI void eo_class_funcs_set(Eo_Class *klass, const Eo_Op_Func_Description *func_descs); - /** * @brief Gets the name of the passed class. * @param klass the class to work on. @@ -592,73 +454,139 @@ EAPI Eina_Bool eo_init(void); */ EAPI Eina_Bool eo_shutdown(void); -/** - * @def eo_do - * A convenience wrapper around eo_do_internal() - * @see eo_do_internal - */ -#define eo_do(obj, ...) eo_do_internal(__FILE__, __LINE__, obj, __VA_ARGS__, EO_NOOP) +// computes size of Eo_Op_Description[] +#define EO_OP_DESC_SIZE(desc) (sizeof(desc)/sizeof(*desc) - 1) -/** - * @def eo_vdo - * A convenience wrapper around eo_vdo_internal() - * @see eo_vdo_internal - */ -#define eo_vdo(obj, args) eo_vdo_internal(__FILE__, __LINE__, obj, args) +// Helpers macro to help populating #Eo_Class_Description. +#define EO_CLASS_DESCRIPTION_NOOPS() { NULL, 0} +#define EO_CLASS_DESCRIPTION_OPS(op_descs) { op_descs, EO_OP_DESC_SIZE(op_descs) } -/** - * @brief Calls op functions of an object - * @param obj The object to work on - * @param ... NULL terminated list of OPs and parameters. - * @return @c EINA_TRUE on success. - * - * Use the helper macros, don't pass the parameters manually. - * Use #eo_do instead of this function. - * - * @see #eo_do - */ -EAPI Eina_Bool eo_do_internal(const char *file, int line, const Eo *obj, ...); +// to fetch internal function and object data at once +typedef struct _Eo_Op_Call_Data +{ + Eo *obj; + Eo_Class *klass; // remove this not necessary in Eo_Hook_Call + void *func; + void *data; +} Eo_Op_Call_Data; -/** - * @brief Calls op functions of an object - * @param obj The object to work on - * @param ops NULL terminated list of OPs and parameters. - * @return @c EINA_TRUE on success. - * - * Use the helper macros, don't pass the parameters manually. - * Use #eo_vdo instead of this function. - * - * @see #eo_vdo - */ -EAPI Eina_Bool eo_vdo_internal(const char *file, int line, const Eo *obj, va_list *ops); +typedef void (*Eo_Hook_Call)(const Eo_Class *klass_id, const Eo *obj, void *func, ...); -/** - * @brief Calls the super function for the specific op. - * @param obj The object to work on - * @param cur_klass The *current* class (use the class *after* this in the MRO). - * @param ... list of parameters. - * @return @c EINA_TRUE on success. - * - * Unlike eo_do(), this function only accepts one op. - * - * @see #eo_do - */ -#define eo_do_super(obj, cur_klass, ...) eo_do_super_internal(__FILE__, __LINE__, obj, cur_klass, __VA_ARGS__) +EAPI extern Eo_Hook_Call eo_hook_call_pre; +EAPI extern Eo_Hook_Call eo_hook_call_post; -/** - * @brief Calls the super function for the specific op. - * @param obj The object to work on - * @param cur_klass The *current* class (use the class *after* this in the MRO). - * @param op The wanted op. - * @param ... list of parameters. - * @return @c EINA_TRUE on success. - * - * Don't use this function, use the wrapping macros instead. - * - * @see #eo_do - * @see #eo_do_super - */ -EAPI Eina_Bool eo_do_super_internal(const char *file, int line, const Eo *obj, const Eo_Class *cur_klass, Eo_Op op, ...); +// to pass the internal function call to EO_FUNC_BODY (as Func parameter) +#define EO_FUNC_CALL(...) __VA_ARGS__ + +#define EO_HOOK_CALL_PREPARE(Hook) \ + if (Hook) \ + Hook(call.klass, call.obj, call.func); + +#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 EO_FUNC_COMMON_OP(Name, DefRet) \ + Eo_Op_Call_Data call; \ + static Eo_Op op = EO_NOOP; \ + if (op == EO_NOOP) \ + 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 EO_FUNC_BODY(Name, Ret, DefRet) \ + Ret \ + Name(void) \ + { \ + typedef Ret (*_Eo_##Name##_func)(Eo *, void *obj_data); \ + Ret _r; \ + EO_FUNC_COMMON_OP(Name, DefRet); \ + EO_HOOK_CALL_PREPARE(eo_hook_call_pre); \ + _r = _func_(call.obj, call.data); \ + EO_HOOK_CALL_PREPARE(eo_hook_call_post); \ + return _r; \ + } + +#define EO_VOID_FUNC_BODY(Name) \ + void \ + Name(void) \ + { \ + 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); \ + EO_HOOK_CALL_PREPARE(eo_hook_call_post); \ + } + +#define EO_FUNC_BODYV(Name, Ret, DefRet, Arguments, ...) \ + Ret \ + Name(__VA_ARGS__) \ + { \ + typedef Ret (*_Eo_##Name##_func)(Eo *, void *obj_data, __VA_ARGS__); \ + Ret _r; \ + EO_FUNC_COMMON_OP(Name, DefRet); \ + EO_HOOK_CALL_PREPAREV(eo_hook_call_pre, Arguments); \ + _r = _func_(call.obj, call.data, Arguments); \ + EO_HOOK_CALL_PREPAREV(eo_hook_call_post, Arguments); \ + return _r; \ + } + +#define EO_VOID_FUNC_BODYV(Name, Arguments, ...) \ + void \ + Name(__VA_ARGS__) \ + { \ + 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); \ + EO_HOOK_CALL_PREPAREV(eo_hook_call_post, Arguments); \ + } + +// OP ID of an overriding function +#define EO_OP_OVERRIDE ((Eo_Op) -1) + +#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 _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 _eo_call_resolve(const char *func_name, const Eo_Op op, Eo_Op_Call_Data *call, const char *file, 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 eo_do barrier, unref the obj, move the stack pointer +EAPI void _eo_do_end(const Eo **ojb); + +#define EO_DO_CLEANUP __attribute__((cleanup(_eo_do_end))) + +// eo object method calls batch, + +#define _eo_do_common(eoid, clsid, is_super, ...) \ + do \ + { \ + const Eo *_eoid_ = eoid; \ + if (_eo_do_start(_eoid_, clsid, is_super, __FILE__, __FUNCTION__, __LINE__)) \ + { \ + const Eo *_id_clean_ EO_DO_CLEANUP = _eoid_; \ + __VA_ARGS__; \ + (void) _id_clean_; \ + } \ + } while (0) + + +#define eo_do(eoid, ...) _eo_do_common(eoid, NULL, EINA_FALSE, __VA_ARGS__) + +#define eo_do_super(eoid, clsid, func) _eo_do_common(eoid, clsid, EINA_TRUE, func) + +/*****************************************************************************/ /** * @brief Gets the class of the object. @@ -695,7 +623,13 @@ EAPI void eo_error_set_internal(const Eo *obj, const char *file, int line); #define eo_add(klass, parent, ...) \ ({ \ const Eo_Class *_tmp_klass = klass; \ - eo_add_internal(__FILE__, __LINE__, _tmp_klass, parent, eo_constructor(), ## __VA_ARGS__, EO_NOOP); \ + Eo *_tmp_obj = _eo_add_internal_start(__FILE__, __LINE__, _tmp_klass, parent); \ + eo_do(_tmp_obj, \ + eo_constructor(); \ + __VA_ARGS__; \ + _tmp_obj = _eo_add_internal_end(__FILE__, __LINE__, _tmp_obj); \ + ); \ + _tmp_obj; \ }) /** @@ -711,22 +645,16 @@ EAPI void eo_error_set_internal(const Eo *obj, const char *file, int line); #define eo_add_custom(klass, parent, ...) \ ({ \ const Eo_Class *_tmp_klass = klass; \ - eo_add_internal(__FILE__, __LINE__, _tmp_klass, parent, ## __VA_ARGS__, EO_NOOP); \ + Eo *_tmp_obj = _eo_add_internal_start(__FILE__, __LINE__, _tmp_klass, parent); \ + eo_do(_tmp_obj, \ + __VA_ARGS__; \ + _tmp_obj = _eo_add_internal_end(__FILE__, __LINE__, _tmp_obj); \ + ); \ + _tmp_obj; \ }) -/** - * @brief Create a new object. - * @param klass the class of the object to create. - * @param parent the parent to set to the object. - * @param ... The ops to run. With the constructor being first. - * @return An handle to the new object on success, NULL otherwise. - * - * Use the helper macros, don't pass the parameters manually. - * Use #eo_add or #eo_add_custom instead of this function. - * - * @see #eo_add - */ -EAPI Eo *eo_add_internal(const char *file, int line, const Eo_Class *klass, Eo *parent, ...); +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. @@ -993,16 +921,6 @@ EAPI Eina_Bool eo_composite_is(const Eo *comp_obj); * */ EAPI const Eo_Class *eo_class_class_get(void); -/** - * @var EO_CLASS_CLASS_BASE_ID - * #EO_CLASS_CLASS 's base id. - */ -extern EAPI Eo_Op EO_CLASS_CLASS_BASE_ID; - -enum { - EO_CLASS_CLASS_SUB_ID_LAST -}; - /** * @} */ @@ -1013,105 +931,59 @@ enum { */ /** - * @def EO_BASE_CLASS + * @def EO_CLASS * The class type for the Eo base class. */ -#define EO_BASE_CLASS eo_base_class_get() +#define EO_CLASS eo_base_class_get() /** - * @brief Use #EO_BASE_CLASS + * @brief Use #EO_CLASS * @internal * */ EAPI const Eo_Class *eo_base_class_get(void); /** - * @typedef eo_base_data_free_func + * @typedef eo_key_data_free_func * Data free func prototype. */ -typedef void (*eo_base_data_free_func)(void *); +typedef void (*eo_key_data_free_func)(void *); /** - * @var EO_BASE_BASE_ID - * #EO_BASE_CLASS 's base id. - */ -extern EAPI Eo_Op EO_BASE_BASE_ID; - -enum { - EO_BASE_SUB_ID_CONSTRUCTOR, - EO_BASE_SUB_ID_DESTRUCTOR, - EO_BASE_SUB_ID_PARENT_SET, - EO_BASE_SUB_ID_PARENT_GET, - EO_BASE_SUB_ID_CHILDREN_ITERATOR_NEW, - EO_BASE_SUB_ID_DATA_SET, - EO_BASE_SUB_ID_DATA_GET, - EO_BASE_SUB_ID_DATA_DEL, - EO_BASE_SUB_ID_WREF_ADD, - EO_BASE_SUB_ID_WREF_DEL, - EO_BASE_SUB_ID_EVENT_CALLBACK_PRIORITY_ADD, - EO_BASE_SUB_ID_EVENT_CALLBACK_DEL, - EO_BASE_SUB_ID_EVENT_CALLBACK_ARRAY_PRIORITY_ADD, - EO_BASE_SUB_ID_EVENT_CALLBACK_ARRAY_DEL, - EO_BASE_SUB_ID_EVENT_CALLBACK_CALL, - EO_BASE_SUB_ID_EVENT_CALLBACK_FORWARDER_ADD, - EO_BASE_SUB_ID_EVENT_CALLBACK_FORWARDER_DEL, - EO_BASE_SUB_ID_EVENT_FREEZE, - EO_BASE_SUB_ID_EVENT_THAW, - EO_BASE_SUB_ID_EVENT_FREEZE_GET, - EO_BASE_SUB_ID_EVENT_GLOBAL_FREEZE, - EO_BASE_SUB_ID_EVENT_GLOBAL_THAW, - EO_BASE_SUB_ID_EVENT_GLOBAL_FREEZE_GET, - EO_BASE_SUB_ID_DBG_INFO_GET, - EO_BASE_SUB_ID_LAST -}; - -/** - * @def EO_BASE_ID(sub_id) - * Helper macro to get the full Op ID out of the sub_id for EO_BASE. - * @param sub_id the sub id inside EO_BASE. - */ -#define EO_BASE_ID(sub_id) (EO_BASE_BASE_ID + (sub_id)) - -/** - * @def eo_base_data_set(key, data, free_func) - * Set generic data to object. + * @brief Set generic data to object. * @param[in] key the key associated with the data * @param[in] data the data to set. * @param[in] free_func the func to free data with (NULL means "do nothing"). * - * @see #eo_base_data_get - * @see #eo_base_data_del + * @see #eo_key_data_get + * @see #eo_key_data_del */ -#define eo_base_data_set(key, data, free_func) EO_BASE_ID(EO_BASE_SUB_ID_DATA_SET), EO_TYPECHECK(const char *, key), EO_TYPECHECK(const void *, data), EO_TYPECHECK(eo_base_data_free_func, free_func) +EAPI void eo_key_data_set(const char *key, const void *data, eo_key_data_free_func free_func); /** - * @def eo_base_data_get(key, data) - * Get generic data from object. + * @brief Get generic data from object. * @param[in] key the key associated with the data * @param[out] data the data for the key * - * @see #eo_base_data_set - * @see #eo_base_data_del + * @see #eo_key_data_set + * @see #eo_key_data_del */ -#define eo_base_data_get(key, data) EO_BASE_ID(EO_BASE_SUB_ID_DATA_GET), EO_TYPECHECK(const char *, key), EO_TYPECHECK(void **, data) +EAPI void *eo_key_data_get(const char *key); /** - * @def eo_dbg_info_get(root_node) - * Get dbg information from the object. + * @brief Get dbg information from the object. * @param[in] root node of the tree */ -#define eo_dbg_info_get(root_node) EO_BASE_ID(EO_BASE_SUB_ID_DBG_INFO_GET), EO_TYPECHECK(Eo_Dbg_Info *, root_node) +EAPI void eo_dbg_info_get(Eo_Dbg_Info *root_node); /** - * @def eo_base_data_del(key) - * Del generic data from object. + * @brief Del generic data from object. * @param[in] key the key associated with the data * - * @see #eo_base_data_set - * @see #eo_base_data_get + * @see #eo_key_data_set + * @see #eo_key_data_get */ -#define eo_base_data_del(key) EO_BASE_ID(EO_BASE_SUB_ID_DATA_DEL), EO_TYPECHECK(const char *, key) +EAPI void eo_key_data_del(const char *key); /** - * @def eo_parent_set * @brief Set the parent of an object * @param[in] parent the new parent. * @@ -1122,29 +994,26 @@ enum { * @see eo_del() * @see eo_parent_get() */ -#define eo_parent_set(parent) EO_BASE_ID(EO_BASE_SUB_ID_PARENT_SET), EO_TYPECHECK(Eo *, parent) +EAPI void eo_parent_set(Eo *parent); /** - * @def eo_parent_get * @brief Get the parent of an object * @param[out] a pointer to the parent object. * * @see eo_parent_set() */ -#define eo_parent_get(parent) EO_BASE_ID(EO_BASE_SUB_ID_PARENT_GET), EO_TYPECHECK(Eo **, parent) +EAPI Eo *eo_parent_get(void); /** - * @def eo_children_iterator_new * @brief Get an iterator on all childrens * @param obj the object to get the childrens from. * @return a pointer to an Eina_Iterator containing all the childrens. * * @see eo_parent_set() */ -#define eo_children_iterator_new(it) EO_BASE_ID(EO_BASE_SUB_ID_CHILDREN_ITERATOR_NEW), EO_TYPECHECK(Eina_Iterator **, it) +EAPI Eina_Iterator *eo_children_iterator_new(void); /** - * @def eo_wref_add * @brief Add a new weak reference to obj. * @param wref The pointer to use for the weak ref. * @@ -1155,16 +1024,15 @@ enum { * * @see #eo_wref_del */ -#define eo_wref_add(wref) EO_BASE_ID(EO_BASE_SUB_ID_WREF_ADD), EO_TYPECHECK(Eo **, wref) +EAPI void eo_wref_add(Eo **wref); /** - * @def eo_wref_del * @brief Delete the weak reference passed. * @param wref the weak reference to free. * * @see #eo_wref_add */ -#define eo_wref_del(wref) EO_BASE_ID(EO_BASE_SUB_ID_WREF_DEL), EO_TYPECHECK(Eo **, wref) +EAPI void eo_wref_del(Eo **wref); /** * @def eo_weak_ref @@ -1178,9 +1046,9 @@ enum { * @see eo_weak_unref * @see eo_wref_add */ -#define eo_weak_ref(wref) \ - do { \ - if (*wref) eo_do(*wref, eo_wref_add(wref)); \ +#define eo_weak_ref(wref) \ + do { \ + if (*wref) eo_do(*wref, eo_wref_add(wref)); \ } while (0) /** @@ -1196,9 +1064,9 @@ enum { * @see eo_wref_del * @see eo_wref_del_safe */ -#define eo_weak_unref(wref) \ - do { \ - if (*wref) eo_do(*wref, eo_wref_del(wref)); \ +#define eo_weak_unref(wref) \ + do { \ + if (*wref) eo_do(*wref, eo_wref_del(wref)); \ } while (0) /** @@ -1214,24 +1082,22 @@ enum { #define eo_wref_del_safe(wref) eo_weak_unref(wref) /** - * @def eo_constructor * @brief Call the object's constructor. * * Should not be used with #eo_do. Only use it with #eo_do_super. * * @see #eo_destructor */ -#define eo_constructor() EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR) +EAPI void eo_constructor(void); /** - * @def eo_destructor * @brief Call the object's destructor. * * Should not be used with #eo_do. Only use it with #eo_do_super. * * @see #eo_constructor */ -#define eo_destructor() EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR) +EAPI void eo_destructor(void); /** * @addtogroup Eo_Events Eo's Event Handling @@ -1316,47 +1182,42 @@ struct _Eo_Callback_Array_Item } /** - * @def eo_event_callback_forwarder_add * @brief Add an event callback forwarder for an event and an object. * @param[in] desc The description of the event to listen to. * @param[in] new_obj The object to emit events from. * * @see eo_event_callback_forwarder_del() */ -#define eo_event_callback_forwarder_add(desc, new_obj) EO_BASE_ID(EO_BASE_SUB_ID_EVENT_CALLBACK_FORWARDER_ADD), EO_TYPECHECK(const Eo_Event_Description *, desc), EO_TYPECHECK(Eo *, new_obj) +EAPI void eo_event_callback_forwarder_add(const Eo_Event_Description *desc, Eo *new_obj); /** - * @def eo_event_callback_forwarder_del * @brief Remove an event callback forwarder for an event and an object. * @param[in] desc The description of the event to listen to. * @param[in] new_obj The object to emit events from. * * @see eo_event_callback_forwarder_add() */ -#define eo_event_callback_forwarder_del(desc, new_obj) EO_BASE_ID(EO_BASE_SUB_ID_EVENT_CALLBACK_FORWARDER_DEL), EO_TYPECHECK(const Eo_Event_Description *, desc), EO_TYPECHECK(Eo *, new_obj) +EAPI void eo_event_callback_forwarder_del(const Eo_Event_Description *desc, Eo *new_obj); /** - * @def eo_event_freeze * @brief freeze events of object. * * Prevents event callbacks from being called for the object. * * @see #eo_event_thaw */ -#define eo_event_freeze() EO_BASE_ID(EO_BASE_SUB_ID_EVENT_FREEZE) +EAPI void eo_event_freeze(void); /** - * @def eo_event_thaw * @brief thaw events of object. * * Lets event callbacks be called for the object. * * @see #eo_event_freeze */ -#define eo_event_thaw() EO_BASE_ID(EO_BASE_SUB_ID_EVENT_THAW) +EAPI void eo_event_thaw(void); /** - * @def eo_event_freeze_get * @brief return freeze events of object. * * @param[out] fcount The event freeze count of the object. @@ -1366,10 +1227,9 @@ struct _Eo_Callback_Array_Item * @see #eo_event_freeze * @see #eo_event_thaw */ -#define eo_event_freeze_get(fcount) EO_BASE_ID(EO_BASE_SUB_ID_EVENT_FREEZE_GET), EO_TYPECHECK(int *, fcount) +EAPI int eo_event_freeze_get(void); /** - * @def eo_event_global_freeze * @brief freeze events of object. * * Prevents event callbacks from being called for the object. @@ -1377,10 +1237,9 @@ struct _Eo_Callback_Array_Item * @see #eo_event_freeze * @see #eo_event_global_thaw */ -#define eo_event_global_freeze() EO_BASE_ID(EO_BASE_SUB_ID_EVENT_GLOBAL_FREEZE) +EAPI void eo_event_global_freeze(void); /** - * @def eo_event_global_thaw * @brief thaw events of object. * * Lets event callbacks be called for the object. @@ -1388,10 +1247,9 @@ struct _Eo_Callback_Array_Item * @see #eo_event_thaw * @see #eo_event_global_freeze */ -#define eo_event_global_thaw() EO_BASE_ID(EO_BASE_SUB_ID_EVENT_GLOBAL_THAW) +EAPI void eo_event_global_thaw(void); /** - * @def eo_event_global_freeze_get * @brief return freeze events of object. * * @param[out] fcount The event freeze count of the object. @@ -1402,7 +1260,7 @@ struct _Eo_Callback_Array_Item * @see #eo_event_global_freeze * @see #eo_event_global_thaw */ -#define eo_event_global_freeze_get(fcount) EO_BASE_ID(EO_BASE_SUB_ID_EVENT_GLOBAL_FREEZE_GET), EO_TYPECHECK(int *, fcount) +EAPI int eo_event_global_freeze_get(void); /** * @def eo_event_callback_add(obj, desc, cb, data) @@ -1420,7 +1278,6 @@ struct _Eo_Callback_Array_Item EO_CALLBACK_PRIORITY_DEFAULT, cb, data) /** - * @def eo_event_callback_priority_add * @brief Add a callback for an event with a specific priority. * @param[in] desc The description of the event to listen to. * @param[in] priority The priority of the callback. @@ -1431,17 +1288,21 @@ struct _Eo_Callback_Array_Item * * @see #eo_event_callback_add */ -#define eo_event_callback_priority_add(desc, priority, cb, data) EO_BASE_ID(EO_BASE_SUB_ID_EVENT_CALLBACK_PRIORITY_ADD), EO_TYPECHECK(const Eo_Event_Description *, desc), EO_TYPECHECK(Eo_Callback_Priority, priority), EO_TYPECHECK(Eo_Event_Cb, cb), EO_TYPECHECK(const void *, data) +EAPI void eo_event_callback_priority_add(const Eo_Event_Description *desc, + Eo_Callback_Priority priority, + Eo_Event_Cb func, + const void *user_data); /** - * @def eo_event_callback_del * @brief Del a callback with a specific data associated to it for an event. * @param[in] desc The description of the event to listen to. * @param[in] func the callback to delete. * @param[in] user_data The data to compare. * */ -#define eo_event_callback_del(desc, func, user_data) EO_BASE_ID(EO_BASE_SUB_ID_EVENT_CALLBACK_DEL), EO_TYPECHECK(const Eo_Event_Description *, desc), EO_TYPECHECK(Eo_Event_Cb, func), EO_TYPECHECK(const void *, user_data) +EAPI void eo_event_callback_del(const Eo_Event_Description *desc, + Eo_Event_Cb func, + const void *user_data); /** * @def eo_event_callback_array_add(obj, desc, cb, data) @@ -1458,7 +1319,6 @@ struct _Eo_Callback_Array_Item EO_CALLBACK_PRIORITY_DEFAULT, data) /** - * @def eo_event_callback_array_priority_add * @brief Add a callback array for an event with a specific priority. * @param[in] array an #Eo_Callback_Array_Item of events to listen to. * @param[in] priority The priority of the callback. @@ -1468,25 +1328,26 @@ struct _Eo_Callback_Array_Item * * @see #eo_event_callback_add */ -#define eo_event_callback_array_priority_add(array, priority, data) EO_BASE_ID(EO_BASE_SUB_ID_EVENT_CALLBACK_ARRAY_PRIORITY_ADD), EO_TYPECHECK(const Eo_Callback_Array_Item *, array), EO_TYPECHECK(Eo_Callback_Priority, priority), EO_TYPECHECK(const void *, data) +EAPI void eo_event_callback_array_priority_add(const Eo_Callback_Array_Item *array, + Eo_Callback_Priority priority, + const void *user_data); /** - * @def eo_event_callback_array_del * @brief Del a callback array with a specific data associated to it for an event. * @param[in] array an #Eo_Callback_Array_Item of events to listen to. * @param[in] user_data The data to compare. * */ -#define eo_event_callback_array_del(array, user_data) EO_BASE_ID(EO_BASE_SUB_ID_EVENT_CALLBACK_ARRAY_DEL), EO_TYPECHECK(const Eo_Callback_Array_Item *, array), EO_TYPECHECK(const void *, user_data) +EAPI void eo_event_callback_array_del(const Eo_Callback_Array_Item *array, + const void *user_data); /** - * @def eo_event_callback_call * @brief Call the callbacks for an event of an object. * @param[in] desc The description of the event to call. * @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. */ -#define eo_event_callback_call(desc, event_info, aborted) EO_BASE_ID(EO_BASE_SUB_ID_EVENT_CALLBACK_CALL), EO_TYPECHECK(const Eo_Event_Description *, desc), EO_TYPECHECK(const void *, event_info), EO_TYPECHECK(Eina_Bool *, aborted) +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 7842aa8a91..d207f206c0 100644 --- a/src/lib/eo/eo.c +++ b/src/lib/eo/eo.c @@ -28,7 +28,7 @@ static inline void *_eo_data_scope_get(const _Eo_Object *obj, const _Eo_Class *k static inline void *_eo_data_xref_internal(const char *file, int line, _Eo_Object *obj, const _Eo_Class *klass, const _Eo_Object *ref_obj); static inline void _eo_data_xunref_internal(_Eo_Object *obj, void *data, const _Eo_Object *ref_obj); static const _Eo_Class *_eo_op_class_get(Eo_Op op); -static const Eo_Op_Description *_eo_op_id_desc_get(Eo_Op op); +static const char * _eo_op_id_name_get(Eo_Op op); /* Start of Dich */ @@ -96,22 +96,27 @@ _dich_func_get(const _Eo_Class *klass, Eo_Op op) return &chain1->funcs[DICH_CHAIN_LAST(op)]; } -static inline void +static inline Eina_Bool _dich_func_set(_Eo_Class *klass, Eo_Op op, eo_op_func_type func) { + op_type_funcs *fsrc; size_t idx1 = DICH_CHAIN1(op); Dich_Chain1 *chain1 = &klass->chain[idx1]; _dich_chain_alloc(chain1); - if (chain1->funcs[DICH_CHAIN_LAST(op)].src == klass) + fsrc = &chain1->funcs[DICH_CHAIN_LAST(op)]; + if (fsrc->src == klass) { const _Eo_Class *op_kls = _eo_op_class_get(op); - const Eo_Op_Description *op_desc = _eo_op_id_desc_get(op); - ERR("Already set function for op 0x%x (%s:%s). Overriding with func %p", - op, op_kls->desc->name, op_desc->name, func); + const char *op_name = _eo_op_id_name_get(op); + ERR("Class '%s': Overriding func %p for op %d (%s:'%s') with %p.", + klass->desc->name, fsrc->func, op, op_kls->desc->name, op_name, func); + return EINA_FALSE; } - chain1->funcs[DICH_CHAIN_LAST(op)].func = func; - chain1->funcs[DICH_CHAIN_LAST(op)].src = klass; + fsrc->func = func; + fsrc->src = klass; + + return EINA_TRUE; } static inline void @@ -131,20 +136,16 @@ _dich_func_clean_all(_Eo_Class *klass) /* END OF DICH */ -static const Eo_Op_Description noop_desc = - EO_OP_DESCRIPTION(EO_NOOP, "No operation."); - - static inline Eina_Bool -_eo_is_a_class(const Eo *obj_id) +_eo_is_a_class(const Eo *eo_id) { Eo_Id oid; #ifdef HAVE_EO_ID - oid = (Eo_Id) obj_id; + oid = (Eo_Id) eo_id; #else - /* fortunately EO_OBJ_POINTER_RETURN* will handle NULL obj_id */ - if (!obj_id) return EINA_FALSE; - oid = ((Eo_Base *) obj_id)->id; + /* fortunately EO_OBJ_POINTER_RETURN* will handle NULL eo_id */ + if (!eo_id) return EINA_FALSE; + oid = ((Eo_Base *) eo_id)->id; #endif return (((oid >> REF_TAG_SHIFT) & 0x1) == 0x0); } @@ -186,18 +187,24 @@ _eo_op_class_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 Eo_Op_Description *op_descs; if (op == EO_NOOP) - return &noop_desc; + return NULL; klass = _eo_op_class_get(op); + DBG("klass %p %s", klass, klass->desc->name); if (klass) { - Eo_Op sub_id = op - klass->base_id; - if (sub_id < klass->desc->ops.count) - return klass->desc->ops.descs + sub_id; + op_descs = klass->desc->ops.descs2; + for (i = 0; i < klass->desc->ops.count; i++) + { + if (op_descs[i].op == op) + return &op_descs[i]; + } } return NULL; @@ -207,10 +214,10 @@ static const char * _eo_op_id_name_get(Eo_Op op) { const Eo_Op_Description *desc = _eo_op_id_desc_get(op); - return (desc) ? desc->name : NULL; + return (desc) ? desc->doc : NULL; } -static inline const _Eo_Class * +static inline const op_type_funcs * _eo_kls_itr_next(const _Eo_Class *orig_kls, const _Eo_Class *cur_klass, Eo_Op op) { const _Eo_Class **kls_itr = NULL; @@ -231,30 +238,586 @@ _eo_kls_itr_next(const _Eo_Class *orig_kls, const _Eo_Class *cur_klass, Eo_Op op kls_itr++; continue; } - return fsrc->src; + return fsrc; } } return NULL; } -static inline const op_type_funcs * -_eo_kls_itr_func_get(const _Eo_Class *cur_klass, Eo_Op op) +/************************************ EO ************************************/ + +EAPI Eo_Hook_Call eo_hook_call_pre = NULL; +EAPI Eo_Hook_Call eo_hook_call_post = NULL; + +// FIXME: Thread Local Storage +#define EO_INVALID_DATA (void *) -1 +#define EO_CALL_STACK_DEPTH 30 + +typedef struct _Eo_Stack_Frame { - const _Eo_Class *klass = cur_klass; + const Eo *eo_id; + union { + _Eo_Object *obj; + const _Eo_Class *kls; + } o; + const _Eo_Class *cur_klass; + void *obj_data; +} Eo_Stack_Frame; + +static Eina_TLS _eo_call_stack_key = 0; + +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 Eo_Call_Stack * +_eo_call_stack_create() +{ + Eo_Call_Stack *stack; + + stack = calloc(1, sizeof(Eo_Call_Stack)); + if (!stack) + return NULL; + + stack->frames = calloc(EO_CALL_STACK_DEPTH, sizeof(Eo_Stack_Frame)); + if (!stack->frames) + { + free(stack); + return NULL; + } + + // first frame is never used + stack->frame_ptr = stack->frames; + stack->last_frame = &stack->frames[EO_CALL_STACK_DEPTH - 1]; + stack->shrink_frame = stack->frames; + + return stack; +} + +static void +_eo_call_stack_free(void *ptr) +{ + Eo_Call_Stack *stack = (Eo_Call_Stack *) ptr; + + if (!stack) return; + + if (stack->frames) + free(stack->frames); + free(stack); +} + +static inline Eo_Call_Stack * +_eo_call_stack_get() +{ + Eo_Call_Stack *stack = eina_tls_get(_eo_call_stack_key); + + if (stack) return stack; + + stack = _eo_call_stack_create(); + if (!stack) + { + EINA_LOG_ERR("Could not alloc eo call stack."); + return NULL; + } + + if (!eina_tls_set(_eo_call_stack_key, stack)) + { + EINA_LOG_ERR("Could not set eo call stack in TLS key."); + _eo_call_stack_free(stack); + return NULL; + } + + return stack; +} + +static inline void +_eo_call_stack_resize(Eo_Call_Stack *stack, Eina_Bool grow) +{ + size_t sz, next_sz; + int frame_offset; + + frame_offset = stack->frame_ptr - stack->frames; + sz = stack->last_frame - stack->frames + 1; + if (grow) + next_sz = sz << 1; + else + next_sz = sz >> 1; + + DBG("resize from %lu to %lu", (long unsigned int)sz, (long unsigned int)next_sz); + stack->frames = realloc(stack->frames, next_sz * sizeof(Eo_Stack_Frame)); + if(!stack->frames) + { + CRI("unable to resize call stack, abort."); + abort(); + } + + stack->frame_ptr = &stack->frames[frame_offset]; + stack->last_frame = &stack->frames[next_sz - 1]; + + if (grow) + frame_offset = (sz >> 1); + if (next_sz == EO_CALL_STACK_DEPTH) + frame_offset = 0; + else + frame_offset = (next_sz >> 1); + stack->shrink_frame = &stack->frames[frame_offset]; +} + +static inline Eina_Bool +_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(Eo_Stack_Frame)); + if (!is_klass) + _eo_ref(fptr->o.obj); + } + else + { + fptr->eo_id = eo_id; + fptr->obj_data = EO_INVALID_DATA; + if (is_klass) + { + EO_CLASS_POINTER_RETURN_VAL(eo_id, _klass, EINA_FALSE); + fptr->o.kls = _klass; + } + else + { + EO_OBJ_POINTER_RETURN_VAL(eo_id, _obj, EINA_FALSE); + fptr->o.obj = _obj; + _eo_ref(_obj); + } + } + + if (is_super) + { + EO_CLASS_POINTER_RETURN_VAL(cur_klass_id, cur_klass, EINA_FALSE); + if (fptr->cur_klass == cur_klass) + fptr->obj_data = EO_INVALID_DATA; + fptr->cur_klass = cur_klass; + } + else + { + fptr->cur_klass = NULL; + } + + return EINA_TRUE; +} + +EAPI Eina_Bool +_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) +{ + Eo_Stack_Frame *fptr, *pfptr; + Eo_Call_Stack *stack = _eo_call_stack_get(); + + if (stack->frame_ptr == stack->last_frame) + _eo_call_stack_resize(stack, EINA_TRUE); + + fptr = stack->frame_ptr; + + pfptr = ((eo_id) && (fptr->eo_id == eo_id) ? fptr : NULL); + fptr++; + + if (!_eo_do_internal(eo_id, cur_klass_id, is_super, fptr, pfptr)) + return EINA_FALSE; + + stack->frame_ptr++; + + return EINA_TRUE; +} + +EAPI void +_eo_do_end(const Eo **eo_id EINA_UNUSED) +{ + 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 = EO_INVALID_DATA; + + if (fptr == stack->frames) + { + CRI("call stack underflow, abort."); + abort(); + } + + stack->frame_ptr--; + + if (fptr == stack->shrink_frame) + _eo_call_stack_resize(stack, EINA_FALSE); +} + +EAPI Eina_Bool +_eo_call_resolve(const char *func_name, const Eo_Op op, Eo_Op_Call_Data *call, const char *file, int line) +{ + 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 = _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; + + /* If we have a current class, we need to itr to the next. */ + if (fptr->cur_klass) + { + func = _eo_kls_itr_next(klass, fptr->cur_klass, op); + + if (!func) + goto end; + + klass = func->src; + } + else + { + func = _dich_func_get(klass, op); + } + + if (EINA_UNLIKELY(func == NULL)) + { + ERR("in %s:%d: you called func '%s' (%d) which is unknown in class '%s'.", + file, line, func_name, op, klass->desc->name); + return EINA_FALSE; + } + + if (EINA_LIKELY(func->func && func->src)) + { + call->func = func->func; + call->klass = _eo_class_id_get(klass); + + if (is_obj) + { + call->obj = (Eo *)fptr->eo_id; + if (func->src == fptr->o.obj->klass) + { + if (fptr->obj_data == EO_INVALID_DATA) + fptr->obj_data = _eo_data_scope_get(fptr->o.obj, func->src); + + call->data = fptr->obj_data; + } + else + call->data = _eo_data_scope_get(fptr->o.obj, func->src); + } + else + { + call->obj = call->klass; + call->data = NULL; + } + + return EINA_TRUE; + } + + if (func->src != NULL) + { + ERR("in %s:%d: you called a pure virtual func '%s' (%d).", + file, line, func_name, op); + return EINA_FALSE; + } + + +end: + /* Try composite objects */ + if (is_obj) + { + const _Eo_Object **comp_itr = fptr->o.obj->composites; + if (!comp_itr) goto end2; + + for (unsigned int i = 0; i < fptr->o.obj->klass->composites_count; i++, comp_itr++) + { + const _Eo_Object *emb_obj = *comp_itr; + + func = _dich_func_get(emb_obj->klass, op); + if (func == NULL) + continue; + + if (EINA_LIKELY(func->func && func->src)) + { + call->obj = _eo_id_get(emb_obj); + call->klass = _eo_class_id_get(emb_obj->klass); + call->func = func->func; + call->data = _eo_data_scope_get(emb_obj, func->src); + + return EINA_TRUE; + } + } + } + +end2: + { + const _Eo_Class *main_klass; + main_klass = (is_obj) ? fptr->o.obj->klass : fptr->o.kls; + + /* If it's a do_super call. */ + if (fptr->cur_klass) + { + ERR("in %s:%d: func '%s' (%d) could not be resolved for class '%s' for super of '%s'.", + file, line, func_name, op, main_klass->desc->name, + fptr->cur_klass->desc->name); + } + else + { + /* we should not be able to take this branch */ + ERR("in %s:%d: func '%s' (%d) could not be resolved for class '%s'.", + file, line, func_name, op, main_klass->desc->name); + } + } + + return EINA_FALSE; +} + + +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 Eo_Op_Description *op_desc; + const Eo_Op_Description *op_descs; + if (klass) { - const op_type_funcs *func = _dich_func_get(klass, op); - - if (func && func->func) + for (kls_itr = klass->mro ; *kls_itr ; kls_itr++) { - return func; + cur_klass = *kls_itr; + imin = 0; + imax = cur_klass->desc->ops.count - 1; + op_descs = cur_klass->desc->ops.descs2; + + while (imax >= imin) + { + imid = (imax + imin) / 2; + op_desc = op_descs + imid; + + if (op_desc->api_func > api_func) + imin = imid + 1; + else if (op_desc->api_func < api_func) + imax = imid - 1; + else + return op_desc; + } + + } + } + + if (extns) + { + for (kls_itr = extns ; *kls_itr ; kls_itr++) + { + cur_klass = *kls_itr; + op_desc = _eo_api_desc_get(api_func, cur_klass, NULL); + if (op_desc) return op_desc; } } return NULL; } +EAPI Eo_Op +_eo_api_op_id_get(const void *api_func, const char *file, int line) +{ + const Eo_Op_Description *desc; + const _Eo_Class *klass; + Eo_Call_Stack *stack = _eo_call_stack_get(); + + Eina_Bool class_ref = _eo_is_a_class(stack->frame_ptr->eo_id); + + if (class_ref) + klass = stack->frame_ptr->o.kls; + else + klass = stack->frame_ptr->o.obj->klass; + + desc = _eo_api_desc_get(api_func, klass, klass->extensions); + + if (desc == NULL) + { + ERR("in %s:%d: unable to resolve %s api func %p.", + file, line, (class_ref ? "class" : "regular"), api_func); + return EO_NOOP; + } + + return desc->op; +} + +static int +eo_api_funcs_cmp(const void *p1, const void *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; +} + +static Eina_Bool +_eo_class_funcs_set(_Eo_Class *klass) +{ + int op_id; + const void *last_api_func; + 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; + + DBG("Set functions for class '%s':%p", klass->desc->name, klass); + + if (!op_descs) return EINA_TRUE; + + 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++) + { + if(op_desc->api_func == NULL) + { + ERR("Class '%s': NULL API not allowed (%d NULL->%p '%s').", + klass->desc->name, op_desc->op, op_desc->func, op_desc->doc); + return EINA_FALSE; + } + + if (op_desc->op == EO_NOOP) + { + if (op_desc->api_func == last_api_func) + { + ERR("Class '%s': API previously defined (%d %p->%p '%s').", + klass->desc->name, op_desc->op, op_desc->api_func, op_desc->func, op_desc->doc); + return EINA_FALSE; + } + op_desc->op = op_id; + op_id++; + } + else if (op_desc->op == EO_OP_OVERRIDE) + { + api_desc = _eo_api_desc_get(op_desc->api_func, klass->parent, klass->extensions); + + if (api_desc == NULL) + { + ERR("Class '%s': Can't find api func description in class hierarchy (%p->%p) (%s).", + klass->desc->name, op_desc->api_func, op_desc->func, op_desc->doc); + return EINA_FALSE; + } + + op_desc->op = api_desc->op; + op_desc->doc = api_desc->doc; + } + + DBG(" %4d %p->%p '%s'", op_desc->op, op_desc->api_func, op_desc->func, op_desc->doc); + + if (!_dich_func_set(klass, op_desc->op, op_desc->func)) + return EINA_FALSE; + + last_api_func = op_desc->api_func; + } + + return EINA_TRUE; +} + +EAPI Eo * +_eo_add_internal_start(const char *file, int line, const Eo_Class *klass_id, Eo *parent_id) +{ + _Eo_Object *obj; + + EO_CLASS_POINTER_RETURN_VAL(klass_id, klass, NULL); + + if (parent_id) + { + EO_OBJ_POINTER_RETURN_VAL(parent_id, parent, NULL); + } + + if (EINA_UNLIKELY(klass->desc->type != EO_CLASS_TYPE_REGULAR)) + { + ERR("in %s:%d: Class '%s' is not instantiate-able. Aborting.", file, line, klass->desc->name); + return NULL; + } + + eina_spinlock_take(&klass->objects.trash_lock); + obj = eina_trash_pop(&klass->objects.trash); + if (obj) + { + memset(obj, 0, klass->obj_size); + klass->objects.trash_count--; + } + else + { + obj = calloc(1, klass->obj_size); + } + eina_spinlock_release(&klass->objects.trash_lock); + + obj->refcount++; + obj->klass = klass; + if (klass->composites_count == 0) + obj->composites = NULL; + else + obj->composites = (const _Eo_Object **) + ((char *) obj + klass->obj_size - (klass->composites_count * sizeof(_Eo_Object *))); + +#ifndef HAVE_EO_ID + EINA_MAGIC_SET((Eo_Base *) obj, EO_EINA_MAGIC); +#endif + Eo_Id eo_id = _eo_id_allocate(obj); + obj->header.id = eo_id; + + _eo_condtor_reset(obj); + + _eo_ref(obj); + + eo_do(_eo_id_get(obj), eo_parent_set(parent_id)); + + return _eo_id_get(obj); +} + +EAPI Eo * +_eo_add_internal_end(const char *file, int line, const Eo *eo_id) +{ + Eo_Stack_Frame *fptr; + Eo_Call_Stack *stack = _eo_call_stack_get(); + + fptr = stack->frame_ptr; + + if ((fptr == NULL) || (fptr->eo_id != eo_id)) + { + ERR("in %s:%d - Something very wrong happend to the call stack.", file, line); + return NULL; + } + + if (!fptr->o.obj->condtor_done || fptr->o.obj->do_error) + { + const _Eo_Class *klass = (fptr->cur_klass) ? + fptr->cur_klass : fptr->o.obj->klass; + ERR("in %s:%d: Object of class '%s' - Not all of the object constructors have been executed.", + file, line, klass->desc->name); + /* 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; + } + + _eo_unref(fptr->o.obj); + + return (Eo *)eo_id; +} + +/*****************************************************************************/ + #define _EO_OP_ERR_NO_OP_PRINT(file, line, op, klass) \ do \ { \ @@ -266,206 +829,16 @@ _eo_kls_itr_func_get(const _Eo_Class *cur_klass, Eo_Op op) } \ while (0) -static inline Eina_Bool -_eo_op_internal(const char *file, int line, Eo_Base *eo_ptr, const _Eo_Class *cur_klass, - Eo_Op_Type op_type, Eo_Op op, va_list *p_list) -{ -#ifdef EO_DEBUG - const Eo_Op_Description *op_desc = _eo_op_id_desc_get(op); - - if (op_desc && (op_type != op_desc->op_type)) - { - if (op_type == EO_OP_TYPE_REGULAR) - { - ERR("in %s:%d: Tried calling a class op '%s' (0x%x) from a non-class context.", - file, line, op_desc->name, op); - } - else - { - ERR("in %s:%d: Tried calling an instance op '%s' (0x%x) from a class context.", - file, line, op_desc->name, op); - } - return EINA_FALSE; - } -#endif - - { - const op_type_funcs *func = _eo_kls_itr_func_get(cur_klass, op); - if (EINA_LIKELY(func != NULL)) - { - void *func_data = NULL; - Eo *calling_obj; - if (op_type == EO_OP_TYPE_REGULAR) - { - func_data = _eo_data_scope_get((_Eo_Object *) eo_ptr, func->src); - calling_obj = _eo_id_get((_Eo_Object *) eo_ptr); - } - else - { - calling_obj = _eo_class_id_get(cur_klass); - } - func->func(calling_obj, func_data, p_list); - return EINA_TRUE; - } - } - - /* Try composite objects */ - if (op_type == EO_OP_TYPE_REGULAR) - { - const _Eo_Object **comp_itr = ((_Eo_Object *) eo_ptr)->composites; - if (!comp_itr) return EINA_FALSE; - - for (unsigned int i = 0; i < ((_Eo_Object *) eo_ptr)->klass->composites_count; i++, comp_itr++) - if (*comp_itr) - { - if (_eo_op_internal(file, line, (Eo_Base *) (*comp_itr), (*comp_itr)->klass, op_type, op, p_list)) - { - return EINA_TRUE; - } - } - } - - return EINA_FALSE; -} - -static inline Eina_Bool -_eo_dov_internal(const char *file, int line, Eo_Base *obj, const _Eo_Class *klass, Eo_Op_Type op_type, va_list *p_list) -{ - Eina_Bool ret = EINA_TRUE; - Eo_Op op = EO_NOOP; - - op = va_arg(*p_list, Eo_Op); - while (op) - { - if (!_eo_op_internal(file, line, obj, klass, op_type, op, p_list)) - { - _EO_OP_ERR_NO_OP_PRINT(file, line, op, klass); - ret = EINA_FALSE; - break; - } - op = va_arg(*p_list, Eo_Op); - } - - return ret; -} - -static inline Eina_Bool -_eo_obj_dov_internal(const char *file, int line, _Eo_Object *obj, va_list *p_list) -{ - Eina_Bool prev_error; - Eina_Bool ret = EINA_TRUE; - - prev_error = obj->do_error; - _eo_ref(obj); - - ret = _eo_dov_internal(file, line, (Eo_Base *) obj, obj->klass, EO_OP_TYPE_REGULAR, p_list); - - if (obj->do_error) - ret = EINA_FALSE; - - obj->do_error = prev_error; - _eo_unref(obj); - - return ret; -} - -static inline Eina_Bool -_eo_class_dov_internal(const char *file, int line, _Eo_Class *klass, va_list *p_list) -{ - return _eo_dov_internal(file, line, (Eo_Base *) klass, klass, EO_OP_TYPE_CLASS, p_list); -} - -EAPI Eina_Bool -eo_do_internal(const char *file, int line, const Eo *obj_id, ...) -{ - Eina_Bool ret = EINA_TRUE; - va_list p_list; - Eina_Bool class_ref = _eo_is_a_class(obj_id); - - if (class_ref) - { - EO_CLASS_POINTER_RETURN_VAL(obj_id, klass, EINA_FALSE); - - va_start(p_list, obj_id); - ret = _eo_class_dov_internal(file, line, klass, &p_list); - va_end(p_list); - } - else - { - EO_OBJ_POINTER_RETURN_VAL(obj_id, obj, EINA_FALSE); - - va_start(p_list, obj_id); - ret = _eo_obj_dov_internal(file, line, obj, &p_list); - va_end(p_list); - } - - return ret; -} - -EAPI Eina_Bool -eo_vdo_internal(const char *file, int line, const Eo *obj_id, va_list *ops) -{ - Eina_Bool class_ref = _eo_is_a_class(obj_id); - - if (class_ref) - { - EO_CLASS_POINTER_RETURN_VAL(obj_id, klass, EINA_FALSE); - return _eo_class_dov_internal(file, line, klass, ops); - } - else - { - EO_OBJ_POINTER_RETURN_VAL(obj_id, obj, EINA_FALSE); - return _eo_obj_dov_internal(file, line, obj, ops); - } -} - -EAPI Eina_Bool -eo_do_super_internal(const char *file, int line, const Eo *obj_id, const Eo_Class *cur_klass_id, Eo_Op op, ...) -{ - const _Eo_Class *nklass; - Eina_Bool op_ret = EINA_TRUE; - Eina_Bool ret = EINA_TRUE; - va_list p_list; - - EO_CLASS_POINTER_RETURN_VAL(cur_klass_id, cur_klass, EINA_FALSE); - - if (_eo_is_a_class(obj_id)) - { - EO_CLASS_POINTER_RETURN_VAL(obj_id, klass, EINA_FALSE); - - va_start(p_list, op); - nklass = _eo_kls_itr_next(klass, cur_klass, op); - op_ret = _eo_op_internal(file, line, (Eo_Base *) klass, nklass, EO_OP_TYPE_CLASS, op, &p_list); - va_end(p_list); - } - else - { - EO_OBJ_POINTER_RETURN_VAL(obj_id, obj, EINA_FALSE); - - va_start(p_list, op); - nklass = _eo_kls_itr_next(obj->klass, cur_klass, op); - op_ret = _eo_op_internal(file, line, (Eo_Base *) obj, nklass, EO_OP_TYPE_REGULAR, op, &p_list); - if (obj->do_error) - ret = EINA_FALSE; - va_end(p_list); - } - - if (!op_ret) - _EO_OP_ERR_NO_OP_PRINT(file, line, op, nklass); - - return (ret & op_ret); -} - EAPI const Eo_Class * -eo_class_get(const Eo *obj_id) +eo_class_get(const Eo *eo_id) { - if (_eo_is_a_class(obj_id)) + if (_eo_is_a_class(eo_id)) { - EO_CLASS_POINTER_RETURN_VAL(obj_id, _klass, NULL); + EO_CLASS_POINTER_RETURN_VAL(eo_id, _klass, NULL); return eo_class_class_get(); } - EO_OBJ_POINTER_RETURN_VAL(obj_id, obj, NULL); + EO_OBJ_POINTER_RETURN_VAL(eo_id, obj, NULL); if (obj->klass) return _eo_class_id_get(obj->klass); @@ -473,18 +846,18 @@ eo_class_get(const Eo *obj_id) } EAPI const char * -eo_class_name_get(const Eo_Class *obj_id) +eo_class_name_get(const Eo_Class *eo_id) { const _Eo_Class *klass; - if (_eo_is_a_class(obj_id)) + if (_eo_is_a_class(eo_id)) { - EO_CLASS_POINTER_RETURN_VAL(obj_id, _klass, NULL); + EO_CLASS_POINTER_RETURN_VAL(eo_id, _klass, NULL); klass = _klass; } else { - EO_OBJ_POINTER_RETURN_VAL(obj_id, obj, NULL); + EO_OBJ_POINTER_RETURN_VAL(eo_id, obj, NULL); klass = obj->klass; } @@ -498,9 +871,6 @@ _eo_class_base_op_init(_Eo_Class *klass) klass->base_id = _eo_ops_last_id; - if (desc->ops.base_op_id) - *(desc->ops.base_op_id) = klass->base_id; - _eo_ops_last_id += desc->ops.count + 1; klass->chain_size = DICH_CHAIN1(_eo_ops_last_id) + 1; @@ -632,46 +1002,12 @@ static void _eo_class_constructor(_Eo_Class *klass) { if (klass->constructed) - return; + return; klass->constructed = EINA_TRUE; if (klass->desc->class_constructor) - klass->desc->class_constructor(_eo_class_id_get(klass)); -} - -EAPI void -eo_class_funcs_set(Eo_Class *klass_id, const Eo_Op_Func_Description *func_descs) -{ - EO_CLASS_POINTER_RETURN(klass_id, klass); - - const Eo_Op_Func_Description *itr; - itr = func_descs; - if (itr) - { - for ( ; itr->op_type != EO_OP_TYPE_INVALID ; itr++) - { - const Eo_Op_Description *op_desc = _eo_op_id_desc_get(itr->op); - - if (EINA_UNLIKELY(!op_desc || (itr->op == EO_NOOP))) - { - ERR("Setting implementation for non-existent op 0x%x for class '%s'. Func index: %lu", itr->op, klass->desc->name, (unsigned long) (itr - func_descs)); - } - else if (EINA_LIKELY(itr->op_type == op_desc->op_type)) - { - _dich_func_set(klass, itr->op, itr->func); - } - else - { - ERR("Set function's op type (0x%x) is different than the one in the op description (%d) for op '%s:%s'. Func index: %lu", - itr->op_type, - (op_desc) ? op_desc->op_type : EO_OP_TYPE_REGULAR, - klass->desc->name, - (op_desc) ? op_desc->name : NULL, - (unsigned long) (itr - func_descs)); - } - } - } + klass->desc->class_constructor(_eo_class_id_get(klass)); } static void @@ -699,59 +1035,9 @@ eo_class_free(_Eo_Class *klass) free(klass); } -/* DEVCHECK */ -static Eina_Bool -_eo_class_check_op_descs(const Eo_Class_Description *desc) -{ - const Eo_Op_Description *itr; - size_t i; - - if (desc->ops.count > 0) - { - if (!desc->ops.base_op_id) - { - ERR("Class '%s' has a non-zero ops count, but base_id is NULL.", - desc->name); - return EINA_FALSE; - } - - if (!desc->ops.descs) - { - ERR("Class '%s' has a non-zero ops count, but there are no descs.", - desc->name); - return EINA_FALSE; - } - } - - itr = desc->ops.descs; - for (i = 0 ; i < desc->ops.count ; i++, itr++) - { - if (itr->sub_op != i) - { - if (itr->name) - { - ERR("Wrong order in Ops description for class '%s'. Expected 0x%lx and got 0x%lx", desc->name, (unsigned long) i, (unsigned long) itr->sub_op); - } - else - { - ERR("Found too few Ops description for class '%s'. Expected 0x%lx descriptions, but found 0x%lx.", desc->name, (unsigned long) desc->ops.count, (unsigned long) i); - } - return EINA_FALSE; - } - } - - if (itr && itr->name) - { - ERR("Found extra Ops description for class '%s'. Expected %lu descriptions, but found more.", desc->name, (unsigned long) desc->ops.count); - return EINA_FALSE; - } - - return EINA_TRUE; -} - /* Not really called, just used for the ptr... */ static void -_eo_class_isa_func(Eo *obj_id EINA_UNUSED, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +_eo_class_isa_func(Eo *eo_id EINA_UNUSED, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) { /* Do nonthing. */ } @@ -767,11 +1053,6 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...) EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL); EINA_SAFETY_ON_NULL_RETURN_VAL(desc->name, NULL); - DBG("Started building class '%s'", desc->name); - - if (!_eo_class_check_op_descs(desc)) - return NULL; - _Eo_Class *parent = _eo_class_pointer_get(parent_id); #ifndef HAVE_EO_ID if (parent && !EINA_MAGIC_CHECK((Eo_Base *) parent, EO_CLASS_EINA_MAGIC)) @@ -972,6 +1253,7 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...) } _eo_class_base_op_init(klass); + /* Flatten the function array */ { const _Eo_Class **mro_itr = klass->mro; @@ -1008,6 +1290,15 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...) } } + if (!_eo_class_funcs_set(klass)) + { + eina_spinlock_free(&klass->objects.trash_lock); + eina_spinlock_free(&klass->iterators.trash_lock); + _dich_func_clean_all(klass); + free(klass); + return NULL; + } + eina_spinlock_take(&_eo_class_creation_lock); klass->header.id = ++_eo_classes_last_id | MASK_CLASS_TAG; { @@ -1033,9 +1324,9 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent_id, ...) } EAPI Eina_Bool -eo_isa(const Eo *obj_id, const Eo_Class *klass_id) +eo_isa(const Eo *eo_id, const Eo_Class *klass_id) { - EO_OBJ_POINTER_RETURN_VAL(obj_id, obj, EINA_FALSE); + EO_OBJ_POINTER_RETURN_VAL(eo_id, obj, EINA_FALSE); EO_CLASS_POINTER_RETURN_VAL(klass_id, klass, EINA_FALSE); const op_type_funcs *func = _dich_func_get(obj->klass, klass->base_id + klass->desc->ops.count); @@ -1045,103 +1336,6 @@ eo_isa(const Eo *obj_id, const Eo_Class *klass_id) return (func && (func->func == _eo_class_isa_func)); } -// A little bit hacky, but does the job -static void -_eo_parent_internal_set(_Eo_Object *obj, ...) -{ - va_list p_list; - - va_start(p_list, obj); - _eo_op_internal(__FILE__, __LINE__, (Eo_Base *) obj, obj->klass, - EO_OP_TYPE_REGULAR, EO_BASE_ID(EO_BASE_SUB_ID_PARENT_SET), - &p_list); - va_end(p_list); -} - -EAPI Eo * -eo_add_internal(const char *file, int line, const Eo_Class *klass_id, Eo *parent_id, ...) -{ - Eina_Bool do_err; - _Eo_Object *obj; - EO_CLASS_POINTER_RETURN_VAL(klass_id, klass, NULL); - - if (parent_id) - { - EO_OBJ_POINTER_RETURN_VAL(parent_id, parent, NULL); - } - - if (EINA_UNLIKELY(klass->desc->type != EO_CLASS_TYPE_REGULAR)) - { - ERR("in %s:%d: Class '%s' is not instantiate-able. Aborting.", file, line, klass->desc->name); - return NULL; - } - - eina_spinlock_take(&klass->objects.trash_lock); - obj = eina_trash_pop(&klass->objects.trash); - if (obj) - { - memset(obj, 0, klass->obj_size); - klass->objects.trash_count--; - } - else - { - obj = calloc(1, klass->obj_size); - } - eina_spinlock_release(&klass->objects.trash_lock); - - obj->refcount++; - obj->klass = klass; - if (klass->composites_count == 0) - obj->composites = NULL; - else - obj->composites = (const _Eo_Object **) - ((char *) obj + klass->obj_size - (klass->composites_count * sizeof(_Eo_Object *))); - -#ifndef HAVE_EO_ID - EINA_MAGIC_SET((Eo_Base *) obj, EO_EINA_MAGIC); -#endif - Eo_Id obj_id = _eo_id_allocate(obj); - obj->header.id = obj_id; - - _eo_condtor_reset(obj); - - _eo_ref(obj); - - _eo_parent_internal_set(obj, parent_id); - - /* Run the relevant do stuff. */ - { - va_list p_list; - va_start(p_list, parent_id); - do_err = !_eo_obj_dov_internal(file, line, obj, &p_list); - va_end(p_list); - } - - if (EINA_UNLIKELY(do_err)) - { - ERR("in %s:%d, Object of class '%s' - One of the object constructors have failed.", - file, line, klass->desc->name); - goto fail; - } - - if (!obj->condtor_done) - { - ERR("in %s:%d: Object of class '%s' - Not all of the object constructors have been executed.", - file, line, klass->desc->name); - goto fail; - } - - _eo_unref(obj); - - return _eo_id_get(obj); - -fail: - /* Unref twice, once for the ref above, and once for the basic object ref. */ - _eo_unref(obj); - _eo_unref(obj); - return NULL; -} - EAPI Eo * eo_xref_internal(const char *file, int line, Eo *obj_id, const Eo *ref_obj_id) { @@ -1213,6 +1407,7 @@ eo_unref(const Eo *obj_id) EAPI void eo_del(const Eo *obj) { + EO_OBJ_POINTER_RETURN(obj, _obj); eo_do((Eo *) obj, eo_parent_set(NULL)); eo_unref(obj); } @@ -1230,7 +1425,7 @@ eo_error_set_internal(const Eo *obj_id, const char *file, int line) { EO_OBJ_POINTER_RETURN(obj_id, obj); - ERR("Error with obj '%p' at %s:%d", obj, file, line); + ERR("Error with obj '%p' at %s:%d.", obj, file, line); obj->do_error = EINA_TRUE; } @@ -1370,7 +1565,7 @@ eo_data_scope_get(const Eo *obj_id, const Eo_Class *klass_id) #ifdef EO_DEBUG if (!ret && (klass->desc->data_size == 0)) { - ERR("Tried getting data of class '%s', but it has none..", klass->desc->name); + ERR("Tried getting data of class '%s', but it has none.", klass->desc->name); } #endif @@ -1403,7 +1598,7 @@ eo_data_xref_internal(const char *file, int line, const Eo *obj_id, const Eo_Cla #ifdef EO_DEBUG if (klass && !ret && (klass->desc->data_size == 0)) { - ERR("Tried getting data of class '%s', but it has none..", klass->desc->name); + ERR("Tried getting data of class '%s', but it has none.", klass->desc->name); } #endif @@ -1436,7 +1631,7 @@ eo_init(void) _eo_log_dom = eina_log_domain_register(log_dom, EINA_COLOR_LIGHTBLUE); if (_eo_log_dom < 0) { - EINA_LOG_ERR("Could not register log domain: %s", log_dom); + EINA_LOG_ERR("Could not register log domain: %s.", log_dom); return EINA_FALSE; } @@ -1465,6 +1660,18 @@ eo_init(void) /* bootstrap EO_CLASS_CLASS */ (void) eo_class_class_get(); + if (_eo_call_stack_key != 0) + WRN("_eo_call_stack_key already set, this should not happen."); + else + { + 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; + + } + } + return EINA_TRUE; } @@ -1492,6 +1699,9 @@ eo_shutdown(void) eina_spinlock_free(&_eo_class_creation_lock); + if (_eo_call_stack_key != 0) + eina_tls_free(_eo_call_stack_key); + _eo_free_ids_tables(); eina_log_domain_unregister(_eo_log_dom); @@ -1532,6 +1742,7 @@ eo_composite_attach(Eo *comp_obj_id, Eo *parent_id) comp_obj->composite = EINA_TRUE; *comp_dst = comp_obj; + eo_do(comp_obj_id, eo_parent_set(parent_id)); return EINA_TRUE; diff --git a/src/lib/eo/eo_base.eo b/src/lib/eo/eo_base.eo index 376ba38415..d3980544b2 100644 --- a/src/lib/eo/eo_base.eo +++ b/src/lib/eo/eo_base.eo @@ -1,5 +1,7 @@ abstract Eo_Base () { + eo_prefix: eo; + constructors { constructor { /*@ Call the object's constructor. @@ -75,15 +77,15 @@ Prevents event callbacks from being called for the object. */ /*@ Call the object's destructor. Should not be used with #eo_do. Only use it with #eo_do_super. */ } - data_set { + key_data_set { /*@ Set generic data to object. */ params { @in const char* key; /*@ the key associated with the data */ @in const void* data; /*@ the data to set */ - @in eo_base_data_free_func free_func; /*@ the func to free data with (NULL means */ + @in eo_key_data_free_func free_func; /*@ the func to free data with (NULL means */ } } - data_get { + key_data_get { /*@ Get generic data from object. */ params { @in const char* key; /*@ the key associated with the data */ @@ -102,7 +104,7 @@ Should not be used with #eo_do. Only use it with #eo_do_super. */ /*@ thaw events of object. Lets event callbacks be called for the object. */ } - data_del { + key_data_del { /*@ Del generic data from object. */ params { @in const char* key; /*@ the key associated with the data */ diff --git a/src/lib/eo/eo_base_class.c b/src/lib/eo/eo_base_class.c index c83b19bb23..b1bd8b2673 100644 --- a/src/lib/eo/eo_base_class.c +++ b/src/lib/eo/eo_base_class.c @@ -8,8 +8,6 @@ #include "eo_ptr_indirection.h" #include "eo_private.h" -EAPI Eo_Op EO_BASE_BASE_ID = 0; - static int event_freeze_count = 0; typedef struct _Eo_Callback_Description Eo_Callback_Description; @@ -33,7 +31,7 @@ typedef struct EINA_INLIST; Eina_Stringshare *key; void *data; - eo_base_data_free_func free_func; + eo_key_data_free_func free_func; } Eo_Generic_Data_Node; static void @@ -61,19 +59,16 @@ _eo_generic_data_del_all(Private_Data *pd) } static void -_data_set(Eo *obj, void *class_data, va_list *list) +_data_set(Eo *obj, void *class_data, + const char *key, const void *data, eo_key_data_free_func free_func) { Private_Data *pd = class_data; - EO_PARAMETER_GET(const char *, key, list); - EO_PARAMETER_GET(const void *, data, list); - EO_PARAMETER_GET(eo_base_data_free_func, free_func, list); - Eo_Generic_Data_Node *node; if (!key) return; - eo_do(obj, eo_base_data_del(key)); + eo_do(obj, eo_key_data_del(key); ); node = malloc(sizeof(Eo_Generic_Data_Node)); if (!node) return; @@ -83,21 +78,17 @@ _data_set(Eo *obj, void *class_data, va_list *list) pd->generic_data = eina_inlist_prepend(pd->generic_data, EINA_INLIST_GET(node)); } +EAPI EO_VOID_FUNC_BODYV(eo_key_data_set, EO_FUNC_CALL(key, data, free_func), + const char *key, const void *data, eo_key_data_free_func free_func); -static void -_data_get(Eo *obj EINA_UNUSED, void *class_data, va_list *list) +static void * +_data_get(Eo *obj EINA_UNUSED, void *class_data, const char *key) { /* We don't really change it... */ Eo_Generic_Data_Node *node; Private_Data *pd = (Private_Data *) class_data; - EO_PARAMETER_GET(const char *, key, list); - EO_PARAMETER_GET(void **, data, list); - - if (!data) return; - *data = NULL; - - if (!key) return; + if (!key) return NULL; EINA_INLIST_FOREACH(pd->generic_data, node) { @@ -105,21 +96,21 @@ _data_get(Eo *obj EINA_UNUSED, void *class_data, va_list *list) { pd->generic_data = eina_inlist_promote(pd->generic_data, EINA_INLIST_GET(node)); - *data = node->data; - return; + return node->data; } } + + return NULL; } +EAPI EO_FUNC_BODYV(eo_key_data_get, void*, NULL, EO_FUNC_CALL(key), const char *key); static void -_parent_set(Eo *obj, void *class_data, va_list *list) +_parent_set(Eo *obj, void *class_data, Eo *parent_id) { Private_Data *pd = (Private_Data *) class_data; - EO_PARAMETER_GET(Eo *, parent_id, list); - if (pd->parent == parent_id) - return ; + return; if (eo_composite_is(obj) && pd->parent) { @@ -130,11 +121,11 @@ _parent_set(Eo *obj, void *class_data, va_list *list) { Private_Data *old_parent_pd; - old_parent_pd = eo_data_scope_get(pd->parent, EO_BASE_CLASS); + old_parent_pd = eo_data_scope_get(pd->parent, EO_CLASS); if (old_parent_pd) { old_parent_pd->children = eina_list_remove(old_parent_pd->children, - obj); + obj); } else { @@ -149,7 +140,7 @@ _parent_set(Eo *obj, void *class_data, va_list *list) if (parent_id) { Private_Data *parent_pd = NULL; - parent_pd = eo_data_scope_get(parent_id, EO_BASE_CLASS); + parent_pd = eo_data_scope_get(parent_id, EO_CLASS); if (EINA_LIKELY(parent_pd != NULL)) { @@ -170,18 +161,16 @@ _parent_set(Eo *obj, void *class_data, va_list *list) pd->parent = NULL; } } +EAPI EO_VOID_FUNC_BODYV(eo_parent_set, EO_FUNC_CALL(parent_id), Eo *parent_id); -static void -_parent_get(Eo *obj EINA_UNUSED, void *class_data, va_list *list) +static Eo * +_parent_get(Eo *obj EINA_UNUSED, void *class_data) { Private_Data *pd = (Private_Data *) class_data; - EO_PARAMETER_GET(Eo **, parent_id, list); - - if (!parent_id) return ; - *parent_id = pd->parent; + return pd->parent; } - +EAPI EO_FUNC_BODY(eo_parent_get, Eo *, NULL); /* Children accessor */ typedef struct _Eo_Children_Iterator Eo_Children_Iterator; @@ -191,7 +180,6 @@ struct _Eo_Children_Iterator Eina_List *current; _Eo_Object *obj; Eo *obj_id; - }; static Eina_Bool @@ -231,65 +219,63 @@ _eo_children_iterator_free(Eo_Children_Iterator *it) free(it); } eina_spinlock_release(&klass->iterators.trash_lock); - + _eo_unref(obj); } -static void -_children_iterator_new(Eo *obj_id, void *class_data, va_list *list) +static Eina_Iterator * +_children_iterator_new(Eo *obj_id, void *class_data) { Private_Data *pd = class_data; _Eo_Class *klass; + Eo_Children_Iterator *it; - EO_PARAMETER_GET(Eo_Children_Iterator **, it, list); - EO_OBJ_POINTER_RETURN(obj_id, obj); + EO_OBJ_POINTER_RETURN_VAL(obj_id, obj, NULL); - if (!it) return ; - *it = NULL; - - if (!pd->children) return ; + if (!pd->children) return NULL; klass = (_Eo_Class *) obj->klass; eina_spinlock_take(&klass->iterators.trash_lock); - *it = eina_trash_pop(&klass->iterators.trash); - if (*it) + it = eina_trash_pop(&klass->iterators.trash); + if (it) { klass->iterators.trash_count--; - memset(*it, 0, sizeof (Eo_Children_Iterator)); + memset(it, 0, sizeof (Eo_Children_Iterator)); } else { - *it = calloc(1, sizeof (Eo_Children_Iterator)); + it = calloc(1, sizeof (Eo_Children_Iterator)); } eina_spinlock_release(&klass->iterators.trash_lock); - if (!*it) return ; + if (!it) return NULL; - EINA_MAGIC_SET(&(*it)->iterator, EINA_MAGIC_ITERATOR); - (*it)->current = obj->children; - (*it)->obj = _eo_ref(obj); - (*it)->obj_id = obj_id; + EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR); + it->current = obj->children; + it->obj = _eo_ref(obj); + it->obj_id = obj_id; - (*it)->iterator.next = FUNC_ITERATOR_NEXT(_eo_children_iterator_next); - (*it)->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(_eo_children_iterator_container); - (*it)->iterator.free = FUNC_ITERATOR_FREE(_eo_children_iterator_free); + it->iterator.next = FUNC_ITERATOR_NEXT(_eo_children_iterator_next); + it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(_eo_children_iterator_container); + it->iterator.free = FUNC_ITERATOR_FREE(_eo_children_iterator_free); + + return (Eina_Iterator *)it; } +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, - va_list *data EINA_UNUSED) +_dbg_info_get(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, Eo_Dbg_Info *root_node EINA_UNUSED) { /* No info required in the meantime */ return; } +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, va_list *list) +_data_del(Eo *obj EINA_UNUSED, void *class_data, const char *key) { Eo_Generic_Data_Node *node; Private_Data *pd = class_data; - EO_PARAMETER_GET(const char *, key, list); - if (!key) return; EINA_INLIST_FOREACH(pd->generic_data, node) @@ -303,6 +289,7 @@ _data_del(Eo *obj EINA_UNUSED, void *class_data, va_list *list) } } } +EAPI EO_VOID_FUNC_BODYV(eo_key_data_del, EO_FUNC_CALL(key), const char *key); /* Weak reference. */ @@ -314,41 +301,38 @@ _wref_count(Private_Data *pd) return 0; Eo ***itr; - for (itr = pd->wrefs ; *itr ; itr++) + for (itr = pd->wrefs; *itr; itr++) count++; return count; } static void -_wref_add(Eo *obj, void *class_data, va_list *list) +_wref_add(Eo *obj, void *class_data, Eo **wref) { Private_Data *pd = (Private_Data *) class_data; size_t count; Eo ***tmp; - EO_PARAMETER_GET(Eo **, wref, list); - count = _wref_count(pd); count += 1; /* New wref. */ tmp = realloc(pd->wrefs, sizeof(*pd->wrefs) * (count + 1)); - if (!tmp) return ; + if (!tmp) return; pd->wrefs = tmp; pd->wrefs[count - 1] = wref; pd->wrefs[count] = NULL; *wref = obj; } +EAPI EO_VOID_FUNC_BODYV(eo_wref_add, EO_FUNC_CALL(wref), Eo **wref); static void -_wref_del(Eo *obj, void *class_data, va_list *list) +_wref_del(Eo *obj, void *class_data, Eo **wref) { Private_Data *pd = (Private_Data *) class_data; size_t count; - EO_PARAMETER_GET(Eo **, wref, list); - if (*wref != obj) { ERR("Wref is a weak ref to %p, while this function was called on %p.", @@ -368,7 +352,7 @@ _wref_del(Eo *obj, void *class_data, va_list *list) { Eo ***itr; - for (itr = pd->wrefs ; *itr ; itr++) + for (itr = pd->wrefs; *itr; itr++) { if (*itr == wref) { @@ -390,7 +374,7 @@ _wref_del(Eo *obj, void *class_data, va_list *list) Eo ***tmp; // No count--; because of the NULL that is not included in the count. */ tmp = realloc(pd->wrefs, sizeof(*pd->wrefs) * count); - if (!tmp) return ; + if (!tmp) return; pd->wrefs = tmp; pd->wrefs[count - 1] = NULL; } @@ -402,6 +386,7 @@ _wref_del(Eo *obj, void *class_data, va_list *list) *wref = NULL; } +EAPI EO_VOID_FUNC_BODYV(eo_wref_del, EO_FUNC_CALL(wref), Eo **wref); static inline void _wref_destruct(Private_Data *pd) @@ -410,7 +395,7 @@ _wref_destruct(Private_Data *pd) if (!pd->wrefs) return; - for (itr = pd->wrefs ; *itr ; itr++) + for (itr = pd->wrefs; *itr; itr++) { **itr = NULL; } @@ -445,11 +430,13 @@ struct _Eo_Callback_Description static void _eo_callback_remove(Private_Data *pd, Eo_Callback_Description *cb) { - Eo_Callback_Description *itr, *pitr = NULL; + Eo_Callback_Description *itr, *pitr; - itr = pd->callbacks; + itr = pitr = pd->callbacks; + if (pd->callbacks == cb) + pd->callbacks = cb->next; - for ( ; itr ; ) + for ( ; itr; ) { Eo_Callback_Description *titr = itr; itr = itr->next; @@ -460,10 +447,6 @@ _eo_callback_remove(Private_Data *pd, Eo_Callback_Description *cb) { pitr->next = titr->next; } - else - { - pd->callbacks = titr->next; - } free(titr); } else @@ -485,7 +468,7 @@ _eo_callback_remove_all(Private_Data *pd) } } -static inline void +static void _eo_callbacks_clear(Private_Data *pd) { Eo_Callback_Description *cb = NULL; @@ -500,7 +483,7 @@ _eo_callbacks_clear(Private_Data *pd) pd->deletions_waiting = EINA_FALSE; - for (cb = pd->callbacks ; cb ; ) + for (cb = pd->callbacks; cb; ) { Eo_Callback_Description *titr = cb; cb = cb->next; @@ -516,7 +499,7 @@ static void _eo_callbacks_sorted_insert(Private_Data *pd, Eo_Callback_Description *cb) { Eo_Callback_Description *itr, *itrp = NULL; - for (itr = pd->callbacks ; itr && (itr->priority < cb->priority) ; + for (itr = pd->callbacks; itr && (itr->priority < cb->priority); itr = itr->next) { itrp = itr; @@ -535,41 +518,45 @@ _eo_callbacks_sorted_insert(Private_Data *pd, Eo_Callback_Description *cb) } static void -_ev_cb_priority_add(Eo *obj, void *class_data, va_list *list) +_ev_cb_priority_add(Eo *obj, void *class_data, + const Eo_Event_Description *desc, + Eo_Callback_Priority priority, + Eo_Event_Cb func, + const void *user_data) { Eo_Callback_Description *cb; Private_Data *pd = (Private_Data *) class_data; - EO_PARAMETER_GET(const Eo_Event_Description *, desc, list); - EO_PARAMETER_ENUM_GET(Eo_Callback_Priority, priority, list); - EO_PARAMETER_GET(Eo_Event_Cb, func, list); - EO_PARAMETER_GET(const void *, data, list); - cb = calloc(1, sizeof(*cb)); - if (!cb) return ; + if (!cb) return; cb->items.item.desc = desc; cb->items.item.func = func; - cb->func_data = (void *) data; + cb->func_data = (void *) user_data; cb->priority = priority; _eo_callbacks_sorted_insert(pd, cb); { const Eo_Callback_Array_Item arr[] = { {desc, func}, {NULL, NULL}}; - eo_do(obj, eo_event_callback_call(EO_EV_CALLBACK_ADD, arr, NULL)); + eo_do(obj, eo_event_callback_call(EO_EV_CALLBACK_ADD, (void *)arr)); } } +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, + const void *user_data); static void -_ev_cb_del(Eo *obj, void *class_data, va_list *list) +_ev_cb_del(Eo *obj, void *class_data, + const Eo_Event_Description *desc, + Eo_Event_Cb func, + void *user_data) { Eo_Callback_Description *cb; Private_Data *pd = (Private_Data *) class_data; - EO_PARAMETER_GET(const Eo_Event_Description *, desc, list); - EO_PARAMETER_GET(Eo_Event_Cb, func, list); - EO_PARAMETER_GET(void *, user_data, list); - - for (cb = pd->callbacks ; cb ; cb = cb->next) + for (cb = pd->callbacks; cb; cb = cb->next) { if ((cb->items.item.desc == desc) && (cb->items.item.func == func) && (cb->func_data == user_data)) @@ -579,47 +566,55 @@ _ev_cb_del(Eo *obj, void *class_data, va_list *list) cb->delete_me = EINA_TRUE; pd->deletions_waiting = EINA_TRUE; _eo_callbacks_clear(pd); - eo_do(obj, eo_event_callback_call(EO_EV_CALLBACK_DEL, arr, NULL)); + 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 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); static void -_ev_cb_array_priority_add(Eo *obj, void *class_data, va_list *list) +_ev_cb_array_priority_add(Eo *obj, void *class_data, + const Eo_Callback_Array_Item *array, + Eo_Callback_Priority priority, + const void *user_data) { Eo_Callback_Description *cb; Private_Data *pd = (Private_Data *) class_data; - EO_PARAMETER_GET(const Eo_Callback_Array_Item *, array, list); - EO_PARAMETER_ENUM_GET(Eo_Callback_Priority, priority, list); - EO_PARAMETER_GET(const void *, data, list); - cb = calloc(1, sizeof(*cb)); - if (!cb) return ; - cb->func_data = (void *) data; + if (!cb) return; + cb->func_data = (void *) user_data; cb->priority = priority; cb->items.item_array = array; cb->func_array = EINA_TRUE; _eo_callbacks_sorted_insert(pd, cb); { - eo_do(obj, eo_event_callback_call(EO_EV_CALLBACK_ADD, array, NULL)); + eo_do(obj, eo_event_callback_call(EO_EV_CALLBACK_ADD, (void *)array); ); } } +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); static void -_ev_cb_array_del(Eo *obj, void *class_data, va_list *list) +_ev_cb_array_del(Eo *obj, void *class_data, + const Eo_Callback_Array_Item *array, + void *user_data) { Eo_Callback_Description *cb; Private_Data *pd = (Private_Data *) class_data; - EO_PARAMETER_GET(const Eo_Callback_Array_Item *, array, list); - EO_PARAMETER_GET(void *, user_data, list); - - for (cb = pd->callbacks ; cb ; cb = cb->next) + for (cb = pd->callbacks; cb; cb = cb->next) { if ((cb->items.item_array == array) && (cb->func_data == user_data)) { @@ -627,32 +622,35 @@ _ev_cb_array_del(Eo *obj, void *class_data, va_list *list) pd->deletions_waiting = EINA_TRUE; _eo_callbacks_clear(pd); - eo_do(obj, eo_event_callback_call(EO_EV_CALLBACK_DEL, array, NULL)); + 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 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); -static void -_ev_cb_call(Eo *obj_id, void *class_data, va_list *list) +static Eina_Bool +_ev_cb_call(Eo *obj_id, void *class_data, + const Eo_Event_Description *desc, + void *event_info) { + Eina_Bool ret; Eo_Callback_Description *cb; Private_Data *pd = (Private_Data *) class_data; - EO_PARAMETER_GET(const Eo_Event_Description *, desc, list); - EO_PARAMETER_GET(void *, event_info, list); - EO_PARAMETER_GET(Eina_Bool *, ret, list); + EO_OBJ_POINTER_RETURN_VAL(obj_id, obj, EINA_FALSE); - EO_OBJ_POINTER_RETURN(obj_id, obj); - - if (ret) *ret = EINA_TRUE; + ret = EINA_TRUE; _eo_ref(obj); pd->walking_list++; - for (cb = pd->callbacks ; cb ; cb = cb->next) + for (cb = pd->callbacks; cb; cb = cb->next) { if (!cb->delete_me) { @@ -660,7 +658,7 @@ _ev_cb_call(Eo *obj_id, void *class_data, va_list *list) { const Eo_Callback_Array_Item *it; - for (it = cb->items.item_array ; it->func ; it++) + for (it = cb->items.item_array; it->func; it++) { if (it->desc != desc) continue; @@ -672,7 +670,7 @@ _ev_cb_call(Eo *obj_id, void *class_data, va_list *list) if (!it->func((void *) cb->func_data, obj_id, desc, (void *) event_info)) { - if (ret) *ret = EINA_FALSE; + ret = EINA_FALSE; goto end; } } @@ -690,7 +688,7 @@ _ev_cb_call(Eo *obj_id, void *class_data, va_list *list) if (!cb->items.item.func((void *) cb->func_data, obj_id, desc, (void *) event_info)) { - if (ret) *ret = EINA_FALSE; + ret = EINA_FALSE; goto end; } } @@ -701,52 +699,68 @@ end: pd->walking_list--; _eo_callbacks_clear(pd); _eo_unref(obj); + + return ret; } +EAPI EO_FUNC_BODYV(eo_event_callback_call, Eina_Bool, + EINA_FALSE, + EO_FUNC_CALL(desc, event_info), + const Eo_Event_Description *desc, + void *event_info); static Eina_Bool _eo_event_forwarder_callback(void *data, Eo *obj, const Eo_Event_Description *desc, void *event_info) { (void) obj; Eo *new_obj = (Eo *) data; - Eina_Bool ret; + Eina_Bool ret = EINA_FALSE; - eo_do(new_obj, eo_event_callback_call(desc, event_info, &ret)); + eo_do(new_obj, ret = eo_event_callback_call(desc, (void *)event_info); ); return ret; } /* FIXME: Change default priority? Maybe call later? */ static void -_ev_cb_forwarder_add(Eo *obj, void *class_data EINA_UNUSED, va_list *list) +_ev_cb_forwarder_add(Eo *obj, void *class_data EINA_UNUSED, + const Eo_Event_Description *desc, + Eo *new_obj) { - EO_PARAMETER_GET(const Eo_Event_Description *, desc, list); - EO_PARAMETER_GET(Eo *, new_obj, list); /* FIXME: Add it EO_MAGIC_RETURN(new_obj, EO_EINA_MAGIC); */ - eo_do(obj, eo_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 EO_VOID_FUNC_BODYV(eo_event_callback_forwarder_add, + EO_FUNC_CALL(desc, new_obj), + const Eo_Event_Description *desc, + Eo *new_obj); static void -_ev_cb_forwarder_del(Eo *obj, void *class_data EINA_UNUSED, va_list *list) +_ev_cb_forwarder_del(Eo *obj, void *class_data EINA_UNUSED, + const Eo_Event_Description *desc, + Eo *new_obj) { - EO_PARAMETER_GET(const Eo_Event_Description *, desc, list); - EO_PARAMETER_GET(Eo *, new_obj, list); /* FIXME: Add it EO_MAGIC_RETURN(new_obj, EO_EINA_MAGIC); */ - eo_do(obj, eo_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 EO_VOID_FUNC_BODYV(eo_event_callback_forwarder_del, + EO_FUNC_CALL(desc, new_obj), + const Eo_Event_Description *desc, + Eo *new_obj); static void -_ev_freeze(Eo *obj EINA_UNUSED, void *class_data, va_list *list EINA_UNUSED) +_ev_freeze(Eo *obj EINA_UNUSED, void *class_data) { Private_Data *pd = (Private_Data *) class_data; pd->event_freeze_count++; } +EAPI EO_VOID_FUNC_BODY(eo_event_freeze); static void -_ev_thaw(Eo *obj, void *class_data, va_list *list EINA_UNUSED) +_ev_thaw(Eo *obj, void *class_data) { Private_Data *pd = (Private_Data *) class_data; if (pd->event_freeze_count > 0) @@ -758,24 +772,26 @@ _ev_thaw(Eo *obj, void *class_data, va_list *list EINA_UNUSED) ERR("Events for object %p have already been thawed.", obj); } } +EAPI EO_VOID_FUNC_BODY(eo_event_thaw); -static void -_ev_freeze_get(Eo *obj EINA_UNUSED, void *class_data, va_list *list) +static int +_ev_freeze_get(Eo *obj EINA_UNUSED, void *class_data) { Private_Data *pd = (Private_Data *) class_data; - EO_PARAMETER_GET(int *, ret, list); - *ret = pd->event_freeze_count; + return pd->event_freeze_count; } +EAPI EO_FUNC_BODY(eo_event_freeze_get, int, 0); static void -_ev_global_freeze(Eo_Class *klass EINA_UNUSED, void *data EINA_UNUSED, va_list *list EINA_UNUSED) +_ev_global_freeze(const Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED) { event_freeze_count++; } +EAPI EO_VOID_FUNC_BODY(eo_event_global_freeze); static void -_ev_global_thaw(Eo_Class *klass EINA_UNUSED, void *data EINA_UNUSED, va_list *list EINA_UNUSED) +_ev_global_thaw(const Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED) { if (event_freeze_count > 0) { @@ -786,14 +802,14 @@ _ev_global_thaw(Eo_Class *klass EINA_UNUSED, void *data EINA_UNUSED, va_list *li ERR("Global events have already been thawed."); } } +EAPI EO_VOID_FUNC_BODY(eo_event_global_thaw); -static void -_ev_global_freeze_get(Eo_Class *klass EINA_UNUSED, void *data EINA_UNUSED, va_list *list) +static int +_ev_global_freeze_get(const Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED) { - EO_PARAMETER_GET(int *, ret, list); - - *ret = event_freeze_count; + return event_freeze_count; } +EAPI EO_FUNC_BODY(eo_event_global_freeze_get, int, 0); /* Eo_Dbg */ EAPI void @@ -849,6 +865,8 @@ _eo_dbg_info_convert_to(const Eina_Value_Type *type EINA_UNUSED, const Eina_Valu free(inner_val); return ret; } + + eina_error_set(EINA_ERROR_VALUE_FAILED); return EINA_FALSE; } @@ -891,10 +909,9 @@ EAPI const Eina_Value_Type *EO_DBG_INFO_TYPE = &_EO_DBG_INFO_TYPE; /* EOF event callbacks */ -/* EO_BASE_CLASS stuff */ -#define MY_CLASS EO_BASE_CLASS +/* EO_CLASS stuff */ +#define MY_CLASS EO_CLASS -/* FIXME: Set proper type descriptions. */ 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 = @@ -903,15 +920,16 @@ EAPI const Eo_Event_Description _EO_EV_DEL = EO_HOT_EVENT_DESCRIPTION("del", "Obj is being deleted."); static void -_constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +_constructor(Eo *obj, void *class_data EINA_UNUSED) { DBG("%p - %s.", obj, eo_class_name_get(MY_CLASS)); _eo_condtor_done(obj); } +EAPI EO_VOID_FUNC_BODY(eo_constructor); static void -_destructor(Eo *obj, void *class_data, va_list *list EINA_UNUSED) +_destructor(Eo *obj, void *class_data) { Private_Data *pd = class_data; Eo *child; @@ -927,71 +945,43 @@ _destructor(Eo *obj, void *class_data, va_list *list EINA_UNUSED) _eo_condtor_done(obj); } +EAPI EO_VOID_FUNC_BODY(eo_destructor); static void -_class_constructor(Eo_Class *klass) +_class_constructor(Eo_Class *klass EINA_UNUSED) { event_freeze_count = 0; - - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_PARENT_SET), _parent_set), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_PARENT_GET), _parent_get), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CHILDREN_ITERATOR_NEW), _children_iterator_new), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DATA_SET), _data_set), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DATA_GET), _data_get), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DATA_DEL), _data_del), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_WREF_ADD), _wref_add), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_WREF_DEL), _wref_del), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_CALLBACK_PRIORITY_ADD), _ev_cb_priority_add), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_CALLBACK_DEL), _ev_cb_del), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_CALLBACK_ARRAY_PRIORITY_ADD), _ev_cb_array_priority_add), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_CALLBACK_ARRAY_DEL), _ev_cb_array_del), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_CALLBACK_CALL), _ev_cb_call), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_CALLBACK_FORWARDER_ADD), _ev_cb_forwarder_add), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_CALLBACK_FORWARDER_DEL), _ev_cb_forwarder_del), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_FREEZE), _ev_freeze), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_THAW), _ev_thaw), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_FREEZE_GET), _ev_freeze_get), - EO_OP_FUNC_CLASS(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_GLOBAL_FREEZE), _ev_global_freeze), - EO_OP_FUNC_CLASS(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_GLOBAL_THAW), _ev_global_thaw), - EO_OP_FUNC_CLASS(EO_BASE_ID(EO_BASE_SUB_ID_EVENT_GLOBAL_FREEZE_GET), _ev_global_freeze_get), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DBG_INFO_GET), _dbg_info_get), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); } -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_CONSTRUCTOR, "Constructor"), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_DESTRUCTOR, "Destructor"), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_PARENT_SET, "Set parent"), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_PARENT_GET, "Get parent"), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_CHILDREN_ITERATOR_NEW, "Children Iterator"), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_DATA_SET, "Set data for key."), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_DATA_GET, "Get data for key."), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_DATA_DEL, "Del key."), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_WREF_ADD, "Add a weak ref to the object."), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_WREF_DEL, "Delete the weak ref."), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_EVENT_CALLBACK_PRIORITY_ADD, "Add an event callback with a priority."), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_EVENT_CALLBACK_DEL, "Delete an event callback"), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_EVENT_CALLBACK_ARRAY_PRIORITY_ADD, "Add an event callback array with a priority."), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_EVENT_CALLBACK_ARRAY_DEL, "Delete an event callback array"), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_EVENT_CALLBACK_CALL, "Call the event callbacks for an event."), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_EVENT_CALLBACK_FORWARDER_ADD, "Add an event forwarder."), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_EVENT_CALLBACK_FORWARDER_DEL, "Delete an event forwarder."), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_EVENT_FREEZE, "Freezes events."), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_EVENT_THAW, "Thaws events."), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_EVENT_FREEZE_GET, "Get event freeze counter."), - EO_OP_DESCRIPTION_CLASS(EO_BASE_SUB_ID_EVENT_GLOBAL_FREEZE, "Freezes events globally."), - EO_OP_DESCRIPTION_CLASS(EO_BASE_SUB_ID_EVENT_GLOBAL_THAW, "Thaws events globally."), - EO_OP_DESCRIPTION_CLASS(EO_BASE_SUB_ID_EVENT_GLOBAL_FREEZE_GET, "Get global event freeze counter."), - EO_OP_DESCRIPTION(EO_BASE_SUB_ID_DBG_INFO_GET, "Get debug info list for obj."), - EO_OP_DESCRIPTION_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_key_data_set, _data_set, "Set data for key."), + EO_OP_FUNC(eo_key_data_get, _data_get, "Get data for key."), + EO_OP_FUNC(eo_key_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: eo static const Eo_Event_Description *event_desc[] = { EO_EV_CALLBACK_ADD, EO_EV_CALLBACK_DEL, @@ -1003,7 +993,7 @@ static const Eo_Class_Description class_desc = { EO_VERSION, "Eo_Base", EO_CLASS_TYPE_REGULAR_NO_INSTANT, - EO_CLASS_DESCRIPTION_OPS(&EO_BASE_BASE_ID, op_desc, EO_BASE_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), event_desc, sizeof(Private_Data), _class_constructor, diff --git a/src/lib/eo/eo_class_class.c b/src/lib/eo/eo_class_class.c index 654e2efcca..43c2ffeb8f 100644 --- a/src/lib/eo/eo_class_class.c +++ b/src/lib/eo/eo_class_class.c @@ -4,13 +4,11 @@ #include "Eo.h" -EAPI Eo_Op EO_CLASS_CLASS_BASE_ID = 0; - static const Eo_Class_Description class_desc = { EO_VERSION, "Eo_Abstract_Class", EO_CLASS_TYPE_REGULAR_NO_INSTANT, - EO_CLASS_DESCRIPTION_OPS(&EO_CLASS_CLASS_BASE_ID, NULL, EO_CLASS_CLASS_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, diff --git a/src/lib/eo/eo_private.h b/src/lib/eo/eo_private.h index a985556b70..8648d023b8 100644 --- a/src/lib/eo/eo_private.h +++ b/src/lib/eo/eo_private.h @@ -109,6 +109,9 @@ struct _Eo_Object /* [composite*] */ }; +/* 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; typedef struct @@ -207,22 +210,16 @@ _eo_condtor_reset(_Eo_Object *obj) static inline void _eo_del_internal(const char *file, int line, _Eo_Object *obj) { - Eina_Bool do_err; /* We need that for the event callbacks that may ref/unref. */ obj->refcount++; - eo_do(_eo_id_get(obj), eo_event_callback_call(EO_EV_DEL, NULL, NULL)); - const _Eo_Class *klass = obj->klass; + eo_do(_eo_id_get(obj), eo_event_callback_call(EO_EV_DEL, NULL)); + _eo_condtor_reset(obj); - do_err = eo_do(_eo_id_get(obj), eo_destructor()); - if (EINA_UNLIKELY(!do_err)) - { - ERR("in %s:%d: Object of class '%s' - One of the object destructors have failed.", - file, line, klass->desc->name); - } + eo_do(_eo_id_get(obj), eo_destructor();); if (!obj->condtor_done) { diff --git a/src/lib/evas/canvas/evas_callbacks.c b/src/lib/evas/canvas/evas_callbacks.c index 654c5d033a..5aa362f3a1 100644 --- a/src/lib/evas/canvas/evas_callbacks.c +++ b/src/lib/evas/canvas/evas_callbacks.c @@ -238,7 +238,7 @@ evas_event_callback_cleanup(Evas *eo_e) void evas_event_callback_call(Evas *eo_e, Evas_Callback_Type type, void *event_info) { - eo_do(eo_e, eo_event_callback_call(_legacy_evas_callback_table[type], event_info, NULL)); + eo_do(eo_e, eo_event_callback_call(_legacy_evas_callback_table[type], event_info)); } void @@ -299,7 +299,7 @@ evas_object_event_callback_call(Evas_Object *eo_obj, Evas_Object_Protected_Data break; } - eo_do(eo_obj, eo_event_callback_call(_legacy_evas_callback_table[type], event_info, NULL)); + eo_do(eo_obj, eo_event_callback_call(_legacy_evas_callback_table[type], event_info)); if (type == EVAS_CALLBACK_MOUSE_DOWN) { diff --git a/src/lib/evas/canvas/evas_data.c b/src/lib/evas/canvas/evas_data.c index 01355b3ce1..4686595d36 100644 --- a/src/lib/evas/canvas/evas_data.c +++ b/src/lib/evas/canvas/evas_data.c @@ -8,7 +8,7 @@ evas_object_data_set(Evas_Object *obj, const char *key, const void *data) MAGIC_CHECK(obj, Evas_Object, MAGIC_OBJ); return; MAGIC_CHECK_END(); - eo_do(obj, eo_base_data_set(key, data, NULL)); + eo_do(obj, eo_key_data_set(key, data, NULL)); } EAPI void * @@ -18,7 +18,7 @@ evas_object_data_get(const Evas_Object *obj, const char *key) return NULL; MAGIC_CHECK_END(); void *data = NULL; - eo_do((Evas_Object *)obj, eo_base_data_get(key, &data)); + eo_do((Evas_Object *)obj, data = eo_key_data_get(key)); return data; } @@ -29,6 +29,6 @@ evas_object_data_del(Evas_Object *obj, const char *key) return NULL; MAGIC_CHECK_END(); void *data = NULL; - eo_do(obj, eo_base_data_get(key, &data), eo_base_data_del(key)); + eo_do(obj, data = eo_key_data_get(key), eo_key_data_del(key)); return data; } diff --git a/src/lib/evas/canvas/evas_events.c b/src/lib/evas/canvas/evas_events.c index 3308da2bc1..d53451b94e 100644 --- a/src/lib/evas/canvas/evas_events.c +++ b/src/lib/evas/canvas/evas_events.c @@ -958,8 +958,9 @@ _canvas_event_thaw(Eo *eo_e, void *_pd, va_list *list EINA_UNUSED) { int fcount = -1; eo_do_super(eo_e, EVAS_CLASS, - eo_event_thaw(), - eo_event_freeze_get(&fcount)); + eo_event_thaw()); + eo_do_super(eo_e, EVAS_CLASS, + fcount = eo_event_freeze_get()); if (0 == fcount) { Evas_Public_Data *e = _pd; @@ -988,7 +989,7 @@ evas_event_freeze_get(const Evas *eo_e) return 0; MAGIC_CHECK_END(); int ret = 0; - eo_do((Eo *)eo_e, eo_event_freeze_get(&ret)); + eo_do((Eo *)eo_e, ret = eo_event_freeze_get()); return ret; } diff --git a/src/lib/evas/canvas/evas_object_box.c b/src/lib/evas/canvas/evas_object_box.c index 761c736296..903578f232 100644 --- a/src/lib/evas/canvas/evas_object_box.c +++ b/src/lib/evas/canvas/evas_object_box.c @@ -131,7 +131,7 @@ _on_child_del(void *data, Eo *o, const Eo_Event_Description *desc EINA_UNUSED, v Evas_Object *box = data; Evas_Object *ret = NULL; - eo_do(box, evas_obj_box_internal_remove(o, &ret)); + eo_do(box, ret = evas_obj_box_internal_remove(o)); if (!ret) ERR("child removal failed"); evas_object_smart_changed(box); @@ -163,7 +163,7 @@ _evas_object_box_option_new(Evas_Object *o, Evas_Object_Box_Data *priv EINA_UNUS { Evas_Object_Box_Option *opt = NULL; - eo_do(o, evas_obj_box_internal_option_new(child, &opt)); + eo_do(o, opt = evas_obj_box_internal_option_new(child)); if (!opt) { ERR("option_new failed"); @@ -464,7 +464,7 @@ _evas_box_eo_base_constructor(Eo *obj, Evas_Object_Box_Data *class_data EINA_UNU { eo_do_super(obj, MY_CLASS, eo_constructor()); eo_do(obj, - evas_obj_smart_callbacks_descriptions_set(_signals, NULL), + evas_obj_smart_callbacks_descriptions_set(_signals), evas_obj_type_set(MY_CLASS_NAME_LEGACY)); } @@ -1686,7 +1686,7 @@ _evas_box_append(Eo *o, Evas_Object_Box_Data *priv, Evas_Object *child) if (!child) return NULL; - eo_do(o, evas_obj_box_internal_append(child, &opt)); + eo_do(o, opt = evas_obj_box_internal_append(child)); if (opt) { @@ -1705,7 +1705,7 @@ _evas_box_prepend(Eo *o, Evas_Object_Box_Data *priv, Evas_Object *child) if (!child) return NULL; - eo_do(o, evas_obj_box_internal_prepend(child, &opt)); + eo_do(o, opt = evas_obj_box_internal_prepend(child)); if (opt) { @@ -1723,7 +1723,7 @@ _evas_box_insert_before(Eo *o, Evas_Object_Box_Data *priv, Evas_Object *child, c if (!child) return NULL; - eo_do(o, evas_obj_box_internal_insert_before(child, reference, &opt)); + eo_do(o, opt = evas_obj_box_internal_insert_before(child, reference)); if (opt) { @@ -1742,7 +1742,7 @@ _evas_box_insert_after(Eo *o, Evas_Object_Box_Data *priv, Evas_Object *child, co if (!child) return NULL; - eo_do(o, evas_obj_box_internal_insert_after(child, reference, &opt)); + eo_do(o, opt = evas_obj_box_internal_insert_after(child, reference)); if (opt) { @@ -1761,7 +1761,7 @@ _evas_box_insert_at(Eo *o, Evas_Object_Box_Data *priv, Evas_Object *child, unsig if (!child) return NULL; - eo_do(o, evas_obj_box_internal_insert_at(child, pos, &opt)); + eo_do(o, opt = evas_obj_box_internal_insert_at(child, pos)); if (opt) { @@ -1778,7 +1778,7 @@ _evas_box_remove(Eo *o, Evas_Object_Box_Data *_pd EINA_UNUSED, Evas_Object *chil { Evas_Object *obj = NULL; - eo_do(o, evas_obj_box_internal_remove(child, &obj)); + eo_do(o, obj = evas_obj_box_internal_remove(child)); if (obj) { @@ -1796,7 +1796,7 @@ _evas_box_remove_at(Eo *o, Evas_Object_Box_Data *_pd EINA_UNUSED, unsigned int p { Evas_Object *obj = NULL; - eo_do(o, evas_obj_box_internal_remove_at(pos, &obj)); + eo_do(o, obj = evas_obj_box_internal_remove_at(pos)); if (obj) { @@ -1819,7 +1819,7 @@ _evas_box_remove_all(Eo *o, Evas_Object_Box_Data *priv, Eina_Bool clear) Evas_Object_Box_Option *opt = priv->children->data; Evas_Object *obj = NULL; - eo_do(o, evas_obj_box_internal_remove(opt->obj, &obj)); + eo_do(o, obj = evas_obj_box_internal_remove(opt->obj)); if (obj) { _evas_object_box_child_callbacks_unregister(obj, o); @@ -1921,7 +1921,7 @@ EAPI Eina_Bool evas_object_box_option_property_vset(Evas_Object *o, Evas_Object_Box_Option *opt, int property, va_list args) { Eina_Bool ret = EINA_FALSE; - eo_do(o, evas_obj_box_option_property_vset(opt, property, (va_list *) &args, &ret)); + eo_do(o, ret = evas_obj_box_option_property_vset(opt, property, (va_list *) &args)); return ret; } @@ -1948,7 +1948,7 @@ EAPI Eina_Bool evas_object_box_option_property_vget(const Evas_Object *o, Evas_Object_Box_Option *opt, int property, va_list args) { Eina_Bool ret = EINA_FALSE; - eo_do((Eo *)o, evas_obj_box_option_property_vget(opt, property, (va_list *) &args, &ret)); + eo_do((Eo *)o, ret = evas_obj_box_option_property_vget(opt, property, (va_list *) &args)); return ret; } diff --git a/src/lib/evas/canvas/evas_object_image.c b/src/lib/evas/canvas/evas_object_image.c index 287ad1a199..146265021e 100644 --- a/src/lib/evas/canvas/evas_object_image.c +++ b/src/lib/evas/canvas/evas_object_image.c @@ -324,12 +324,12 @@ _evas_image_eo_base_constructor(Eo *eo_obj, Evas_Image_Data *o) { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); Evas *eo_e; - Eo *parent; + Eo *parent = NULL; Evas_Colorspace cspace; eo_do_super(eo_obj, MY_CLASS, eo_constructor()); - eo_do(eo_obj, eo_parent_get(&parent)); + eo_do(eo_obj, parent = eo_parent_get()); eo_e = evas_object_evas_get(parent); evas_object_image_init(eo_obj); @@ -650,7 +650,7 @@ EAPI Eina_Bool evas_object_image_source_unset(Evas_Object *eo_obj) { Eina_Bool result = EINA_FALSE; - eo_do(eo_obj, evas_obj_image_source_set(NULL, &result)); + eo_do(eo_obj, result = evas_obj_image_source_set(NULL)); return result; } @@ -719,8 +719,8 @@ _evas_image_eo_base_dbg_info_get(Eo *eo_obj, Evas_Image_Data *o, Eo_Dbg_Info *ro if (evas_object_image_load_error_get(eo_obj) != EVAS_LOAD_ERROR_NONE) { - Evas_Load_Error error; - eo_do(eo_obj, evas_obj_image_load_error_get(&error)); + Evas_Load_Error error = EVAS_LOAD_ERROR_GENERIC; + eo_do(eo_obj, error = evas_obj_image_load_error_get()); EO_DBG_INFO_APPEND(group, "Load Error", EINA_VALUE_TYPE_STRING, evas_load_error_str(error)); } @@ -2357,8 +2357,8 @@ _proxy_subrender(Evas *eo_e, Evas_Object *eo_source, Evas_Object *eo_proxy, Evas ctx = e->engine.func->context_new(e->engine.data.output); - Eina_Bool source_clip; - eo_do(eo_proxy, evas_obj_image_source_clip_get(&source_clip)); + Eina_Bool source_clip = EINA_FALSE; + eo_do(eo_proxy, source_clip = evas_obj_image_source_clip_get()); Evas_Proxy_Render_Data proxy_render_data = { .eo_proxy = eo_proxy, diff --git a/src/lib/evas/canvas/evas_object_line.c b/src/lib/evas/canvas/evas_object_line.c index 9157314728..5968d8a001 100644 --- a/src/lib/evas/canvas/evas_object_line.c +++ b/src/lib/evas/canvas/evas_object_line.c @@ -221,13 +221,13 @@ _evas_line_eo_base_constructor(Eo *eo_obj, Evas_Line_Data *class_data EINA_UNUSE { Evas_Object_Protected_Data *obj; Evas_Line_Data *o; - Eo *parent; + Eo *parent = NULL; eo_do_super(eo_obj, MY_CLASS, eo_constructor()); obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); evas_object_line_init(eo_obj); - eo_do(eo_obj, eo_parent_get(&parent)); + eo_do(eo_obj, parent = eo_parent_get()); evas_object_inject(eo_obj, obj, evas_object_evas_get(parent)); o = class_data; diff --git a/src/lib/evas/canvas/evas_object_main.c b/src/lib/evas/canvas/evas_object_main.c index 18ab16c253..61b54bb600 100644 --- a/src/lib/evas/canvas/evas_object_main.c +++ b/src/lib/evas/canvas/evas_object_main.c @@ -1418,7 +1418,7 @@ evas_object_evas_get(const Evas_Object *eo_obj) return NULL; MAGIC_CHECK_END(); Evas *eo_evas = NULL; - eo_do((Eo *)eo_obj, evas_common_evas_get(&eo_evas)); + eo_do((Eo *)eo_obj, eo_evas = evas_common_evas_get()); return eo_evas; } @@ -1448,24 +1448,24 @@ _evas_object_eo_base_dbg_info_get(Eo *eo_obj, Evas_Object_Protected_Data *obj EI Eina_Bool clipees_has; eo_do(eo_obj, - evas_obj_visibility_get(&visible), - evas_obj_layer_get(&layer), - evas_obj_name_get(&name), + visible = evas_obj_visibility_get(), + layer = evas_obj_layer_get(), + name = evas_obj_name_get(), evas_obj_position_get(&x, &y), evas_obj_size_get(&w, &h), - evas_obj_scale_get(&scale), + scale = evas_obj_scale_get(), evas_obj_size_hint_min_get(&minw, &minh), evas_obj_size_hint_max_get(&maxw, &maxh), evas_obj_size_hint_request_get(&requestw, &requesth), evas_obj_size_hint_align_get(&dblx, &dbly), evas_obj_size_hint_weight_get(&dblw, &dblh), evas_obj_color_get(&r, &g, &b, &a), - evas_obj_focus_get(&focus), - evas_obj_pointer_mode_get(&m), - evas_obj_pass_events_get(&pass_event), - evas_obj_repeat_events_get(&repeat_event), - evas_obj_propagate_events_get(&propagate_event), - evas_obj_clipees_has(&clipees_has)); + focus = evas_obj_focus_get(), + m = evas_obj_pointer_mode_get(), + pass_event = evas_obj_pass_events_get(), + repeat_event = evas_obj_repeat_events_get(), + propagate_event = evas_obj_propagate_events_get(), + clipees_has = evas_obj_clipees_has()); EO_DBG_INFO_APPEND(group, "Visibility", EINA_VALUE_TYPE_CHAR, visible); @@ -1540,7 +1540,7 @@ _evas_object_eo_base_dbg_info_get(Eo *eo_obj, Evas_Object_Protected_Data *obj EI EO_DBG_INFO_APPEND(group, "Has clipees", EINA_VALUE_TYPE_CHAR, clipees_has); Evas_Object *clipper = NULL; - eo_do(eo_obj, evas_obj_clip_get(&clipper)); + eo_do(eo_obj, clipper = evas_obj_clip_get()); EO_DBG_INFO_APPEND(group, "Clipper", EINA_VALUE_TYPE_UINT64, (uintptr_t) clipper); const Evas_Map *map = evas_object_map_get(eo_obj); @@ -1616,8 +1616,8 @@ evas_object_top_at_pointer_get(const Evas *eo_e) Evas_Public_Data *e = eo_data_scope_get(eo_e, EVAS_CLASS); Evas_Object *ret = NULL; if (!e) return NULL; - eo_do((Eo *)eo_e, evas_canvas_object_top_at_xy_get(e->pointer.x, e->pointer.y, EINA_TRUE, - EINA_TRUE, &ret)); + eo_do((Eo *)eo_e, ret = evas_canvas_object_top_at_xy_get(e->pointer.x, e->pointer.y, EINA_TRUE, + EINA_TRUE)); return ret; } diff --git a/src/lib/evas/canvas/evas_object_polygon.c b/src/lib/evas/canvas/evas_object_polygon.c index 2c6d0bdc8b..d38c9c8825 100644 --- a/src/lib/evas/canvas/evas_object_polygon.c +++ b/src/lib/evas/canvas/evas_object_polygon.c @@ -108,13 +108,13 @@ EOLIAN static void _evas_polygon_eo_base_constructor(Eo *eo_obj, Evas_Polygon_Data *class_data EINA_UNUSED) { Evas_Object_Protected_Data *obj; - Eo *parent; + Eo *parent = NULL; eo_do_super(eo_obj, MY_CLASS, eo_constructor()); obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); evas_object_polygon_init(eo_obj); - eo_do(eo_obj, eo_parent_get(&parent)); + eo_do(eo_obj, parent = eo_parent_get()); evas_object_inject(eo_obj, obj, evas_object_evas_get(parent)); } diff --git a/src/lib/evas/canvas/evas_object_rectangle.c b/src/lib/evas/canvas/evas_object_rectangle.c index 8714fc35f0..dd84f45c74 100644 --- a/src/lib/evas/canvas/evas_object_rectangle.c +++ b/src/lib/evas/canvas/evas_object_rectangle.c @@ -95,14 +95,14 @@ evas_object_rectangle_add(Evas *e) EOLIAN static void _evas_rectangle_eo_base_constructor(Eo *eo_obj, Evas_Rectangle_Data *class_data EINA_UNUSED) { - Eo *parent; + Eo *parent = NULL; eo_do_super(eo_obj, MY_CLASS, eo_constructor()); Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); evas_object_rectangle_init(eo_obj); - eo_do(eo_obj, eo_parent_get(&parent)); + eo_do(eo_obj, parent = eo_parent_get()); evas_object_inject(eo_obj, obj, evas_object_evas_get(parent)); } diff --git a/src/lib/evas/canvas/evas_object_smart.c b/src/lib/evas/canvas/evas_object_smart.c index 2a2aeb2869..d6c3ba2571 100644 --- a/src/lib/evas/canvas/evas_object_smart.c +++ b/src/lib/evas/canvas/evas_object_smart.c @@ -547,7 +547,7 @@ _evas_smart_eo_base_constructor(Eo *eo_obj, Evas_Smart_Data *class_data EINA_UNU { Evas_Object_Protected_Data *obj; Evas_Smart_Data *smart; - Eo *parent; + Eo *parent = NULL; smart = class_data; smart->object = eo_obj; @@ -556,7 +556,7 @@ _evas_smart_eo_base_constructor(Eo *eo_obj, Evas_Smart_Data *class_data EINA_UNU evas_object_smart_init(eo_obj); obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - eo_do(eo_obj, eo_parent_get(&parent)); + eo_do(eo_obj, parent = eo_parent_get()); evas_object_inject(eo_obj, obj, evas_object_evas_get(parent)); eo_do(eo_obj, evas_obj_type_set(MY_CLASS_NAME_LEGACY), @@ -797,7 +797,7 @@ evas_object_smart_callback_call(Evas_Object *eo_obj, const char *event, void *ev if (!event) return; const _Evas_Event_Description *event_desc = eina_hash_find(signals_hash_table, event); if (event_desc) - eo_do(eo_obj, eo_event_callback_call(event_desc->eo_desc, event_info, NULL)); + eo_do(eo_obj, eo_event_callback_call(event_desc->eo_desc, event_info)); } EOLIAN static Eina_Bool diff --git a/src/lib/evas/canvas/evas_object_text.c b/src/lib/evas/canvas/evas_object_text.c index 1e56bfa073..2e77b1644a 100644 --- a/src/lib/evas/canvas/evas_object_text.c +++ b/src/lib/evas/canvas/evas_object_text.c @@ -383,9 +383,9 @@ _evas_text_eo_base_constructor(Eo *eo_obj, Evas_Text_Data *class_data EINA_UNUSE eo_do_super(eo_obj, MY_CLASS, eo_constructor()); evas_object_text_init(eo_obj); Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); - Eo *parent; + Eo *parent = NULL; - eo_do(eo_obj, eo_parent_get(&parent)); + eo_do(eo_obj, parent = eo_parent_get()); evas_object_inject(eo_obj, obj, evas_object_evas_get(parent)); } @@ -961,10 +961,10 @@ _evas_text_eo_base_dbg_info_get(Eo *eo_obj, Evas_Text_Data *o EINA_UNUSED, Eo_Db EO_DBG_INFO_APPEND(group, "Font", EINA_VALUE_TYPE_STRING, text); EO_DBG_INFO_APPEND(group, "Text size", EINA_VALUE_TYPE_INT, size); - eo_do(eo_obj, evas_obj_text_font_source_get(&text)); + eo_do(eo_obj, text = evas_obj_text_font_source_get()); EO_DBG_INFO_APPEND(group, "Font source", EINA_VALUE_TYPE_STRING, text); - eo_do(eo_obj, evas_obj_text_text_get(&text)); + eo_do(eo_obj, text = evas_obj_text_text_get()); EO_DBG_INFO_APPEND(group, "Text", EINA_VALUE_TYPE_STRING, text); } diff --git a/src/lib/evas/canvas/evas_object_textblock.c b/src/lib/evas/canvas/evas_object_textblock.c index 785d687a92..060c91c27e 100644 --- a/src/lib/evas/canvas/evas_object_textblock.c +++ b/src/lib/evas/canvas/evas_object_textblock.c @@ -5499,7 +5499,7 @@ _evas_textblock_eo_base_constructor(Eo *eo_obj, Evas_Textblock_Data *class_data { Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); Evas_Textblock_Data *o; - Eo *eo_parent; + Eo *eo_parent = NULL; eo_do_super(eo_obj, MY_CLASS, eo_constructor()); @@ -5513,7 +5513,7 @@ _evas_textblock_eo_base_constructor(Eo *eo_obj, Evas_Textblock_Data *class_data _format_command_init(); evas_object_textblock_init(eo_obj); - eo_do(eo_obj, eo_parent_get(&eo_parent)); + eo_do(eo_obj, eo_parent = eo_parent_get()); evas_object_inject(eo_obj, obj, evas_object_evas_get(eo_parent)); } @@ -6889,7 +6889,7 @@ EAPI const Evas_Object_Textblock_Node_Format * evas_textblock_node_format_first_get(const Evas_Object *eo_obj) { const Evas_Object_Textblock_Node_Format *format = NULL; - eo_do((Eo *)eo_obj, evas_obj_textblock_node_format_first_get(&format)); + eo_do((Eo *)eo_obj, format = evas_obj_textblock_node_format_first_get()); return format; } @@ -6903,7 +6903,7 @@ EAPI const Evas_Object_Textblock_Node_Format * evas_textblock_node_format_last_get(const Evas_Object *eo_obj) { const Evas_Object_Textblock_Node_Format *format = NULL; - eo_do((Eo *)eo_obj, evas_obj_textblock_node_format_last_get(&format)); + eo_do((Eo *)eo_obj, format = evas_obj_textblock_node_format_last_get()); return format; } @@ -10506,13 +10506,13 @@ _evas_textblock_eo_base_dbg_info_get(Eo *eo_obj, Evas_Textblock_Data *o EINA_UNU Eo_Dbg_Info *node; const char *style; - const char *text; + const char *text = NULL; char shorttext[48]; - const Evas_Textblock_Style *ts; + const Evas_Textblock_Style *ts = NULL; - eo_do(eo_obj, evas_obj_textblock_style_get(&ts)); + eo_do(eo_obj, ts = evas_obj_textblock_style_get()); style = evas_textblock_style_get(ts); - eo_do(eo_obj, evas_obj_textblock_text_markup_get(&text)); + eo_do(eo_obj, text = evas_obj_textblock_text_markup_get()); strncpy(shorttext, text, 38); if (shorttext[37]) strcpy(shorttext + 37, "\xe2\x80\xa6"); /* HORIZONTAL ELLIPSIS */ diff --git a/src/lib/evas/canvas/evas_object_textgrid.c b/src/lib/evas/canvas/evas_object_textgrid.c index 6870b60d6c..6af6a89a80 100644 --- a/src/lib/evas/canvas/evas_object_textgrid.c +++ b/src/lib/evas/canvas/evas_object_textgrid.c @@ -1065,14 +1065,14 @@ evas_object_textgrid_add(Evas *e) EOLIAN static void _evas_textgrid_eo_base_constructor(Eo *eo_obj, Evas_Textgrid_Data *class_data EINA_UNUSED) { - Eo *eo_parent; + Eo *eo_parent = NULL; eo_do_super(eo_obj, MY_CLASS, eo_constructor()); Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJ_CLASS); evas_object_textgrid_init(eo_obj); - eo_do(eo_obj, eo_parent_get(&eo_parent)); + eo_do(eo_obj, eo_parent = eo_parent_get()); evas_object_inject(eo_obj, obj, evas_object_evas_get(eo_parent)); } @@ -1497,7 +1497,7 @@ _evas_textgrid_eo_base_dbg_info_get(Eo *eo_obj, Evas_Textgrid_Data *o EINA_UNUSE EO_DBG_INFO_APPEND(group, "Font", EINA_VALUE_TYPE_STRING, text); EO_DBG_INFO_APPEND(group, "Text size", EINA_VALUE_TYPE_INT, size); - eo_do(eo_obj, evas_obj_textgrid_font_source_get(&text)); + eo_do(eo_obj, text = evas_obj_textgrid_font_source_get()); EO_DBG_INFO_APPEND(group, "Font source", EINA_VALUE_TYPE_STRING, text); { diff --git a/src/lib/evas/canvas/evas_out.c b/src/lib/evas/canvas/evas_out.c index 314ced98da..a77bed0788 100644 --- a/src/lib/evas/canvas/evas_out.c +++ b/src/lib/evas/canvas/evas_out.c @@ -29,10 +29,10 @@ evas_out_add(Evas *e) EOLIAN static void _evas_out_eo_base_constructor(Eo *eo_obj, Evas_Out_Data *eo_dat) { - Eo *eo_parent; + Eo *eo_parent = NULL; Evas_Public_Data *e; - eo_do(eo_obj, eo_parent_get(&eo_parent)); + eo_do(eo_obj, eo_parent = eo_parent_get()); e = eo_data_scope_get(eo_parent, EVAS_CLASS); eo_do_super(eo_obj, MY_CLASS, eo_constructor()); @@ -54,10 +54,10 @@ evas_output_del(Evas_Out *evo) EOLIAN static void _evas_out_eo_base_destructor(Eo *eo_obj, Evas_Out_Data *eo_dat) { - Eo *eo_parent; + Eo *eo_parent = NULL; Evas_Public_Data *e; - eo_do(eo_obj, eo_parent_get(&eo_parent)); + eo_do(eo_obj, eo_parent = eo_parent_get()); e = eo_data_scope_get(eo_parent, EVAS_CLASS); if (!e) return ; // XXX: need to free output and context one they get allocated one day diff --git a/src/lib/evas/canvas/evas_render.c b/src/lib/evas/canvas/evas_render.c index f1776ff958..5ffe0f41c1 100644 --- a/src/lib/evas/canvas/evas_render.c +++ b/src/lib/evas/canvas/evas_render.c @@ -1599,7 +1599,7 @@ _cb_always_call(Evas *eo_e, Evas_Callback_Type type, void *event_info) { int freeze_num = 0, i; - eo_do(eo_e, eo_event_freeze_get(&freeze_num)); + eo_do(eo_e, freeze_num = eo_event_freeze_get()); for (i = 0; i < freeze_num; i++) eo_do(eo_e, eo_event_thaw()); evas_event_callback_call(eo_e, type, event_info); for (i = 0; i < freeze_num; i++) eo_do(eo_e, eo_event_freeze()); diff --git a/src/lib/evas/canvas/evas_render2.c b/src/lib/evas/canvas/evas_render2.c index f853473a56..5fe8913849 100644 --- a/src/lib/evas/canvas/evas_render2.c +++ b/src/lib/evas/canvas/evas_render2.c @@ -121,7 +121,7 @@ _evas_render2_always_call(Eo *eo_e, Evas_Callback_Type type, void *event_info) { int freeze_num = 0, i; - eo_do(eo_e, eo_event_freeze_get(&freeze_num)); + eo_do(eo_e, freeze_num = eo_event_freeze_get()); for (i = 0; i < freeze_num; i++) eo_do(eo_e, eo_event_thaw()); evas_event_callback_call(eo_e, type, event_info); for (i = 0; i < freeze_num; i++) eo_do(eo_e, eo_event_freeze()); diff --git a/src/lib/evas/filters/evas_filter.c b/src/lib/evas/filters/evas_filter.c index dec5149677..e5536da704 100644 --- a/src/lib/evas/filters/evas_filter.c +++ b/src/lib/evas/filters/evas_filter.c @@ -250,7 +250,7 @@ _proxy_subrender(Evas *eo_e, Evas_Object *eo_source, Evas_Object *eo_proxy, ctx = e->engine.func->context_new(e->engine.data.output); if (eo_isa(eo_proxy, EVAS_OBJ_IMAGE_CLASS)) - eo_do(eo_proxy, evas_obj_image_source_clip_get(&source_clip)); + eo_do(eo_proxy, source_clip = evas_obj_image_source_clip_get()); Evas_Proxy_Render_Data proxy_render_data = { .eo_proxy = eo_proxy, diff --git a/src/tests/ecore/ecore_test_ecore_audio.c b/src/tests/ecore/ecore_test_ecore_audio.c index d62838422e..e4ce60a3dd 100644 --- a/src/tests/ecore/ecore_test_ecore_audio.c +++ b/src/tests/ecore/ecore_test_ecore_audio.c @@ -45,14 +45,14 @@ static Eina_Bool _looped_cb(void *data EINA_UNUSED, Eo *obj, const Eo_Event_Desc static Eina_Bool _seek_vol(void *data) { - double len; + double len = 0; Eo *in = data; - Eo *out; + Eo *out = NULL; - eo_do(in, ecore_audio_obj_in_output_get(&out)); + eo_do(in, out = ecore_audio_obj_in_output_get()); eo_do(out, ecore_audio_obj_volume_set(0.4)); - eo_do(in, ecore_audio_obj_in_seek(-0.3, SEEK_END, &len)); + eo_do(in, len = ecore_audio_obj_in_seek(-0.3, SEEK_END)); fail_if(len < 0); return EINA_FALSE; @@ -61,14 +61,14 @@ _seek_vol(void *data) START_TEST(ecore_test_ecore_audio_obj_pulse) { Eo *in, *out; - Eina_Bool ret; + Eina_Bool ret = EINA_FALSE; Eina_Bool pulse_context_failed = EINA_FALSE; in = eo_add(ECORE_AUDIO_OBJ_IN_SNDFILE_CLASS, NULL); fail_if(!in); eo_do(in, ecore_audio_obj_name_set("modem.wav")); - eo_do(in, ecore_audio_obj_source_set(TESTS_SRC_DIR"/modem.wav", &ret)); + eo_do(in, ret = ecore_audio_obj_source_set(TESTS_SRC_DIR"/modem.wav")); fail_if(!ret); out = eo_add(ECORE_AUDIO_OBJ_OUT_PULSE_CLASS, NULL); @@ -79,7 +79,7 @@ START_TEST(ecore_test_ecore_audio_obj_pulse) eo_do(in, eo_event_callback_add(ECORE_AUDIO_IN_EVENT_IN_STOPPED, _finished_cb, NULL)); eo_do(out, eo_event_callback_add(ECORE_AUDIO_OUT_PULSE_EVENT_CONTEXT_FAIL, _failed_cb, &pulse_context_failed)); - eo_do(out, ecore_audio_obj_out_input_attach(in, &ret)); + eo_do(out, ret = ecore_audio_obj_out_input_attach(in)); fail_if(!ret); ecore_main_loop_begin(); @@ -112,21 +112,21 @@ START_TEST(ecore_test_ecore_audio_cleanup) { Eo *in, *out; int freq = 1000; - Eina_Bool ret; + Eina_Bool ret = EINA_FALSE; in = eo_add(ECORE_AUDIO_OBJ_IN_TONE_CLASS, NULL); fail_if(!in); - eo_do(in, eo_base_data_set(ECORE_AUDIO_ATTR_TONE_FREQ, &freq, NULL)); + eo_do(in, eo_key_data_set(ECORE_AUDIO_ATTR_TONE_FREQ, &freq, NULL)); eo_do(in, ecore_audio_obj_in_length_set(2)); out = eo_add(ECORE_AUDIO_OBJ_OUT_SNDFILE_CLASS, NULL); fail_if(!out); - eo_do(out, ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_OGG, &ret)); + eo_do(out, ret = ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_OGG)); fail_if(!ret); - eo_do(out, ecore_audio_obj_source_set(TESTS_BUILD_DIR"/tmp.ogg", &ret)); + eo_do(out, ret = ecore_audio_obj_source_set(TESTS_BUILD_DIR"/tmp.ogg")); fail_if(!ret); - eo_do(out, ecore_audio_obj_out_input_attach(in, &ret)); + eo_do(out, ret = ecore_audio_obj_out_input_attach(in)); fail_if(!ret); ecore_idler_add(_idle_del, in); @@ -150,69 +150,69 @@ START_TEST(ecore_test_ecore_audio_obj_tone) eo_do(in, ecore_audio_obj_name_set("tone")); - eo_do(in, ecore_audio_obj_in_channels_get(&channel)); + eo_do(in, channel = ecore_audio_obj_in_channels_get()); fail_if(channel != 1); - eo_do(in, ecore_audio_obj_in_samplerate_get(&rate)); + eo_do(in, rate = ecore_audio_obj_in_samplerate_get()); fail_if(rate != 44100); - eo_do(in, ecore_audio_obj_in_length_get(&len)); + eo_do(in, len = ecore_audio_obj_in_length_get()); fail_if(len != 1); eo_do(in, ecore_audio_obj_in_length_set(2.5)); - eo_do(in, ecore_audio_obj_in_length_get(&len)); + eo_do(in, len = ecore_audio_obj_in_length_get()); fail_if(len != 2.5); eo_do(in, ecore_audio_obj_in_looped_set(EINA_TRUE)); - eo_do(in, ecore_audio_obj_in_remaining_get(&len)); + eo_do(in, len = ecore_audio_obj_in_remaining_get()); fail_if(len != 2.5); - eo_do(in, eo_base_data_get(ECORE_AUDIO_ATTR_TONE_FREQ, (void **)&freq)); + eo_do(in, freq = (intptr_t) eo_key_data_get(ECORE_AUDIO_ATTR_TONE_FREQ)); fail_if(freq != 1000); freq = 2000; - eo_do(in, eo_base_data_set(ECORE_AUDIO_ATTR_TONE_FREQ, &freq, NULL)); + eo_do(in, eo_key_data_set(ECORE_AUDIO_ATTR_TONE_FREQ, &freq, NULL)); - eo_do(in, eo_base_data_get(ECORE_AUDIO_ATTR_TONE_FREQ, (void **)&freq)); + eo_do(in, freq = (intptr_t) eo_key_data_get(ECORE_AUDIO_ATTR_TONE_FREQ)); fail_if(freq != 2000); - eo_do(in, eo_base_data_set("foo", "bar", NULL)); - eo_do(in, eo_base_data_get("foo", (void **)&tmp)); + eo_do(in, eo_key_data_set("foo", "bar", NULL)); + eo_do(in, tmp = eo_key_data_get("foo")); ck_assert_str_eq(tmp, "bar"); - eo_do(in, ecore_audio_obj_in_seek(5.0, SEEK_SET, &len)); + eo_do(in, len = ecore_audio_obj_in_seek(5.0, SEEK_SET)); fail_if(len != -1); - eo_do(in, ecore_audio_obj_in_seek(1.0, 42, &len)); + eo_do(in, len = ecore_audio_obj_in_seek(1.0, 42)); fail_if(len != -1); - eo_do(in, ecore_audio_obj_in_seek(1.0, SEEK_SET, &len)); + eo_do(in, len = ecore_audio_obj_in_seek(1.0, SEEK_SET)); fail_if(len != 1.0); - eo_do(in, ecore_audio_obj_in_remaining_get(&len)); + eo_do(in, len = ecore_audio_obj_in_remaining_get()); fail_if(len != 1.5); - eo_do(in, ecore_audio_obj_in_seek(1.0, SEEK_CUR, &len)); + eo_do(in, len = ecore_audio_obj_in_seek(1.0, SEEK_CUR)); fail_if(len != 2.0); - eo_do(in, ecore_audio_obj_in_remaining_get(&len)); + eo_do(in, len = ecore_audio_obj_in_remaining_get()); fail_if(len != 0.5); - eo_do(in, ecore_audio_obj_in_seek(-1.0, SEEK_END, &len)); + eo_do(in, len = ecore_audio_obj_in_seek(-1.0, SEEK_END)); fail_if(len != 1.5); - eo_do(in, ecore_audio_obj_in_remaining_get(&len)); + eo_do(in, len = ecore_audio_obj_in_remaining_get()); fail_if(len != 1.0); out = eo_add(ECORE_AUDIO_OBJ_OUT_SNDFILE_CLASS, NULL); fail_if(!out); eo_do(out, ecore_audio_obj_name_set("tmp.wav")); - eo_do(out, ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_WAV, &ret)); + eo_do(out, ret = ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_WAV)); fail_if(!ret); - eo_do(out, ecore_audio_obj_source_set(TESTS_BUILD_DIR"/tmp.wav", &ret)); + eo_do(out, ret = ecore_audio_obj_source_set(TESTS_BUILD_DIR"/tmp.wav")); fail_if(!ret); - eo_do(out, ecore_audio_obj_out_input_attach(in, &ret)); + eo_do(out, ret = ecore_audio_obj_out_input_attach(in)); fail_if(!ret); eo_do(in, eo_event_callback_add(ECORE_AUDIO_IN_EVENT_IN_LOOPED, _looped_cb, NULL)); @@ -240,70 +240,70 @@ START_TEST(ecore_test_ecore_audio_obj_sndfile) in = eo_add(ECORE_AUDIO_OBJ_IN_SNDFILE_CLASS, NULL); fail_if(!in); - eo_do(in, ecore_audio_obj_format_get(&fmt)); + eo_do(in, fmt = ecore_audio_obj_format_get()); fail_if(fmt != ECORE_AUDIO_FORMAT_AUTO); - eo_do(in, ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_FLAC, &ret)); + eo_do(in, ret = ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_FLAC)); fail_if(!ret); - eo_do(in, ecore_audio_obj_format_get(&fmt)); + eo_do(in, fmt = ecore_audio_obj_format_get()); fail_if(fmt != ECORE_AUDIO_FORMAT_FLAC); - eo_do(in, ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_AUTO, &ret)); + eo_do(in, ret = ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_AUTO)); fail_if(!ret); eo_do(in, ecore_audio_obj_name_set("sms.ogg")); - eo_do(in, ecore_audio_obj_source_set(TESTS_SRC_DIR"/sms.ogg", &ret)); + eo_do(in, ret = ecore_audio_obj_source_set(TESTS_SRC_DIR"/sms.ogg")); fail_if(!ret); - eo_do(in, ecore_audio_obj_source_get(&src)); + eo_do(in, src = ecore_audio_obj_source_get()); ck_assert_str_eq(src, TESTS_SRC_DIR"/sms.ogg"); - eo_do(in, ecore_audio_obj_format_get(&fmt)); + eo_do(in, fmt = ecore_audio_obj_format_get()); fail_if(fmt != ECORE_AUDIO_FORMAT_OGG); - eo_do(in, ecore_audio_obj_in_channels_get(&channel)); + eo_do(in, channel = ecore_audio_obj_in_channels_get()); fail_if(channel != 2); - eo_do(in, ecore_audio_obj_in_samplerate_get(&rate)); + eo_do(in, rate = ecore_audio_obj_in_samplerate_get()); fail_if(rate != 44100); - eo_do(in, ecore_audio_obj_in_length_get(&len)); + eo_do(in, len = ecore_audio_obj_in_length_get()); fail_if(len == 0); - eo_do(in, ecore_audio_obj_in_remaining_get(&rem)); + eo_do(in, rem = ecore_audio_obj_in_remaining_get()); fail_if(len != rem); - eo_do(in, ecore_audio_obj_format_get(&fmt)); + eo_do(in, fmt = ecore_audio_obj_format_get()); fail_if(fmt != ECORE_AUDIO_FORMAT_OGG); - eo_do(in, ecore_audio_obj_in_seek(0.5, SEEK_SET, &len)); + eo_do(in, len = ecore_audio_obj_in_seek(0.5, SEEK_SET)); fail_if(len != 0.5); - eo_do(in, ecore_audio_obj_in_seek(0.5, SEEK_CUR, &len)); + eo_do(in, len = ecore_audio_obj_in_seek(0.5, SEEK_CUR)); fail_if(len != 1.0); - eo_do(in, ecore_audio_obj_in_seek(-1.0, SEEK_END, &len)); + eo_do(in, len = ecore_audio_obj_in_seek(-1.0, SEEK_END)); fail_if(fabs(rem - 1 - len) > 0.1); out = eo_add(ECORE_AUDIO_OBJ_OUT_SNDFILE_CLASS, NULL); fail_if(!out); eo_do(out, ecore_audio_obj_name_set("tmp.wav")); - eo_do(out, ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_WAV, &ret)); + eo_do(out, ret = ecore_audio_obj_format_set(ECORE_AUDIO_FORMAT_WAV)); fail_if(!ret); - eo_do(out, ecore_audio_obj_format_get(&fmt)); + eo_do(out, fmt = ecore_audio_obj_format_get()); fail_if(fmt != ECORE_AUDIO_FORMAT_WAV); // eo_do(out, ecore_audio_obj_source_set("/tmp/file/does/not/exist/hopefully.wav", &ret)); // fail_if(ret); - eo_do(out, ecore_audio_obj_source_set(TESTS_BUILD_DIR"/tmp.wav", &ret)); + eo_do(out, ret = ecore_audio_obj_source_set(TESTS_BUILD_DIR"/tmp.wav")); fail_if(!ret); - eo_do(out, ecore_audio_obj_source_get(&src)); + eo_do(out, src = ecore_audio_obj_source_get()); ck_assert_str_eq(src, TESTS_BUILD_DIR"/tmp.wav"); - eo_do(out, ecore_audio_obj_out_input_attach(in, &ret)); + eo_do(out, ret = ecore_audio_obj_out_input_attach(in)); fail_if(!ret); eo_do(in, eo_event_callback_add(ECORE_AUDIO_IN_EVENT_IN_STOPPED, _finished_cb, NULL)); @@ -332,47 +332,47 @@ START_TEST(ecore_test_ecore_audio_obj_in_out) fail_if(!in2); fail_if(!out); - fail_if(!eo_do(in, ecore_audio_obj_in_output_get(&out2))); + eo_do(in, out2 = ecore_audio_obj_in_output_get()); fail_if(out2); - fail_if(!eo_do(out, ecore_audio_obj_out_inputs_get(&in3))); + eo_do(out, in3 = ecore_audio_obj_out_inputs_get()); fail_if(eina_list_count(in3) != 0); - fail_if(!eo_do(out, ecore_audio_obj_out_input_attach(in, &attached))); + eo_do(out, attached = ecore_audio_obj_out_input_attach(in)); fail_if(!attached); - fail_if(!eo_do(out, ecore_audio_obj_out_input_attach(in, &attached))); + eo_do(out, attached = ecore_audio_obj_out_input_attach(in)); fail_if(attached); - fail_if(!eo_do(in, ecore_audio_obj_in_output_get(&out2))); + eo_do(in, out2 = ecore_audio_obj_in_output_get()); fail_if(out2 != out); - fail_if(!eo_do(out, ecore_audio_obj_out_inputs_get(&in3))); + eo_do(out, in3 = ecore_audio_obj_out_inputs_get()); fail_if(eina_list_count(in3) != 1); fail_if(eina_list_data_get(in3) != in); - fail_if(!eo_do(out, ecore_audio_obj_out_input_attach(in2, &attached))); + eo_do(out, attached = ecore_audio_obj_out_input_attach(in2)); fail_if(!attached); - fail_if(!eo_do(out, ecore_audio_obj_out_inputs_get(&in3))); + eo_do(out, in3 = ecore_audio_obj_out_inputs_get()); fail_if(eina_list_count(in3) != 2); fail_if(eina_list_data_get(in3) != in); eo_del(in2); - fail_if(!eo_do(out, ecore_audio_obj_out_inputs_get(&in3))); + eo_do(out, in3 = ecore_audio_obj_out_inputs_get()); fail_if(eina_list_count(in3) != 1); fail_if(eina_list_data_get(in3) != in); eo_del(out); - fail_if(!eo_do(in, ecore_audio_obj_in_output_get(&out2))); + eo_do(in, out2 = ecore_audio_obj_in_output_get()); fail_if(out2); @@ -431,7 +431,7 @@ START_TEST(ecore_test_ecore_audio_obj_vio) eo_do(in, ecore_audio_obj_vio_set(&in_vio, NULL, NULL)); eo_do(out, ecore_audio_obj_vio_set(&out_vio, NULL, NULL)); - eo_do(out, ecore_audio_obj_out_input_attach(in, NULL)); + eo_do(out, ecore_audio_obj_out_input_attach(in)); ecore_main_loop_begin(); @@ -464,73 +464,73 @@ START_TEST(ecore_test_ecore_audio_obj_in) fail_if(!in); - fail_if(!eo_do(in, ecore_audio_obj_vio_set(&vio, &freed, _myfree))); + eo_do(in, ecore_audio_obj_vio_set(&vio, &freed, _myfree)); fail_if(freed); - fail_if(!eo_do(in, ecore_audio_obj_vio_set(NULL, NULL, NULL))); + eo_do(in, ecore_audio_obj_vio_set(NULL, NULL, NULL)); fail_if(!freed); - fail_if(!eo_do(in, ecore_audio_obj_in_speed_get(&speed))); + eo_do(in, speed = ecore_audio_obj_in_speed_get()); fail_if(speed != 1.0); - fail_if(!eo_do(in, ecore_audio_obj_in_speed_set(2.5))); + eo_do(in, ecore_audio_obj_in_speed_set(2.5)); - fail_if(!eo_do(in, ecore_audio_obj_in_speed_get(&speed))); + eo_do(in, speed = ecore_audio_obj_in_speed_get()); fail_if(speed != 2.5); - fail_if(!eo_do(in, ecore_audio_obj_in_speed_set(0))); + eo_do(in, ecore_audio_obj_in_speed_set(0)); - fail_if(!eo_do(in, ecore_audio_obj_in_speed_get(&speed))); + eo_do(in, speed = ecore_audio_obj_in_speed_get()); fail_if(speed != 0.2); - fail_if(!eo_do(in, ecore_audio_obj_in_speed_set(10))); + eo_do(in, ecore_audio_obj_in_speed_set(10)); - fail_if(!eo_do(in, ecore_audio_obj_in_speed_get(&speed))); + eo_do(in, speed = ecore_audio_obj_in_speed_get()); fail_if(speed != 5.0); - fail_if(!eo_do(in, ecore_audio_obj_in_samplerate_get(&samplerate))); + eo_do(in, samplerate = ecore_audio_obj_in_samplerate_get()); fail_if(samplerate != 0); - fail_if(!eo_do(in, ecore_audio_obj_in_samplerate_set(1234))); + eo_do(in, ecore_audio_obj_in_samplerate_set(1234)); - fail_if(!eo_do(in, ecore_audio_obj_in_samplerate_get(&samplerate))); + eo_do(in, samplerate = ecore_audio_obj_in_samplerate_get()); fail_if(samplerate != 1234); - fail_if(!eo_do(in, ecore_audio_obj_in_channels_get(&channels))); + eo_do(in, channels = ecore_audio_obj_in_channels_get()); fail_if(channels != 0); - fail_if(!eo_do(in, ecore_audio_obj_in_channels_set(2))); + eo_do(in, ecore_audio_obj_in_channels_set(2)); - fail_if(!eo_do(in, ecore_audio_obj_in_channels_get(&channels))); + eo_do(in, channels = ecore_audio_obj_in_channels_get()); fail_if(channels != 2); - fail_if(!eo_do(in, ecore_audio_obj_in_looped_get(&looped))); + eo_do(in, looped = ecore_audio_obj_in_looped_get()); fail_if(looped); - fail_if(!eo_do(in, ecore_audio_obj_in_looped_set(EINA_TRUE))); + eo_do(in, ecore_audio_obj_in_looped_set(EINA_TRUE)); - fail_if(!eo_do(in, ecore_audio_obj_in_looped_get(&looped))); + eo_do(in, looped = ecore_audio_obj_in_looped_get()); fail_if(!looped); - fail_if(!eo_do(in, ecore_audio_obj_in_length_get(&length))); + eo_do(in, length = ecore_audio_obj_in_length_get()); fail_if(length != 0); - fail_if(eo_do(in, ecore_audio_obj_in_length_set(10.0))); + eo_do(in, ecore_audio_obj_in_length_set(10.0)); - fail_if(!eo_do(in, ecore_audio_obj_in_remaining_get(&length))); + eo_do(in, length = ecore_audio_obj_in_remaining_get()); fail_if(length != -1); memset(buf, 0xaa, 10); - fail_if(!eo_do(in, ecore_audio_obj_in_read(buf, 10, &read))); + eo_do(in, read = ecore_audio_obj_in_read(buf, 10)); fail_if(read != 0); for (i=0; i<10; i++) { fail_if(buf[i] != 0xaa); } - fail_if(!eo_do(in, ecore_audio_obj_paused_set(EINA_TRUE))); + eo_do(in, ecore_audio_obj_paused_set(EINA_TRUE)); - fail_if(!eo_do(in, ecore_audio_obj_in_read(buf, 10, &read))); + eo_do(in, read = ecore_audio_obj_in_read(buf, 10)); fail_if(read != 10); for (i=0; i<10; i++) { @@ -560,29 +560,29 @@ START_TEST(ecore_test_ecore_audio_obj) fail_if(!obj); - fail_if(!eo_do(obj, ecore_audio_obj_name_get(&name))); + eo_do(obj, name = ecore_audio_obj_name_get()); fail_if(name); - fail_if(!eo_do(obj, ecore_audio_obj_name_set("In1"))); - fail_if(!eo_do(obj, ecore_audio_obj_name_get(&name))); + eo_do(obj, ecore_audio_obj_name_set("In1")); + eo_do(obj, name = ecore_audio_obj_name_get()); ck_assert_str_eq(name, "In1"); - fail_if(!eo_do(obj, ecore_audio_obj_name_get(NULL))); + eo_do(obj, ecore_audio_obj_name_get()); - fail_if(!eo_do(obj, ecore_audio_obj_paused_get(&paused))); + eo_do(obj, paused = ecore_audio_obj_paused_get()); fail_if(paused); - fail_if(!eo_do(obj, ecore_audio_obj_paused_set(EINA_TRUE))); - fail_if(!eo_do(obj, ecore_audio_obj_paused_get(&paused))); + eo_do(obj, ecore_audio_obj_paused_set(EINA_TRUE)); + eo_do(obj, paused = ecore_audio_obj_paused_get()); fail_if(!paused); - fail_if(!eo_do(obj, ecore_audio_obj_volume_get(&volume))); + eo_do(obj, volume = ecore_audio_obj_volume_get()); fail_if(volume != 1.0); - fail_if(!eo_do(obj, ecore_audio_obj_volume_set(0.5))); - fail_if(!eo_do(obj, ecore_audio_obj_volume_get(&volume))); + eo_do(obj, ecore_audio_obj_volume_set(0.5)); + eo_do(obj, volume = ecore_audio_obj_volume_get()); fail_if(volume != 0.5); eo_del(obj); diff --git a/src/tests/eo/access/access_inherit.c b/src/tests/eo/access/access_inherit.c index b42a4a6c6e..46db0c22ad 100644 --- a/src/tests/eo/access/access_inherit.c +++ b/src/tests/eo/access/access_inherit.c @@ -7,42 +7,30 @@ #include "access_simple_protected.h" #include "access_inherit.h" -EAPI Eo_Op INHERIT_BASE_ID = 0; - #define MY_CLASS INHERIT_CLASS static void -_prot_print(Eo *obj, void *class_data EINA_UNUSED, va_list *list) +_prot_print(Eo *obj, void *class_data EINA_UNUSED) { Simple_Protected_Data *pd = eo_data_scope_get(obj, SIMPLE_CLASS); - (void) list; printf("%s %d\n", __func__, pd->protected_x1); } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(INHERIT_ID(INHERIT_SUB_ID_PROT_PRINT), _prot_print), - EO_OP_FUNC_SENTINEL - }; +EAPI EO_VOID_FUNC_BODY(inherit_prot_print); - eo_class_funcs_set(klass, func_desc); -} - -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(INHERIT_SUB_ID_PROT_PRINT, "Print protected var x1."), - EO_OP_DESCRIPTION_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 = { EO_VERSION, "Inherit", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(&INHERIT_BASE_ID, op_desc, INHERIT_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, - _class_constructor, + NULL, NULL }; diff --git a/src/tests/eo/access/access_inherit.h b/src/tests/eo/access/access_inherit.h index f701dae484..0c1543698c 100644 --- a/src/tests/eo/access/access_inherit.h +++ b/src/tests/eo/access/access_inherit.h @@ -1,16 +1,7 @@ #ifndef INHERIT_H #define INHERIT_H -extern EAPI Eo_Op INHERIT_BASE_ID; - -enum { - INHERIT_SUB_ID_PROT_PRINT, - INHERIT_SUB_ID_LAST -}; - -#define INHERIT_ID(sub_id) (INHERIT_BASE_ID + sub_id) - -#define inherit_prot_print() INHERIT_ID(INHERIT_SUB_ID_PROT_PRINT) +EAPI void inherit_prot_print(void); #define INHERIT_CLASS inherit_class_get() const Eo_Class *inherit_class_get(void); diff --git a/src/tests/eo/access/access_simple.c b/src/tests/eo/access/access_simple.c index 42fa259e40..6bf44ded70 100644 --- a/src/tests/eo/access/access_simple.c +++ b/src/tests/eo/access/access_simple.c @@ -6,8 +6,6 @@ #include "access_simple.h" #include "access_simple_protected.h" -EAPI Eo_Op SIMPLE_BASE_ID = 0; - typedef struct { Simple_Protected_Data protected; @@ -20,34 +18,23 @@ EAPI const Eo_Event_Description _EV_A_CHANGED = #define MY_CLASS SIMPLE_CLASS static void -_a_set(Eo *obj, void *class_data, va_list *list) +_a_set(Eo *obj, void *class_data, int a) { Private_Data *pd = class_data; - int a; - a = va_arg(*list, int); pd->a = a; printf("%s %d\n", __func__, pd->a); pd->protected.protected_x1 = a + 1; pd->protected.public.public_x2 = a + 2; - eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a, NULL)); + eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a)); } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_SET), _a_set), - EO_OP_FUNC_SENTINEL - }; +EAPI EO_VOID_FUNC_BODYV(simple_a_set, EO_FUNC_CALL(a), int a); - eo_class_funcs_set(klass, func_desc); -} - -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_A_SET, "Set property A"), - EO_OP_DESCRIPTION_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[] = { @@ -59,12 +46,12 @@ static const Eo_Class_Description class_desc = { EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(&SIMPLE_BASE_ID, op_desc, SIMPLE_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), event_desc, sizeof(Private_Data), - _class_constructor, + NULL, NULL }; -EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, NULL) +EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_CLASS, NULL) diff --git a/src/tests/eo/access/access_simple.h b/src/tests/eo/access/access_simple.h index 11624b7d20..3c92d21073 100644 --- a/src/tests/eo/access/access_simple.h +++ b/src/tests/eo/access/access_simple.h @@ -1,22 +1,13 @@ #ifndef SIMPLE_H #define SIMPLE_H -extern EAPI Eo_Op SIMPLE_BASE_ID; - -enum { - SIMPLE_SUB_ID_A_SET, - SIMPLE_SUB_ID_LAST -}; +EAPI void simple_a_set(int a); typedef struct { int public_x2; } Simple_Public_Data; -#define SIMPLE_ID(sub_id) (SIMPLE_BASE_ID + sub_id) - -#define simple_a_set(a) SIMPLE_ID(SIMPLE_SUB_ID_A_SET), EO_TYPECHECK(int, a) - extern const Eo_Event_Description _EV_A_CHANGED; #define EV_A_CHANGED (&(_EV_A_CHANGED)) diff --git a/src/tests/eo/composite_objects/composite_objects_comp.c b/src/tests/eo/composite_objects/composite_objects_comp.c index 7d66331400..d880c9823e 100644 --- a/src/tests/eo/composite_objects/composite_objects_comp.c +++ b/src/tests/eo/composite_objects/composite_objects_comp.c @@ -8,20 +8,19 @@ #include "../eunit_tests.h" -EAPI Eo_Op COMP_BASE_ID = 0; - #define MY_CLASS COMP_CLASS -static void -_a_get(Eo *obj, void *class_data EINA_UNUSED, va_list *list) +static int +_a_get(Eo *obj, void *class_data EINA_UNUSED) { - int *a; - a = va_arg(*list, int *); - eo_do_super(obj, MY_CLASS, simple_a_get(a)); + int a = 0; + eo_do_super(obj, MY_CLASS, a = simple_a_get()); + + return a; } static void -_constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +_constructor(Eo *obj, void *class_data EINA_UNUSED) { eo_do_super(obj, MY_CLASS, eo_constructor()); @@ -32,34 +31,28 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) fail_if(eo_composite_is(obj)); fail_if(!eo_composite_is(simple)); - eo_do(obj, eo_base_data_set("simple-obj", simple, NULL)); + eo_do(obj, eo_key_data_set("simple-obj", simple, NULL)); eo_unref(simple); } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_GET), _a_get), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} +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 = { EO_VERSION, "Comp", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, - _class_constructor, + NULL, NULL }; -EO_DEFINE_CLASS(comp_class_get, &class_desc, EO_BASE_CLASS, +EO_DEFINE_CLASS(comp_class_get, &class_desc, EO_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 ba96eb4a22..9c3d95c426 100644 --- a/src/tests/eo/composite_objects/composite_objects_main.c +++ b/src/tests/eo/composite_objects/composite_objects_main.c @@ -36,16 +36,16 @@ main(int argc, char *argv[]) fail_if(!eo_isa(obj, COMP_CLASS)); fail_if(!eo_isa(obj, SIMPLE_CLASS)); - int a; + int a = 0; eo_do(obj, simple_a_set(1)); fail_if(!cb_called); - eo_do(obj, simple_a_get(&a)); + eo_do(obj, a = simple_a_get()); fail_if(a != 1); /* disable the callback forwarder, and fail if it's still called. */ - Eo *simple; - eo_do(obj, eo_base_data_get("simple-obj", (void **) &simple)); + Eo *simple = NULL; + eo_do(obj, simple = eo_key_data_get("simple-obj")); eo_ref(simple); eo_do(simple, eo_event_callback_forwarder_del(EV_A_CHANGED, obj)); diff --git a/src/tests/eo/composite_objects/composite_objects_simple.c b/src/tests/eo/composite_objects/composite_objects_simple.c index 5420ef895d..a1dfd4dbd8 100644 --- a/src/tests/eo/composite_objects/composite_objects_simple.c +++ b/src/tests/eo/composite_objects/composite_objects_simple.c @@ -5,50 +5,35 @@ #include "Eo.h" #include "composite_objects_simple.h" -EAPI Eo_Op SIMPLE_BASE_ID = 0; - EAPI const Eo_Event_Description _EV_A_CHANGED = EO_EVENT_DESCRIPTION("a,changed", "Called when a has changed."); #define MY_CLASS SIMPLE_CLASS static void -_a_set(Eo *obj, void *class_data, va_list *list) +_a_set(Eo *obj, void *class_data, int a) { Simple_Public_Data *pd = class_data; - int a; - a = va_arg(*list, int); printf("%s %d\n", eo_class_name_get(MY_CLASS), a); pd->a = a; - eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a, NULL)); + eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a)); } -static void -_a_get(Eo *obj EINA_UNUSED, void *class_data, va_list *list) +static int +_a_get(Eo *obj EINA_UNUSED, void *class_data) { const Simple_Public_Data *pd = class_data; - int *a; - a = va_arg(*list, int *); - *a = pd->a; + return pd->a; } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_SET), _a_set), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_GET), _a_get), - EO_OP_FUNC_SENTINEL - }; +EAPI EO_VOID_FUNC_BODYV(simple_a_set, EO_FUNC_CALL(a), int a); +EAPI EO_FUNC_BODY(simple_a_get, int, 0); - eo_class_funcs_set(klass, func_desc); -} - -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_A_SET, "Set property A"), - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_A_GET, "Get property A"), - EO_OP_DESCRIPTION_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[] = { @@ -60,12 +45,12 @@ static const Eo_Class_Description class_desc = { EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(&SIMPLE_BASE_ID, op_desc, SIMPLE_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), event_desc, sizeof(Simple_Public_Data), - _class_constructor, + NULL, NULL }; -EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, NULL); +EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_CLASS, NULL); diff --git a/src/tests/eo/composite_objects/composite_objects_simple.h b/src/tests/eo/composite_objects/composite_objects_simple.h index 32a62465b8..d9dbbb272b 100644 --- a/src/tests/eo/composite_objects/composite_objects_simple.h +++ b/src/tests/eo/composite_objects/composite_objects_simple.h @@ -1,23 +1,13 @@ #ifndef SIMPLE_H #define SIMPLE_H -extern EAPI Eo_Op SIMPLE_BASE_ID; - -enum { - SIMPLE_SUB_ID_A_SET, - SIMPLE_SUB_ID_A_GET, - SIMPLE_SUB_ID_LAST -}; - typedef struct { int a; } Simple_Public_Data; -#define SIMPLE_ID(sub_id) (SIMPLE_BASE_ID + sub_id) - -#define simple_a_set(a) SIMPLE_ID(SIMPLE_SUB_ID_A_SET), EO_TYPECHECK(int, a) -#define simple_a_get(a) SIMPLE_ID(SIMPLE_SUB_ID_A_GET), EO_TYPECHECK(int *, a) +EAPI void simple_a_set(int a); +EAPI int simple_a_get(void); extern const Eo_Event_Description _EV_A_CHANGED; #define EV_A_CHANGED (&(_EV_A_CHANGED)) diff --git a/src/tests/eo/constructors/constructors_main.c b/src/tests/eo/constructors/constructors_main.c index c7db62d398..7b7da023f1 100644 --- a/src/tests/eo/constructors/constructors_main.c +++ b/src/tests/eo/constructors/constructors_main.c @@ -30,8 +30,10 @@ main(int argc, char *argv[]) eo_do(obj, simple_a_set(1), simple_b_set(2)); - int a, b; - eo_do(obj, simple_a_get(&a), simple_b_get(&b), mixin_add_and_print(5)); + int a = 0, b = 0; + eo_do(obj, a = simple_a_get(), b = simple_b_get(), mixin_add_and_print(5)); + fail_if(a != 1); + fail_if(b != 2); eo_unref(obj); @@ -68,7 +70,7 @@ main(int argc, char *argv[]) fail_if(!obj); fail_if(my_init_count != 2); - eo_do(obj, simple_a_get(&a)); + 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 24f73643f3..ca7343ffe0 100644 --- a/src/tests/eo/constructors/constructors_mixin.c +++ b/src/tests/eo/constructors/constructors_mixin.c @@ -6,23 +6,20 @@ #include "constructors_mixin.h" #include "constructors_simple.h" -EAPI Eo_Op MIXIN_BASE_ID = 0; - #define MY_CLASS MIXIN_CLASS static void -_add_and_print_set(Eo *obj, void *class_data EINA_UNUSED, va_list *list) +_add_and_print_set(Eo *obj, void *class_data EINA_UNUSED, int x) { - int a, b, x; - eo_do(obj, simple_a_get(&a), simple_b_get(&b)); - x = va_arg(*list, const int); + int a = 0, b = 0; + eo_do(obj, a = simple_a_get(), b = simple_b_get()); printf("%s %d\n", __func__, a + b + x); } extern int my_init_count; static void -_constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +_constructor(Eo *obj, void *class_data EINA_UNUSED) { eo_do_super(obj, MY_CLASS, eo_constructor()); @@ -30,41 +27,32 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) } static void -_destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +_destructor(Eo *obj, void *class_data EINA_UNUSED) { eo_do_super(obj, MY_CLASS, eo_destructor()); my_init_count--; } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), - EO_OP_FUNC(MIXIN_ID(MIXIN_SUB_ID_ADD_AND_SET), _add_and_print_set), - EO_OP_FUNC_SENTINEL - }; +EAPI EO_VOID_FUNC_BODYV(mixin_add_and_print, EO_FUNC_CALL(x), int x); - eo_class_funcs_set(klass, func_desc); -} - -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(MIXIN_SUB_ID_ADD_AND_SET, "Add A + B + param and print it"), - EO_OP_DESCRIPTION_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 = { EO_VERSION, "Mixin", EO_CLASS_TYPE_MIXIN, - EO_CLASS_DESCRIPTION_OPS(&MIXIN_BASE_ID, op_desc, MIXIN_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, - _class_constructor, + NULL, NULL }; -EO_DEFINE_CLASS(mixin_class_get, &class_desc, NULL, NULL); +EO_DEFINE_CLASS(mixin_class_get, &class_desc, NULL, EO_CLASS, NULL); diff --git a/src/tests/eo/constructors/constructors_mixin.h b/src/tests/eo/constructors/constructors_mixin.h index 9998b274f4..ebf923f702 100644 --- a/src/tests/eo/constructors/constructors_mixin.h +++ b/src/tests/eo/constructors/constructors_mixin.h @@ -1,16 +1,7 @@ #ifndef MIXIN_H #define MIXIN_H -extern EAPI Eo_Op MIXIN_BASE_ID; - -enum { - MIXIN_SUB_ID_ADD_AND_SET, - MIXIN_SUB_ID_LAST -}; - -#define MIXIN_ID(sub_id) (MIXIN_BASE_ID + sub_id) - -#define mixin_add_and_print(x) MIXIN_ID(MIXIN_SUB_ID_ADD_AND_SET), EO_TYPECHECK(int, x) +EAPI void mixin_add_and_print(int x); #define MIXIN_CLASS mixin_class_get() const Eo_Class *mixin_class_get(void); diff --git a/src/tests/eo/constructors/constructors_simple.c b/src/tests/eo/constructors/constructors_simple.c index 466bd85c05..fa6b3fd820 100644 --- a/src/tests/eo/constructors/constructors_simple.c +++ b/src/tests/eo/constructors/constructors_simple.c @@ -6,8 +6,6 @@ #include "constructors_mixin.h" #include "constructors_simple.h" -EAPI Eo_Op SIMPLE_BASE_ID = 0; - typedef struct { int a; @@ -19,24 +17,22 @@ typedef struct static char *class_var = NULL; #define _GET_SET_FUNC(name) \ -static void \ -_##name##_get(Eo *obj EINA_UNUSED, void *class_data, va_list *list) \ +static int \ +_##name##_get(Eo *obj EINA_UNUSED, void *class_data) \ { \ const Private_Data *pd = class_data; \ - int *name; \ - name = va_arg(*list, int *); \ - *name = pd->name; \ printf("%s %d\n", __func__, pd->name); \ + return pd->name; \ } \ static void \ -_##name##_set(Eo *obj EINA_UNUSED, void *class_data, va_list *list) \ +_##name##_set(Eo *obj EINA_UNUSED, void *class_data, int name) \ { \ Private_Data *pd = class_data; \ - int name; \ - name = va_arg(*list, int); \ pd->name = name; \ printf("%s %d\n", __func__, pd->name); \ -} +} \ +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,11 +40,9 @@ _GET_SET_FUNC(b) extern int my_init_count; static void -_simple_constructor(Eo *obj, void *class_data, va_list *list) +_simple_constructor(Eo *obj, void *class_data, int a) { Private_Data *pd = class_data; - int a; - a = va_arg(*list, int); eo_do_super(obj, MY_CLASS, eo_constructor()); @@ -59,7 +53,7 @@ _simple_constructor(Eo *obj, void *class_data, va_list *list) } static void -_constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +_constructor(Eo *obj, void *class_data EINA_UNUSED) { eo_do_super(obj, MY_CLASS, eo_constructor()); @@ -67,7 +61,7 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) } static void -_destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +_destructor(Eo *obj, void *class_data EINA_UNUSED) { eo_do_super(obj, MY_CLASS, eo_destructor()); @@ -75,21 +69,8 @@ _destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) } static void -_class_constructor(Eo_Class *klass) +_class_constructor(Eo_Class *klass EINA_UNUSED) { - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_CONSTRUCTOR), _simple_constructor), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_SET), _a_set), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_GET), _a_get), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_B_SET), _b_set), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_B_GET), _b_get), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); - class_var = malloc(10); } @@ -99,26 +80,30 @@ _class_destructor(Eo_Class *klass EINA_UNUSED) free(class_var); } -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_CONSTRUCTOR, "Construct and set A."), - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_A_SET, "Set property A"), - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_A_GET, "Get property A"), - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_B_SET, "Set property B"), - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_B_GET, "Get property B"), - EO_OP_DESCRIPTION_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 = { EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(&SIMPLE_BASE_ID, op_desc, SIMPLE_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Private_Data), _class_constructor, _class_destructor }; -EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, +EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_CLASS, MIXIN_CLASS, NULL); diff --git a/src/tests/eo/constructors/constructors_simple.h b/src/tests/eo/constructors/constructors_simple.h index 7342d3402e..d8ab0e9d2f 100644 --- a/src/tests/eo/constructors/constructors_simple.h +++ b/src/tests/eo/constructors/constructors_simple.h @@ -1,24 +1,11 @@ #ifndef SIMPLE_H #define SIMPLE_H -extern EAPI Eo_Op SIMPLE_BASE_ID; - -enum { - SIMPLE_SUB_ID_CONSTRUCTOR, - SIMPLE_SUB_ID_A_SET, - SIMPLE_SUB_ID_A_GET, - SIMPLE_SUB_ID_B_SET, - SIMPLE_SUB_ID_B_GET, - SIMPLE_SUB_ID_LAST -}; - -#define SIMPLE_ID(sub_id) (SIMPLE_BASE_ID + sub_id) - -#define simple_constructor(a) SIMPLE_ID(SIMPLE_SUB_ID_CONSTRUCTOR), EO_TYPECHECK(int, a) -#define simple_a_set(a) SIMPLE_ID(SIMPLE_SUB_ID_A_SET), EO_TYPECHECK(int, a) -#define simple_a_get(a) SIMPLE_ID(SIMPLE_SUB_ID_A_GET), EO_TYPECHECK(int *, a) -#define simple_b_set(b) SIMPLE_ID(SIMPLE_SUB_ID_B_SET), EO_TYPECHECK(int, b) -#define simple_b_get(b) SIMPLE_ID(SIMPLE_SUB_ID_B_GET), EO_TYPECHECK(int *, b) +EAPI void simple_constructor(int a); +EAPI void simple_a_set(int a); +EAPI int simple_a_get(void); +EAPI void simple_b_set(int b); +EAPI int simple_b_get(void); #define SIMPLE_CLASS simple_class_get() const Eo_Class *simple_class_get(void); diff --git a/src/tests/eo/constructors/constructors_simple2.c b/src/tests/eo/constructors/constructors_simple2.c index b80b22b809..0318a9ff09 100644 --- a/src/tests/eo/constructors/constructors_simple2.c +++ b/src/tests/eo/constructors/constructors_simple2.c @@ -9,34 +9,28 @@ #define MY_CLASS SIMPLE2_CLASS static void -_constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +_constructor(Eo *obj, void *class_data EINA_UNUSED) { eo_do_super(obj, MY_CLASS, eo_constructor()); eo_error_set(obj); } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor), + EO_OP_SENTINEL +}; static const Eo_Class_Description class_desc = { EO_VERSION, "Simple2", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, - _class_constructor, + NULL, NULL }; -EO_DEFINE_CLASS(simple2_class_get, &class_desc, EO_BASE_CLASS, NULL); +EO_DEFINE_CLASS(simple2_class_get, &class_desc, EO_CLASS, NULL); diff --git a/src/tests/eo/constructors/constructors_simple3.c b/src/tests/eo/constructors/constructors_simple3.c index 13453b76e3..9c720b51eb 100644 --- a/src/tests/eo/constructors/constructors_simple3.c +++ b/src/tests/eo/constructors/constructors_simple3.c @@ -14,27 +14,21 @@ _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) (void) obj; } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor), + EO_OP_SENTINEL +}; static const Eo_Class_Description class_desc = { EO_VERSION, "Simple3", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, - _class_constructor, + NULL, NULL }; -EO_DEFINE_CLASS(simple3_class_get, &class_desc, EO_BASE_CLASS, NULL); +EO_DEFINE_CLASS(simple3_class_get, &class_desc, EO_CLASS, NULL); diff --git a/src/tests/eo/constructors/constructors_simple4.c b/src/tests/eo/constructors/constructors_simple4.c index abce301e3a..a7f627b09f 100644 --- a/src/tests/eo/constructors/constructors_simple4.c +++ b/src/tests/eo/constructors/constructors_simple4.c @@ -13,7 +13,7 @@ static const Eo_Class_Description class_desc = { EO_VERSION, "Simple4", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + 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 bd2f1a5b3b..df51e4ae87 100644 --- a/src/tests/eo/constructors/constructors_simple5.c +++ b/src/tests/eo/constructors/constructors_simple5.c @@ -14,27 +14,21 @@ _destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) (void) obj; } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} +static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor), + EO_OP_SENTINEL +}; static const Eo_Class_Description class_desc = { EO_VERSION, "Simple5", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, - _class_constructor, + NULL, NULL }; -EO_DEFINE_CLASS(simple5_class_get, &class_desc, EO_BASE_CLASS, NULL); +EO_DEFINE_CLASS(simple5_class_get, &class_desc, EO_CLASS, NULL); diff --git a/src/tests/eo/constructors/constructors_simple6.c b/src/tests/eo/constructors/constructors_simple6.c index c9988854df..3f4c70e480 100644 --- a/src/tests/eo/constructors/constructors_simple6.c +++ b/src/tests/eo/constructors/constructors_simple6.c @@ -9,34 +9,28 @@ #define MY_CLASS SIMPLE6_CLASS static void -_destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +_destructor(Eo *obj, void *class_data EINA_UNUSED) { eo_do_super(obj, MY_CLASS, eo_destructor()); eo_error_set(obj); } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} +static Eo_Op_Description op_descs [] = { + EO_OP_FUNC_OVERRIDE(eo_destructor, _destructor), + EO_OP_SENTINEL +}; static const Eo_Class_Description class_desc = { EO_VERSION, "Simple6", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, - _class_constructor, + NULL, NULL }; -EO_DEFINE_CLASS(simple6_class_get, &class_desc, EO_BASE_CLASS, NULL); +EO_DEFINE_CLASS(simple6_class_get, &class_desc, EO_CLASS, NULL); diff --git a/src/tests/eo/constructors/constructors_simple7.c b/src/tests/eo/constructors/constructors_simple7.c index 20faba537e..cd0298948d 100644 --- a/src/tests/eo/constructors/constructors_simple7.c +++ b/src/tests/eo/constructors/constructors_simple7.c @@ -14,28 +14,23 @@ static void _constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) { - fail_if(eo_do_super(obj, MY_CLASS, eo_constructor())); + /* FIXME: Actually test it. */ + eo_do_super(obj, MY_CLASS, eo_constructor()); } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} +static Eo_Op_Description op_descs [] = { + EO_OP_FUNC_OVERRIDE(eo_constructor, _constructor), + EO_OP_SENTINEL +}; static const Eo_Class_Description class_desc = { EO_VERSION, "Simple7", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, - _class_constructor, + NULL, NULL }; diff --git a/src/tests/eo/function_overrides/function_overrides_inherit.c b/src/tests/eo/function_overrides/function_overrides_inherit.c index e2dadbec1b..3a767f9e1a 100644 --- a/src/tests/eo/function_overrides/function_overrides_inherit.c +++ b/src/tests/eo/function_overrides/function_overrides_inherit.c @@ -12,7 +12,7 @@ static const Eo_Class_Description class_desc = { EO_VERSION, "Inherit", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + 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 addf9fdd43..a892aaf96e 100644 --- a/src/tests/eo/function_overrides/function_overrides_inherit2.c +++ b/src/tests/eo/function_overrides/function_overrides_inherit2.c @@ -9,72 +9,72 @@ #include "../eunit_tests.h" -EAPI Eo_Op INHERIT2_BASE_ID = 0; - #define MY_CLASS INHERIT2_CLASS static void -_a_set(Eo *obj, void *class_data EINA_UNUSED, va_list *list) +_a_set(Eo *obj, void *class_data EINA_UNUSED, int a) { - int a; - a = va_arg(*list, int); printf("%s %d\n", eo_class_name_get(MY_CLASS), a); eo_do(obj, simple_a_print()); eo_do_super(obj, MY_CLASS, simple_a_set(a + 1)); - fail_if(!eo_do_super(obj, MY_CLASS, simple_a_print())); + Eina_Bool called = EINA_FALSE; + eo_do_super(obj, MY_CLASS, called = simple_a_print()); + fail_if(!called); } -static void -_print(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +static Eina_Bool +_print(Eo *obj, void *class_data EINA_UNUSED) { + Eina_Bool called = EINA_FALSE; printf("Hey\n"); - fail_if(eo_do_super(obj, MY_CLASS, inherit2_print())); + eo_do_super(obj, MY_CLASS, called = inherit2_print()); + fail_if(called); + + return EINA_TRUE; } -static void -_print2(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +static Eina_Bool +_print2(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED) { printf("Hey2\n"); + + return EINA_TRUE; } -static void -_class_print(Eo_Class *klass, void *data EINA_UNUSED, va_list *list) +static Eina_Bool +_class_print(Eo_Class *klass, void *data EINA_UNUSED) { - (void) list; + Eina_Bool called = EINA_FALSE; printf("Print %s-%s\n", eo_class_name_get(klass), eo_class_name_get(MY_CLASS)); - fail_if(!eo_do_super(klass, MY_CLASS, simple_class_print())); - fail_if(!eo_do_super(klass, MY_CLASS, simple_class_print2())); + eo_do_super(klass, MY_CLASS, called = simple_class_print()); + fail_if(!called); + + eo_do_super(klass, MY_CLASS, called = simple_class_print2()); + fail_if(!called); + + return EINA_TRUE; } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_SET), _a_set), - EO_OP_FUNC(INHERIT2_ID(INHERIT2_SUB_ID_PRINT), _print), - EO_OP_FUNC(INHERIT2_ID(INHERIT2_SUB_ID_PRINT2), _print2), - EO_OP_FUNC_CLASS(SIMPLE_ID(SIMPLE_SUB_ID_CLASS_PRINT), _class_print), - EO_OP_FUNC_SENTINEL - }; +EAPI EO_FUNC_BODY(inherit2_print, Eina_Bool, EINA_FALSE); +EAPI EO_FUNC_BODY(inherit2_print2, Eina_Bool, EINA_FALSE); - eo_class_funcs_set(klass, func_desc); -} - -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(INHERIT2_SUB_ID_PRINT, "Print hey"), - EO_OP_DESCRIPTION(INHERIT2_SUB_ID_PRINT2, "Print hey2"), - EO_OP_DESCRIPTION_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 = { EO_VERSION, "Inherit2", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(&INHERIT2_BASE_ID, op_desc, INHERIT2_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, - _class_constructor, + NULL, NULL }; diff --git a/src/tests/eo/function_overrides/function_overrides_inherit2.h b/src/tests/eo/function_overrides/function_overrides_inherit2.h index 2bc0b0d36a..48be203664 100644 --- a/src/tests/eo/function_overrides/function_overrides_inherit2.h +++ b/src/tests/eo/function_overrides/function_overrides_inherit2.h @@ -1,18 +1,8 @@ #ifndef INHERIT2_H #define INHERIT2_H -extern EAPI Eo_Op INHERIT2_BASE_ID; - -enum { - INHERIT2_SUB_ID_PRINT, - INHERIT2_SUB_ID_PRINT2, - INHERIT2_SUB_ID_LAST -}; - -#define INHERIT2_ID(sub_id) (INHERIT2_BASE_ID + sub_id) - -#define inherit2_print() INHERIT2_ID(INHERIT2_SUB_ID_PRINT) -#define inherit2_print2() INHERIT2_ID(INHERIT2_SUB_ID_PRINT2) +EAPI Eina_Bool inherit2_print(void); +EAPI Eina_Bool inherit2_print2(void); #define INHERIT2_CLASS inherit2_class_get() const Eo_Class *inherit2_class_get(void); diff --git a/src/tests/eo/function_overrides/function_overrides_inherit3.c b/src/tests/eo/function_overrides/function_overrides_inherit3.c index ba6f84a229..d8b6190098 100644 --- a/src/tests/eo/function_overrides/function_overrides_inherit3.c +++ b/src/tests/eo/function_overrides/function_overrides_inherit3.c @@ -10,33 +10,25 @@ #define MY_CLASS INHERIT3_CLASS static void -_a_set(Eo *obj, void *class_data EINA_UNUSED, va_list *list) +_a_set(Eo *obj, void *class_data EINA_UNUSED, int a) { - int a; - a = va_arg(*list, int); printf("%s %d\n", eo_class_name_get(MY_CLASS), a); eo_do_super(obj, MY_CLASS, simple_a_set(a + 1)); } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_SET), _a_set), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} +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 = { EO_VERSION, "Inherit3", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, - _class_constructor, + NULL, NULL }; diff --git a/src/tests/eo/function_overrides/function_overrides_main.c b/src/tests/eo/function_overrides/function_overrides_main.c index 4210925dfe..920595c077 100644 --- a/src/tests/eo/function_overrides/function_overrides_main.c +++ b/src/tests/eo/function_overrides/function_overrides_main.c @@ -17,6 +17,7 @@ main(int argc, char *argv[]) (void) argv; eo_init(); + Eina_Bool called = EINA_FALSE; Eo *obj = eo_add(INHERIT2_CLASS, NULL); eo_do(obj, simple_a_set(1)); @@ -34,24 +35,36 @@ main(int argc, char *argv[]) eo_unref(obj); obj = eo_add(INHERIT2_CLASS, NULL); - fail_if(!eo_do(obj, inherit2_print())); - fail_if(!eo_do(obj, inherit2_print(), inherit2_print())); + eo_do(obj, called = inherit2_print()); + fail_if(!called); + eo_do(obj, called = inherit2_print(), called = inherit2_print()); + fail_if(!called); eo_unref(obj); obj = eo_add(SIMPLE_CLASS, NULL); - fail_if(eo_do(obj, inherit2_print2())); + eo_do(obj, called = inherit2_print()); + fail_if(called); #ifdef EO_DEBUG - fail_if(eo_do(obj, simple_class_print())); + eo_do(obj, called = simple_class_print()); + fail_if(called); #endif - fail_if(!eo_do(SIMPLE_CLASS, simple_class_print())); - fail_if(!eo_do(INHERIT_CLASS, simple_class_print())); - fail_if(!eo_do(INHERIT2_CLASS, simple_class_print())); - fail_if(!eo_do(INHERIT3_CLASS, simple_class_print())); + eo_do(SIMPLE_CLASS, called = simple_class_print()); + fail_if(!called); + + eo_do(INHERIT_CLASS, called = simple_class_print()); + fail_if(!called); + + eo_do(INHERIT2_CLASS, called = simple_class_print()); + fail_if(!called); + + eo_do(INHERIT3_CLASS, called = simple_class_print()); + fail_if(!called); #ifdef EO_DEBUG - fail_if(eo_do(SIMPLE_CLASS, simple_a_print())); + eo_do(SIMPLE_CLASS, called = simple_a_print()); + fail_if(called); #endif eo_do_super(obj, SIMPLE_CLASS, eo_constructor()); diff --git a/src/tests/eo/function_overrides/function_overrides_simple.c b/src/tests/eo/function_overrides/function_overrides_simple.c index afa4fef9fb..1ba2382948 100644 --- a/src/tests/eo/function_overrides/function_overrides_simple.c +++ b/src/tests/eo/function_overrides/function_overrides_simple.c @@ -7,76 +7,73 @@ #include "../eunit_tests.h" -EAPI Eo_Op SIMPLE_BASE_ID = 0; - #define MY_CLASS SIMPLE_CLASS +Eina_Bool class_print_called = EINA_FALSE; +Eina_Bool class_print2_called = EINA_FALSE; + static void -_a_set(Eo *obj EINA_UNUSED, void *class_data, va_list *list) +_a_set(Eo *obj EINA_UNUSED, void *class_data, int a) { Simple_Public_Data *pd = class_data; - int a; - a = va_arg(*list, int); printf("%s %d\n", eo_class_name_get(MY_CLASS), a); pd->a = a; } -static void -_a_print(Eo *obj EINA_UNUSED, void *class_data, va_list *list) +static Eina_Bool +_a_print(Eo *obj EINA_UNUSED, void *class_data) { - const Simple_Public_Data *pd = class_data; - (void) list; + Simple_Public_Data *pd = class_data; printf("Print %s %d\n", eo_class_name_get(MY_CLASS), pd->a); + + return EINA_TRUE; } -static void -_class_print(Eo_Class *klass, void *data EINA_UNUSED, va_list *list) +static Eina_Bool +_class_print(Eo_Class *klass, void *class_data EINA_UNUSED) { - (void) list; printf("Print %s-%s\n", eo_class_name_get(klass), eo_class_name_get(MY_CLASS)); - fail_if(eo_do_super(klass, MY_CLASS, simple_class_print())); - fail_if(eo_do_super(klass, MY_CLASS, simple_class_print2())); + Eina_Bool called = EINA_FALSE; + eo_do_super(klass, MY_CLASS, called = simple_class_print()); + fail_if(called); + + eo_do_super(klass, MY_CLASS, called = simple_class_print2()); + fail_if(called); + + return EINA_TRUE; } -static void -_class_print2(Eo_Class *klass, void *data EINA_UNUSED, va_list *list) +static Eina_Bool +_class_print2(Eo_Class *klass, void *class_data EINA_UNUSED) { - (void) list; printf("Print %s-%s\n", eo_class_name_get(klass), eo_class_name_get(MY_CLASS)); + + return EINA_TRUE; } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_SET), _a_set), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_PRINT), _a_print), - EO_OP_FUNC_CLASS(SIMPLE_ID(SIMPLE_SUB_ID_CLASS_PRINT), _class_print), - EO_OP_FUNC_CLASS(SIMPLE_ID(SIMPLE_SUB_ID_CLASS_PRINT2), _class_print2), - EO_OP_FUNC_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); - eo_class_funcs_set(klass, func_desc); -} - -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_A_SET, "Set property A"), - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_A_PRINT, "Print property A"), - EO_OP_DESCRIPTION_CLASS(SIMPLE_SUB_ID_CLASS_PRINT, "Print class name."), - EO_OP_DESCRIPTION_CLASS(SIMPLE_SUB_ID_CLASS_PRINT2, "Print2 class name."), - EO_OP_DESCRIPTION_SENTINEL +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 = { EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(&SIMPLE_BASE_ID, op_desc, SIMPLE_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Simple_Public_Data), - _class_constructor, + NULL, NULL }; -EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, NULL); +EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_CLASS, NULL); diff --git a/src/tests/eo/function_overrides/function_overrides_simple.h b/src/tests/eo/function_overrides/function_overrides_simple.h index 3a620fa611..e4739685b2 100644 --- a/src/tests/eo/function_overrides/function_overrides_simple.h +++ b/src/tests/eo/function_overrides/function_overrides_simple.h @@ -1,27 +1,15 @@ #ifndef SIMPLE_H #define SIMPLE_H -extern EAPI Eo_Op SIMPLE_BASE_ID; - -enum { - SIMPLE_SUB_ID_A_SET, - SIMPLE_SUB_ID_A_PRINT, - SIMPLE_SUB_ID_CLASS_PRINT, - SIMPLE_SUB_ID_CLASS_PRINT2, - SIMPLE_SUB_ID_LAST -}; - typedef struct { int a; } Simple_Public_Data; -#define SIMPLE_ID(sub_id) (SIMPLE_BASE_ID + sub_id) - -#define simple_a_set(a) SIMPLE_ID(SIMPLE_SUB_ID_A_SET), EO_TYPECHECK(int, a) -#define simple_a_print() SIMPLE_ID(SIMPLE_SUB_ID_A_PRINT) -#define simple_class_print() SIMPLE_ID(SIMPLE_SUB_ID_CLASS_PRINT) -#define simple_class_print2() SIMPLE_ID(SIMPLE_SUB_ID_CLASS_PRINT2) +EAPI void simple_a_set(int a); +EAPI Eina_Bool simple_a_print(void); +EAPI Eina_Bool simple_class_print(void); +EAPI Eina_Bool simple_class_print2(void); extern const Eo_Event_Description _SIG_A_CHANGED; #define SIG_A_CHANGED (&(_SIG_A_CHANGED)) diff --git a/src/tests/eo/interface/interface_interface.c b/src/tests/eo/interface/interface_interface.c index c0dec7649d..7a58a3b8fa 100644 --- a/src/tests/eo/interface/interface_interface.c +++ b/src/tests/eo/interface/interface_interface.c @@ -6,20 +6,20 @@ #include "interface_interface.h" #include "interface_simple.h" -EAPI Eo_Op INTERFACE_BASE_ID = 0; - #define MY_CLASS INTERFACE_CLASS -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(INTERFACE_SUB_ID_AB_SUM_GET, "Get the sum of a and b."), - EO_OP_DESCRIPTION_SENTINEL +EO_FUNC_BODY(interface_ab_sum_get, int, 0); + +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 = { EO_VERSION, "Interface", EO_CLASS_TYPE_INTERFACE, - EO_CLASS_DESCRIPTION_OPS(&INTERFACE_BASE_ID, op_desc, INTERFACE_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, NULL, diff --git a/src/tests/eo/interface/interface_interface.h b/src/tests/eo/interface/interface_interface.h index 4e161b8488..9af90a75ee 100644 --- a/src/tests/eo/interface/interface_interface.h +++ b/src/tests/eo/interface/interface_interface.h @@ -1,22 +1,7 @@ #ifndef INTERFACE_H #define INTERFACE_H -extern EAPI Eo_Op INTERFACE_BASE_ID; - -enum { - INTERFACE_SUB_ID_AB_SUM_GET, - INTERFACE_SUB_ID_LAST -}; - -#define INTERFACE_ID(sub_id) (INTERFACE_BASE_ID + sub_id) - - -/** - * @def interface_ab_sum_get(sum) - * @brief Get sum of a,b integer elements - * @param[out] sum integer pointer to sum - value - */ -#define interface_ab_sum_get(sum) INTERFACE_ID(INTERFACE_SUB_ID_AB_SUM_GET), EO_TYPECHECK(int *, sum) +EAPI int interface_ab_sum_get(void); #define INTERFACE_CLASS interface_class_get() const Eo_Class *interface_class_get(void); diff --git a/src/tests/eo/interface/interface_interface2.c b/src/tests/eo/interface/interface_interface2.c index 14d3f1d0f8..5e29c1712b 100644 --- a/src/tests/eo/interface/interface_interface2.c +++ b/src/tests/eo/interface/interface_interface2.c @@ -7,20 +7,20 @@ #include "interface_interface2.h" #include "interface_simple.h" -EAPI Eo_Op INTERFACE2_BASE_ID = 0; - #define MY_CLASS INTERFACE2_CLASS -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(INTERFACE2_SUB_ID_AB_SUM_GET2, "Print the sum of a and b."), - EO_OP_DESCRIPTION_SENTINEL +EO_FUNC_BODY(interface2_ab_sum_get2, int, 0); + +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 = { EO_VERSION, "Interface2", EO_CLASS_TYPE_INTERFACE, - EO_CLASS_DESCRIPTION_OPS(&INTERFACE2_BASE_ID, op_desc, INTERFACE2_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, NULL, diff --git a/src/tests/eo/interface/interface_interface2.h b/src/tests/eo/interface/interface_interface2.h index 5aa91f4fdc..f02a547d6b 100644 --- a/src/tests/eo/interface/interface_interface2.h +++ b/src/tests/eo/interface/interface_interface2.h @@ -1,22 +1,7 @@ #ifndef INTERFACE2_H #define INTERFACE2_H -extern EAPI Eo_Op INTERFACE2_BASE_ID; - -enum { - INTERFACE2_SUB_ID_AB_SUM_GET2, - INTERFACE2_SUB_ID_LAST -}; - -#define INTERFACE2_ID(sub_id) (INTERFACE2_BASE_ID + sub_id) - - -/** - * @def interface2_ab_sum_get2(sum) - * @brief Get sum of a,b integer elements - * @param[out] sum integer pointer to sum - value - */ -#define interface2_ab_sum_get2(sum) INTERFACE2_ID(INTERFACE2_SUB_ID_AB_SUM_GET2), EO_TYPECHECK(int *, sum) +EAPI int interface2_ab_sum_get2(void); #define INTERFACE2_CLASS interface2_class_get() const Eo_Class *interface2_class_get(void); diff --git a/src/tests/eo/interface/interface_main.c b/src/tests/eo/interface/interface_main.c index 5fa65266f6..40936d42e7 100644 --- a/src/tests/eo/interface/interface_main.c +++ b/src/tests/eo/interface/interface_main.c @@ -20,14 +20,14 @@ main(int argc, char *argv[]) eo_do(obj, simple_a_set(1), simple_b_set(2)); - int a, b, sum = 0; - eo_do(obj, simple_a_get(&a), simple_b_get(&b), interface_ab_sum_get(&sum)); + int a = 0, b = 0, sum = 0; + eo_do(obj, a = simple_a_get(), b = simple_b_get(), sum = interface_ab_sum_get()); fail_if(sum != a + b); sum = 0; - eo_do(obj, interface_ab_sum_get(&sum), interface_ab_sum_get(&sum)); + eo_do(obj, sum = interface_ab_sum_get(), sum = interface_ab_sum_get()); fail_if(sum != a + b); - eo_do(obj, interface2_ab_sum_get2(&sum), interface2_ab_sum_get2(&sum)); + 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 e6f3c156b5..d35e142d3a 100644 --- a/src/tests/eo/interface/interface_simple.c +++ b/src/tests/eo/interface/interface_simple.c @@ -7,8 +7,6 @@ #include "interface_interface2.h" #include "interface_simple.h" -EAPI Eo_Op SIMPLE_BASE_ID = 0; - typedef struct { int a; @@ -18,83 +16,63 @@ typedef struct #define MY_CLASS SIMPLE_CLASS #define _GET_SET_FUNC(name) \ -static void \ -_##name##_get(Eo *obj EINA_UNUSED, void *class_data, va_list *list) \ +static int \ +_##name##_get(Eo *obj EINA_UNUSED, void *class_data) \ { \ const Private_Data *pd = class_data; \ - int *name; \ - name = va_arg(*list, int *); \ - *name = pd->name; \ printf("%s %d\n", __func__, pd->name); \ + return pd->name; \ } \ static void \ -_##name##_set(Eo *obj EINA_UNUSED, void *class_data, va_list *list) \ +_##name##_set(Eo *obj EINA_UNUSED, void *class_data, int name) \ { \ Private_Data *pd = class_data; \ - int name; \ - name = va_arg(*list, int); \ pd->name = name; \ printf("%s %d\n", __func__, pd->name); \ -} +} \ +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 void -_ab_sum_get(Eo *obj, void *class_data EINA_UNUSED, va_list *list) +static int +_ab_sum_get(Eo *obj, void *class_data EINA_UNUSED) { - int a, b; - eo_do(obj, simple_a_get(&a), simple_b_get(&b)); - int *sum = va_arg(*list, int *); - if (sum) - *sum = a + b; + int a = 0, b = 0; + 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; } -static void -_ab_sum_get2(Eo *obj, void *class_data EINA_UNUSED, va_list *list) +static int +_ab_sum_get2(Eo *obj, void *class_data EINA_UNUSED) { - int a, b; - eo_do(obj, simple_a_get(&a), simple_b_get(&b)); - int *sum = va_arg(*list, int *); - if (sum) - *sum = a + b + 1; + int a = 0, b = 0; + 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 void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_SET), _a_set), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_GET), _a_get), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_B_SET), _b_set), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_B_GET), _b_get), - EO_OP_FUNC(INTERFACE_ID(INTERFACE_SUB_ID_AB_SUM_GET), _ab_sum_get), - EO_OP_FUNC(INTERFACE2_ID(INTERFACE2_SUB_ID_AB_SUM_GET2), _ab_sum_get2), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} - -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_A_SET, "Set property A"), - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_A_GET, "Get property A"), - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_B_SET, "Set property B"), - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_B_GET, "Get property B"), - EO_OP_DESCRIPTION_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 = { EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(&SIMPLE_BASE_ID, op_desc, SIMPLE_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Private_Data), - _class_constructor, + NULL, NULL }; -EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, INTERFACE2_CLASS, NULL); +EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_CLASS, INTERFACE2_CLASS, NULL); diff --git a/src/tests/eo/interface/interface_simple.h b/src/tests/eo/interface/interface_simple.h index 8df8131278..c4b3d7bee5 100644 --- a/src/tests/eo/interface/interface_simple.h +++ b/src/tests/eo/interface/interface_simple.h @@ -1,45 +1,10 @@ #ifndef SIMPLE_H #define SIMPLE_H -extern EAPI Eo_Op SIMPLE_BASE_ID; - -enum { - SIMPLE_SUB_ID_A_SET, - SIMPLE_SUB_ID_A_GET, - SIMPLE_SUB_ID_B_SET, - SIMPLE_SUB_ID_B_GET, - SIMPLE_SUB_ID_LAST -}; - -#define SIMPLE_ID(sub_id) (SIMPLE_BASE_ID + sub_id) - -/** - * @def simple_a_set(a) - * @brief Set value to a-property - * @param[in] a integer value to set - */ -#define simple_a_set(a) SIMPLE_ID(SIMPLE_SUB_ID_A_SET), EO_TYPECHECK(int, a) - -/** - * @def simple_a_get(a) - * @brief Get value of a-property - * @param[out] integer pointer to a-value - */ -#define simple_a_get(a) SIMPLE_ID(SIMPLE_SUB_ID_A_GET), EO_TYPECHECK(int *, a) - -/** - * @def simple_b_set(b) - * @brief Set value to b-property - * @param[in] a integer value to set - */ -#define simple_b_set(b) SIMPLE_ID(SIMPLE_SUB_ID_B_SET), EO_TYPECHECK(int, b) - -/** - * @def simple_b_get(b) - * @brief Get value of b-property - * @param[out] integer pointer to b-value - */ -#define simple_b_get(b) SIMPLE_ID(SIMPLE_SUB_ID_B_GET), EO_TYPECHECK(int *, b) +EAPI void simple_a_set(int a); +EAPI int simple_a_get(void); +EAPI void simple_b_set(int b); +EAPI int simple_b_get(void); #define SIMPLE_CLASS simple_class_get() const Eo_Class *simple_class_get(void); diff --git a/src/tests/eo/mixin/mixin_inherit.c b/src/tests/eo/mixin/mixin_inherit.c index 8f9db135df..521acbe721 100644 --- a/src/tests/eo/mixin/mixin_inherit.c +++ b/src/tests/eo/mixin/mixin_inherit.c @@ -9,33 +9,29 @@ #define MY_CLASS INHERIT_CLASS -static void -_a_get(Eo *obj, void *class_data EINA_UNUSED, va_list *list) +static int +_a_get(Eo *obj, void *class_data EINA_UNUSED) { - int *name = va_arg(*list, int *); - eo_do_super(obj, MY_CLASS, simple_a_get(name)); - printf("%s\n", __func__); + int ret = 0; + eo_do_super(obj, MY_CLASS, ret = simple_a_get()); + printf("%s %d\n", __func__, ret); + + return ret; } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_GET), _a_get), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} +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 = { EO_VERSION, "Inherit", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, - _class_constructor, + NULL, NULL }; diff --git a/src/tests/eo/mixin/mixin_main.c b/src/tests/eo/mixin/mixin_main.c index cde8ef984e..6ab6af288e 100644 --- a/src/tests/eo/mixin/mixin_main.c +++ b/src/tests/eo/mixin/mixin_main.c @@ -22,11 +22,11 @@ main(int argc, char *argv[]) eo_do(obj, simple_a_set(1), simple_b_set(2)); - int a, b, sum = 0; - eo_do(obj, simple_a_get(&a), simple_b_get(&b), mixin_ab_sum_get(&sum)); + int a = 0, b = 0, sum = 0; + 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... */ - eo_do(obj, mixin_ab_sum_get(&sum), mixin_ab_sum_get(&sum)); + 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); @@ -37,7 +37,8 @@ main(int argc, char *argv[]) eo_unref(obj); obj = eo_add(INHERIT_CLASS, NULL); - eo_do(obj, simple_a_set(5), simple_a_get(&a)); + eo_do(obj, simple_a_set(5), a = simple_a_get()); + printf("%d\n", a); fail_if(a != 5); eo_unref(obj); diff --git a/src/tests/eo/mixin/mixin_mixin.c b/src/tests/eo/mixin/mixin_mixin.c index ee3342f00b..d91a04fe11 100644 --- a/src/tests/eo/mixin/mixin_mixin.c +++ b/src/tests/eo/mixin/mixin_mixin.c @@ -6,62 +6,48 @@ #include "mixin_mixin.h" #include "mixin_simple.h" -EAPI Eo_Op MIXIN_BASE_ID = 0; - #define MY_CLASS MIXIN_CLASS -static void -_ab_sum_get(Eo *obj, void *class_data EINA_UNUSED, va_list *list) +static int +_ab_sum_get(Eo *obj, void *class_data EINA_UNUSED) { - int a, b; - eo_do(obj, simple_a_get(&a), simple_b_get(&b)); - int *sum = va_arg(*list, int *); - if (sum) - *sum = a + b; + int a = 0, b = 0; + 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; } static void -_constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +_constructor(Eo *obj, void *class_data EINA_UNUSED) { eo_do_super(obj, MY_CLASS, eo_constructor()); } static void -_destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +_destructor(Eo *obj, void *class_data EINA_UNUSED) { eo_do_super(obj, MY_CLASS, eo_destructor()); } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), - EO_OP_FUNC(MIXIN_ID(MIXIN_SUB_ID_AB_SUM_GET), _ab_sum_get), - EO_OP_FUNC_SENTINEL - }; +EAPI EO_FUNC_BODY(mixin_ab_sum_get, int, 0); - eo_class_funcs_set(klass, func_desc); -} - - -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(MIXIN_SUB_ID_AB_SUM_GET, "Get the sum of a and b."), - EO_OP_DESCRIPTION_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 = { EO_VERSION, "Mixin", EO_CLASS_TYPE_MIXIN, - EO_CLASS_DESCRIPTION_OPS(&MIXIN_BASE_ID, op_desc, MIXIN_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, - _class_constructor, + NULL, NULL }; -EO_DEFINE_CLASS(mixin_class_get, &class_desc, NULL, NULL) +EO_DEFINE_CLASS(mixin_class_get, &class_desc, NULL, EO_CLASS, NULL) diff --git a/src/tests/eo/mixin/mixin_mixin.h b/src/tests/eo/mixin/mixin_mixin.h index 745e5c4683..e97b609ab0 100644 --- a/src/tests/eo/mixin/mixin_mixin.h +++ b/src/tests/eo/mixin/mixin_mixin.h @@ -1,22 +1,7 @@ #ifndef MIXIN_H #define MIXIN_H -extern EAPI Eo_Op MIXIN_BASE_ID; - -enum { - MIXIN_SUB_ID_AB_SUM_GET, - MIXIN_SUB_ID_LAST -}; - -#define MIXIN_ID(sub_id) (MIXIN_BASE_ID + sub_id) - - -/** - * @def mixin_ab_sum_get(sum) - * @brief Get sum of a,b integer elements - * @param[out] sum integer pointer to sum - value - */ -#define mixin_ab_sum_get(sum) MIXIN_ID(MIXIN_SUB_ID_AB_SUM_GET), EO_TYPECHECK(int *, sum) +EAPI int mixin_ab_sum_get(void); #define MIXIN_CLASS mixin_class_get() const Eo_Class *mixin_class_get(void); diff --git a/src/tests/eo/mixin/mixin_mixin2.c b/src/tests/eo/mixin/mixin_mixin2.c index 451a8ec1ca..6df0a85fec 100644 --- a/src/tests/eo/mixin/mixin_mixin2.c +++ b/src/tests/eo/mixin/mixin_mixin2.c @@ -11,23 +11,25 @@ #define MY_CLASS MIXIN2_CLASS -static void -_ab_sum_get(Eo *obj, void *class_data, va_list *list) +static int +_ab_sum_get(Eo *obj, void *class_data) { /* This cast is a hack just for the tests... */ Mixin2_Public_Data *pd = (Mixin2_Public_Data *) class_data; - int *sum = va_arg(*list, int *); + int sum = 0; printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__); - eo_do_super(obj, MY_CLASS, mixin_ab_sum_get(sum)); + eo_do_super(obj, MY_CLASS, sum = mixin_ab_sum_get()); - ++*sum; + ++sum; pd->count += 2; { - int _a, _b; - eo_do(obj, simple_a_get(&_a), simple_b_get(&_b)); - fail_if(*sum != _a + _b + 1); + int _a = 0, _b = 0; + eo_do(obj, _a = simple_a_get(), _b = simple_b_get()); + fail_if(sum != _a + _b + 1); } + + return sum; } static void @@ -42,27 +44,21 @@ _destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) eo_do_super(obj, MY_CLASS, eo_destructor()); } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), - EO_OP_FUNC(MIXIN_ID(MIXIN_SUB_ID_AB_SUM_GET), _ab_sum_get), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} +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 = { EO_VERSION, "Mixin2", EO_CLASS_TYPE_MIXIN, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Mixin2_Public_Data), - _class_constructor, + NULL, NULL }; diff --git a/src/tests/eo/mixin/mixin_mixin3.c b/src/tests/eo/mixin/mixin_mixin3.c index 6ad66e1172..6d0d99d4f8 100644 --- a/src/tests/eo/mixin/mixin_mixin3.c +++ b/src/tests/eo/mixin/mixin_mixin3.c @@ -11,23 +11,25 @@ #define MY_CLASS MIXIN3_CLASS -static void -_ab_sum_get(Eo *obj, void *class_data EINA_UNUSED, va_list *list) +static int +_ab_sum_get(Eo *obj, void *class_data EINA_UNUSED) { /* This cast is just a hack for the test. */ Mixin3_Public_Data *pd = (Mixin3_Public_Data *) class_data; - int *sum = va_arg(*list, int *); + int sum = 0; printf("%s %s\n", eo_class_name_get(MY_CLASS), __func__); - eo_do_super(obj, MY_CLASS, mixin_ab_sum_get(sum)); + eo_do_super(obj, MY_CLASS, sum = mixin_ab_sum_get()); - ++*sum; + ++sum; pd->count += 3; { - int _a, _b; - eo_do(obj, simple_a_get(&_a), simple_b_get(&_b)); - fail_if(*sum != _a + _b + 2); + int _a = 0, _b = 0; + eo_do(obj, _a = simple_a_get(), _b = simple_b_get()); + fail_if(sum != _a + _b + 2); } + + return sum; } static void @@ -42,27 +44,21 @@ _destructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) eo_do_super(obj, MY_CLASS, eo_destructor()); } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _destructor), - EO_OP_FUNC(MIXIN_ID(MIXIN_SUB_ID_AB_SUM_GET), _ab_sum_get), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} +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 = { EO_VERSION, "Mixin3", EO_CLASS_TYPE_MIXIN, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Mixin3_Public_Data), - _class_constructor, + NULL, NULL }; diff --git a/src/tests/eo/mixin/mixin_mixin4.c b/src/tests/eo/mixin/mixin_mixin4.c index cf8f16f965..f4e312f77b 100644 --- a/src/tests/eo/mixin/mixin_mixin4.c +++ b/src/tests/eo/mixin/mixin_mixin4.c @@ -15,7 +15,7 @@ static const Eo_Class_Description class_desc = { EO_VERSION, "Mixin4", EO_CLASS_TYPE_MIXIN, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + 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 ff4600d727..0212939580 100644 --- a/src/tests/eo/mixin/mixin_simple.c +++ b/src/tests/eo/mixin/mixin_simple.c @@ -8,8 +8,6 @@ #include "mixin_mixin3.h" #include "mixin_simple.h" -EAPI Eo_Op SIMPLE_BASE_ID = 0; - typedef struct { int a; @@ -19,59 +17,45 @@ typedef struct #define MY_CLASS SIMPLE_CLASS #define _GET_SET_FUNC(name) \ -static void \ -_##name##_get(Eo *obj EINA_UNUSED, void *class_data, va_list *list) \ +static int \ +_##name##_get(Eo *obj EINA_UNUSED, void *class_data) \ { \ const Private_Data *pd = class_data; \ - int *name; \ - name = va_arg(*list, int *); \ - *name = pd->name; \ printf("%s %d\n", __func__, pd->name); \ + return pd->name; \ } \ static void \ -_##name##_set(Eo *obj EINA_UNUSED, void *class_data, va_list *list) \ +_##name##_set(Eo *obj EINA_UNUSED, void *class_data, int name) \ { \ Private_Data *pd = class_data; \ - int name; \ - name = va_arg(*list, int); \ pd->name = name; \ printf("%s %d\n", __func__, pd->name); \ -} +} \ +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 void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_SET), _a_set), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_GET), _a_get), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_B_SET), _b_set), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_B_GET), _b_get), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} - -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_A_SET, "Set property A"), - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_A_GET, "Get property A"), - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_B_SET, "Set property B"), - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_B_GET, "Get property B"), - EO_OP_DESCRIPTION_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 = { EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(&SIMPLE_BASE_ID, op_desc, SIMPLE_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Private_Data), - _class_constructor, + NULL, NULL }; -EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, MIXIN3_CLASS, MIXIN2_CLASS, NULL); +EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_CLASS, + MIXIN3_CLASS, MIXIN2_CLASS, NULL); + diff --git a/src/tests/eo/mixin/mixin_simple.h b/src/tests/eo/mixin/mixin_simple.h index 8df8131278..c4b3d7bee5 100644 --- a/src/tests/eo/mixin/mixin_simple.h +++ b/src/tests/eo/mixin/mixin_simple.h @@ -1,45 +1,10 @@ #ifndef SIMPLE_H #define SIMPLE_H -extern EAPI Eo_Op SIMPLE_BASE_ID; - -enum { - SIMPLE_SUB_ID_A_SET, - SIMPLE_SUB_ID_A_GET, - SIMPLE_SUB_ID_B_SET, - SIMPLE_SUB_ID_B_GET, - SIMPLE_SUB_ID_LAST -}; - -#define SIMPLE_ID(sub_id) (SIMPLE_BASE_ID + sub_id) - -/** - * @def simple_a_set(a) - * @brief Set value to a-property - * @param[in] a integer value to set - */ -#define simple_a_set(a) SIMPLE_ID(SIMPLE_SUB_ID_A_SET), EO_TYPECHECK(int, a) - -/** - * @def simple_a_get(a) - * @brief Get value of a-property - * @param[out] integer pointer to a-value - */ -#define simple_a_get(a) SIMPLE_ID(SIMPLE_SUB_ID_A_GET), EO_TYPECHECK(int *, a) - -/** - * @def simple_b_set(b) - * @brief Set value to b-property - * @param[in] a integer value to set - */ -#define simple_b_set(b) SIMPLE_ID(SIMPLE_SUB_ID_B_SET), EO_TYPECHECK(int, b) - -/** - * @def simple_b_get(b) - * @brief Get value of b-property - * @param[out] integer pointer to b-value - */ -#define simple_b_get(b) SIMPLE_ID(SIMPLE_SUB_ID_B_GET), EO_TYPECHECK(int *, b) +EAPI void simple_a_set(int a); +EAPI int simple_a_get(void); +EAPI void simple_b_set(int b); +EAPI int simple_b_get(void); #define SIMPLE_CLASS simple_class_get() const Eo_Class *simple_class_get(void); diff --git a/src/tests/eo/signals/signals_main.c b/src/tests/eo/signals/signals_main.c index 7c7b786977..4886d35b5f 100644 --- a/src/tests/eo/signals/signals_main.c +++ b/src/tests/eo/signals/signals_main.c @@ -79,15 +79,15 @@ main(int argc, char *argv[]) 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); - eo_do(obj, eo_event_freeze_get(&fcount)); + eo_do(obj, fcount = eo_event_freeze_get()); fail_if(fcount != 0); eo_do(obj, eo_event_freeze()); - eo_do(obj, eo_event_freeze_get(&fcount)); + eo_do(obj, fcount = eo_event_freeze_get()); fail_if(fcount != 1); eo_do(obj, eo_event_freeze()); - eo_do(obj, eo_event_freeze_get(&fcount)); + eo_do(obj, fcount = eo_event_freeze_get()); fail_if(fcount != 2); eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2)); @@ -96,11 +96,11 @@ main(int argc, char *argv[]) eo_do(obj, simple_a_set(2)); fail_if(cb_count != 0); eo_do(obj, eo_event_thaw()); - eo_do(obj, eo_event_freeze_get(&fcount)); + eo_do(obj, fcount = eo_event_freeze_get()); fail_if(fcount != 1); eo_do(obj, eo_event_thaw()); - eo_do(obj, eo_event_freeze_get(&fcount)); + eo_do(obj, fcount = eo_event_freeze_get()); fail_if(fcount != 0); eo_do(obj, simple_a_set(3)); @@ -108,17 +108,17 @@ main(int argc, char *argv[]) cb_count = 0; eo_do(obj, eo_event_thaw()); - eo_do(obj, eo_event_freeze_get(&fcount)); + eo_do(obj, fcount = eo_event_freeze_get()); fail_if(fcount != 0); eo_do(obj, eo_event_freeze()); - eo_do(obj, eo_event_freeze_get(&fcount)); + eo_do(obj, fcount = eo_event_freeze_get()); fail_if(fcount != 1); eo_do(obj, simple_a_set(2)); fail_if(cb_count != 0); eo_do(obj, eo_event_thaw()); - eo_do(obj, eo_event_freeze_get(&fcount)); + eo_do(obj, fcount = eo_event_freeze_get()); fail_if(fcount != 0); eo_do(obj, eo_event_callback_del(EV_A_CHANGED, _a_changed_cb, (void *) 1)); @@ -133,15 +133,15 @@ main(int argc, char *argv[]) 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); - eo_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount)); + eo_do(EO_CLASS, fcount = eo_event_global_freeze_get()); fail_if(fcount != 0); - eo_do(EO_BASE_CLASS, eo_event_global_freeze()); - eo_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount)); + eo_do(EO_CLASS, eo_event_global_freeze()); + eo_do(EO_CLASS, fcount = eo_event_global_freeze_get()); fail_if(fcount != 1); - eo_do(EO_BASE_CLASS, eo_event_global_freeze()); - eo_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount)); + eo_do(EO_CLASS, eo_event_global_freeze()); + eo_do(EO_CLASS, fcount = eo_event_global_freeze_get()); fail_if(fcount != 2); eo_do(obj, eo_event_callback_priority_add(EV_A_CHANGED, EO_CALLBACK_PRIORITY_BEFORE, _a_changed_cb, (void *) 2)); @@ -149,30 +149,30 @@ main(int argc, char *argv[]) eo_do(obj, simple_a_set(2)); fail_if(cb_count != 0); - eo_do(EO_BASE_CLASS, eo_event_global_thaw()); - eo_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount)); + eo_do(EO_CLASS, eo_event_global_thaw()); + eo_do(EO_CLASS, fcount = eo_event_global_freeze_get()); fail_if(fcount != 1); - eo_do(EO_BASE_CLASS, eo_event_global_thaw()); - eo_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount)); + eo_do(EO_CLASS, eo_event_global_thaw()); + eo_do(EO_CLASS, fcount = eo_event_global_freeze_get()); fail_if(fcount != 0); eo_do(obj, simple_a_set(3)); fail_if(cb_count != 2); cb_count = 0; - eo_do(EO_BASE_CLASS, eo_event_global_thaw()); - eo_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount)); + eo_do(EO_CLASS, eo_event_global_thaw()); + eo_do(EO_CLASS, fcount = eo_event_global_freeze_get()); fail_if(fcount != 0); - eo_do(EO_BASE_CLASS, eo_event_global_freeze()); - eo_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount)); + eo_do(EO_CLASS, eo_event_global_freeze()); + eo_do(EO_CLASS, fcount = eo_event_global_freeze_get()); fail_if(fcount != 1); eo_do(obj, simple_a_set(2)); fail_if(cb_count != 0); - eo_do(EO_BASE_CLASS, eo_event_global_thaw()); - eo_do(EO_BASE_CLASS, eo_event_global_freeze_get(&fcount)); + eo_do(EO_CLASS, eo_event_global_thaw()); + eo_do(EO_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 1417988bbc..a928cec854 100644 --- a/src/tests/eo/signals/signals_simple.c +++ b/src/tests/eo/signals/signals_simple.c @@ -5,8 +5,6 @@ #include "Eo.h" #include "signals_simple.h" -EAPI Eo_Op SIMPLE_BASE_ID = 0; - typedef struct { Simple_Public_Data pub; @@ -19,15 +17,13 @@ EAPI const Eo_Event_Description _EV_A_CHANGED = #define MY_CLASS SIMPLE_CLASS static void -_a_set(Eo *obj, void *class_data, va_list *list) +_a_set(Eo *obj, void *class_data, int a) { Private_Data *pd = class_data; - int a; - a = va_arg(*list, int); pd->a = a; printf("%s %d\n", __func__, pd->a); - eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a, NULL)); + eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a)); } Eina_Bool @@ -65,33 +61,25 @@ _cb_deled(void *data, Eo *obj, const Eo_Event_Description *desc, void *event_inf } static void -_constructor(Eo *obj, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +_constructor(Eo *obj, void *class_data EINA_UNUSED) { eo_do_super(obj, MY_CLASS, eo_constructor()); 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)); - eo_do(obj, eo_base_data_set("cb_count", (intptr_t) 0, NULL)); + eo_do(obj, eo_key_data_set("cb_count", (intptr_t) 0, NULL)); } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _constructor), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_SET), _a_set), - EO_OP_FUNC_SENTINEL - }; +EAPI EO_VOID_FUNC_BODYV(simple_a_set, EO_FUNC_CALL(a), int a); - eo_class_funcs_set(klass, func_desc); -} - -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_A_SET, "Set property A"), - EO_OP_DESCRIPTION_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 }; + static const Eo_Event_Description *event_desc[] = { EV_A_CHANGED, NULL @@ -101,12 +89,12 @@ static const Eo_Class_Description class_desc = { EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(&SIMPLE_BASE_ID, op_desc, SIMPLE_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), event_desc, sizeof(Private_Data), - _class_constructor, + NULL, NULL }; -EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, NULL); +EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_CLASS, NULL); diff --git a/src/tests/eo/signals/signals_simple.h b/src/tests/eo/signals/signals_simple.h index d1f63bdd06..ba50f98b4c 100644 --- a/src/tests/eo/signals/signals_simple.h +++ b/src/tests/eo/signals/signals_simple.h @@ -1,26 +1,12 @@ #ifndef SIMPLE_H #define SIMPLE_H -extern EAPI Eo_Op SIMPLE_BASE_ID; - -enum { - SIMPLE_SUB_ID_A_SET, - SIMPLE_SUB_ID_LAST -}; - typedef struct { int cb_count; } Simple_Public_Data; -#define SIMPLE_ID(sub_id) (SIMPLE_BASE_ID + sub_id) - -/** - * @def simple_a_set(a) - * @brief Set value to a - property - * @param[in] a integer value to set - */ -#define simple_a_set(a) SIMPLE_ID(SIMPLE_SUB_ID_A_SET), EO_TYPECHECK(int, a) +EAPI void simple_a_set(int a); extern const Eo_Event_Description _EV_A_CHANGED; #define EV_A_CHANGED (&(_EV_A_CHANGED)) diff --git a/src/tests/eo/suite/eo_error_msgs.c b/src/tests/eo/suite/eo_error_msgs.c new file mode 100644 index 0000000000..ae5b5d0ddc --- /dev/null +++ b/src/tests/eo/suite/eo_error_msgs.c @@ -0,0 +1,53 @@ +#include "eo_error_msgs.h" + +void +eo_test_print_cb(const Eina_Log_Domain *d, Eina_Log_Level level, const char *file, const char *fnc, int line, const char *fmt, void *data, va_list args EINA_UNUSED) +{ + struct log_ctx *myctx = data; + + if (level > _EINA_LOG_MAX) + return; + + ck_assert_int_eq(level, myctx->expected_level); + if (myctx->msg) + ck_assert_str_eq(myctx->msg, fmt); + ck_assert_str_eq(myctx->fnc, fnc); + myctx->did = EINA_TRUE; + +#ifdef SHOW_LOG + eina_log_print_cb_stderr(d, level, file, fnc, line, fmt, NULL, args); +#else + (void)d; + (void)file; + (void)line; +#endif +} + +void +eo_test_safety_print_cb(const Eina_Log_Domain *d, Eina_Log_Level level, const char *file, const char *fnc, int line, const char *fmt, void *data, va_list args EINA_UNUSED) +{ + struct log_ctx *myctx = data; + va_list cp_args; + const char *str; + + if (level > _EINA_LOG_MAX) + return; + + va_copy(cp_args, args); + str = va_arg(cp_args, const char *); + va_end(cp_args); + + ck_assert_int_eq(level, myctx->expected_level); + ck_assert_str_eq(fmt, "%s"); + ck_assert_str_eq(myctx->msg, str); + ck_assert_str_eq(myctx->fnc, fnc); + myctx->did = EINA_TRUE; + +#ifdef SHOW_LOG + eina_log_print_cb_stderr(d, level, file, fnc, line, fmt, NULL, args); +#else + (void)d; + (void)file; + (void)line; +#endif +} diff --git a/src/tests/eo/suite/eo_error_msgs.h b/src/tests/eo/suite/eo_error_msgs.h new file mode 100644 index 0000000000..c3690fd345 --- /dev/null +++ b/src/tests/eo/suite/eo_error_msgs.h @@ -0,0 +1,30 @@ +#ifndef _EO_ERROR_MSGS_H +#define _EO_ERROR_MSGS_H + +#include "Eo.h" +#include "eo_suite.h" + +/* The Max level to consider when working with the print cb. */ +#define _EINA_LOG_MAX 2 +/* #define SHOW_LOG 1 */ + +struct log_ctx { + const char *msg; + const char *fnc; + Eina_Bool did; + int expected_level; +}; + +void +eo_test_print_cb(const Eina_Log_Domain *d, Eina_Log_Level level, const char *file, const char *fnc, int line, const char *fmt, void *data, va_list args EINA_UNUSED); + +void +eo_test_safety_print_cb(const Eina_Log_Domain *d, Eina_Log_Level level, const char *file, const char *fnc, int line, const char *fmt, void *data, va_list args EINA_UNUSED); + +#define TEST_EO_ERROR(fn, _msg) \ + ctx.msg = _msg; \ + ctx.fnc = fn; \ + ctx.did = EINA_FALSE; \ + ctx.expected_level = EINA_LOG_LEVEL_ERR + +#endif /* _EO_ERROR_MSGS_H */ diff --git a/src/tests/eo/suite/eo_suite.c b/src/tests/eo/suite/eo_suite.c index 9d040d32cc..42c6645156 100644 --- a/src/tests/eo/suite/eo_suite.c +++ b/src/tests/eo/suite/eo_suite.c @@ -20,7 +20,9 @@ static const Eo_Test_Case etc[] = { { "Eo init", eo_test_init }, { "Eo general", eo_test_general }, { "Eo class errors", eo_test_class_errors }, + { "Eo call errors", eo_test_call_errors }, { "Eo eina value", eo_test_value }, + { "Eo threaded eo calls", eo_test_threaded_calls }, { NULL, NULL } }; diff --git a/src/tests/eo/suite/eo_suite.h b/src/tests/eo/suite/eo_suite.h index c26db968be..94d88bd1fe 100644 --- a/src/tests/eo/suite/eo_suite.h +++ b/src/tests/eo/suite/eo_suite.h @@ -6,6 +6,8 @@ void eo_test_init(TCase *tc); void eo_test_general(TCase *tc); void eo_test_class_errors(TCase *tc); +void eo_test_call_errors(TCase *tc); void eo_test_value(TCase *tc); +void eo_test_threaded_calls(TCase *tc); #endif /* _EO_SUITE_H */ diff --git a/src/tests/eo/suite/eo_test_call_errors.c b/src/tests/eo/suite/eo_test_call_errors.c new file mode 100644 index 0000000000..08e1635a7d --- /dev/null +++ b/src/tests/eo/suite/eo_test_call_errors.c @@ -0,0 +1,73 @@ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include + +#include "Eo.h" +#include "eo_suite.h" +#include "eo_error_msgs.h" +#include "eo_test_class_simple.h" + +static struct log_ctx ctx; + +START_TEST(eo_pure_virtual_fct_call) +{ + eo_init(); + eina_log_print_cb_set(eo_test_print_cb, &ctx); + + Eo *obj = eo_add(SIMPLE_CLASS, NULL); + fail_if(!obj); + + 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); + eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); + eo_shutdown(); +} +END_TEST + +START_TEST(eo_api_not_implemented_call) +{ + eo_init(); + eina_log_print_cb_set(eo_test_print_cb, &ctx); + + Eo *obj = eo_add(SIMPLE_CLASS, NULL); + fail_if(!obj); + + 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); + eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); + eo_shutdown(); +} +END_TEST + +START_TEST(eo_op_not_found_in_super) +{ + eo_init(); + eina_log_print_cb_set(eo_test_print_cb, &ctx); + + Eo *obj = eo_add(SIMPLE_CLASS, NULL); + fail_if(!obj); + + 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); + eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); + eo_shutdown(); +} +END_TEST + +void eo_test_call_errors(TCase *tc) +{ + tcase_add_test(tc, eo_pure_virtual_fct_call); + tcase_add_test(tc, eo_api_not_implemented_call); + tcase_add_test(tc, eo_op_not_found_in_super); +} diff --git a/src/tests/eo/suite/eo_test_class_errors.c b/src/tests/eo/suite/eo_test_class_errors.c index 5b1f8e6947..cd9ddf5b55 100644 --- a/src/tests/eo/suite/eo_test_class_errors.c +++ b/src/tests/eo/suite/eo_test_class_errors.c @@ -6,185 +6,15 @@ #include "Eo.h" #include "eo_suite.h" +#include "eo_error_msgs.h" #include "eo_test_class_simple.h" -/* The Max level to consider when working with the print cb. */ -#define _EINA_LOG_MAX 2 - -struct log_ctx { - const char *msg; - const char *fnc; - Eina_Bool did; - int expected_level; -}; - static struct log_ctx ctx; -static void -_eo_test_print_cb(const Eina_Log_Domain *d, Eina_Log_Level level, const char *file, const char *fnc, int line, const char *fmt, void *data, va_list args EINA_UNUSED) -{ - struct log_ctx *myctx = data; - - if (level > _EINA_LOG_MAX) - return; - - ck_assert_int_eq(level, myctx->expected_level); - if (myctx->msg) - ck_assert_str_eq(myctx->msg, fmt); - ck_assert_str_eq(myctx->fnc, fnc); - myctx->did = EINA_TRUE; - -#ifdef SHOW_LOG - eina_log_print_cb_stderr(d, level, file, fnc, line, fmt, NULL, args); -#else - (void)d; - (void)file; - (void)line; -#endif -} - -static void -_eo_test_safety_print_cb(const Eina_Log_Domain *d, Eina_Log_Level level, const char *file, const char *fnc, int line, const char *fmt, void *data, va_list args EINA_UNUSED) -{ - struct log_ctx *myctx = data; - va_list cp_args; - const char *str; - - if (level > _EINA_LOG_MAX) - return; - - va_copy(cp_args, args); - str = va_arg(cp_args, const char *); - va_end(cp_args); - - ck_assert_int_eq(level, myctx->expected_level); - ck_assert_str_eq(fmt, "%s"); - ck_assert_str_eq(myctx->msg, str); - ck_assert_str_eq(myctx->fnc, fnc); - myctx->did = EINA_TRUE; - -#ifdef SHOW_LOG - eina_log_print_cb_stderr(d, level, file, fnc, line, fmt, NULL, args); -#else - (void)d; - (void)file; - (void)line; -#endif -} - -#define TEST_EO_ERROR(fn, _msg) \ - ctx.msg = _msg; \ - ctx.fnc = fn; \ - ctx.did = EINA_FALSE; \ - ctx.expected_level = EINA_LOG_LEVEL_ERR - -START_TEST(eo_incomplete_desc) -{ - eo_init(); - eina_log_print_cb_set(_eo_test_print_cb, &ctx); - - const Eo_Class *klass; - static Eo_Op TMP_BASE_ID = EO_NOOP; - - enum { - TEST_SUB_ID_FOO, - TEST_SUB_ID_FOO2, - TEST_SUB_ID_LAST - }; - - static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(TEST_SUB_ID_FOO, "Foo"), - EO_OP_DESCRIPTION(TEST_SUB_ID_FOO2, "Foo2"), - EO_OP_DESCRIPTION_SENTINEL - }; - - static const Eo_Op_Description op_desc_wrong[] = { - EO_OP_DESCRIPTION(TEST_SUB_ID_FOO2, "Foo2"), - EO_OP_DESCRIPTION(TEST_SUB_ID_FOO, "Foo"), - EO_OP_DESCRIPTION_SENTINEL - }; - - /* XXX: In real life this should be const, this is just for testing. */ - static Eo_Class_Description class_desc = { - EO_VERSION, - "Simple", - EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, op_desc, 1), - NULL, - 0, - NULL, - NULL - }; - - TEST_EO_ERROR("_eo_class_check_op_descs", "Class '%s' has a non-zero ops count, but base_id is NULL."); - klass = eo_class_new(&class_desc, NULL, NULL); - fail_if(klass); - fail_unless(ctx.did); - - class_desc.ops.base_op_id = &TMP_BASE_ID; - class_desc.ops.descs = NULL; - - TEST_EO_ERROR("_eo_class_check_op_descs", "Class '%s' has a non-zero ops count, but there are no descs."); - klass = eo_class_new(&class_desc, NULL, NULL); - fail_if(klass); - fail_unless(ctx.did); - - class_desc.ops.descs = op_desc; - class_desc.ops.count = TEST_SUB_ID_LAST + 1; - - TEST_EO_ERROR("_eo_class_check_op_descs", "Found too few Ops description for class '%s'. Expected 0x%lx descriptions, but found 0x%lx."); - klass = eo_class_new(&class_desc, NULL, NULL); - fail_if(klass); - fail_unless(ctx.did); - - class_desc.ops.count = 0; - - TEST_EO_ERROR("_eo_class_check_op_descs", "Found extra Ops description for class '%s'. Expected %lu descriptions, but found more."); - klass = eo_class_new(&class_desc, NULL, NULL); - fail_if(klass); - fail_unless(ctx.did); - - class_desc.ops.count = TEST_SUB_ID_LAST; - class_desc.ops.descs = op_desc_wrong; - - TEST_EO_ERROR("_eo_class_check_op_descs", "Wrong order in Ops description for class '%s'. Expected 0x%lx and got 0x%lx"); - klass = eo_class_new(&class_desc, NULL, NULL); - fail_if(klass); - fail_unless(ctx.did); - - class_desc.ops.descs = op_desc; - class_desc.name = NULL; - - eina_log_print_cb_set(_eo_test_safety_print_cb, &ctx); - - TEST_EO_ERROR("eo_class_new", "safety check failed: desc->name == NULL"); - klass = eo_class_new(&class_desc, NULL, NULL); - fail_if(klass); - fail_unless(ctx.did); - - class_desc.name = "Simple"; - - - TEST_EO_ERROR("eo_class_new", "safety check failed: desc == NULL"); - klass = eo_class_new(NULL, NULL, NULL); - fail_if(klass); - fail_unless(ctx.did); - - /* Should create a class. */ - klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL); - fail_if(!klass); - - (void) klass; - eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); - - eo_shutdown(); -} -END_TEST - START_TEST(eo_inherit_errors) { eo_init(); - eina_log_print_cb_set(_eo_test_print_cb, &ctx); + eina_log_print_cb_set(eo_test_print_cb, &ctx); const Eo_Class *klass; const Eo_Class *klass_mixin; @@ -194,7 +24,7 @@ START_TEST(eo_inherit_errors) EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -205,7 +35,7 @@ START_TEST(eo_inherit_errors) EO_VERSION, "Mixin", EO_CLASS_TYPE_MIXIN, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -216,7 +46,7 @@ START_TEST(eo_inherit_errors) EO_VERSION, "General", EO_CLASS_TYPE_MIXIN, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -226,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, EO_BASE_CLASS, NULL); + klass_simple = eo_class_new(&class_desc_simple, EO_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')."); @@ -251,7 +81,7 @@ END_TEST START_TEST(eo_inconsistent_mro) { eo_init(); - eina_log_print_cb_set(_eo_test_print_cb, &ctx); + eina_log_print_cb_set(eo_test_print_cb, &ctx); const Eo_Class *klass; const Eo_Class *klass_mixin; @@ -262,7 +92,7 @@ START_TEST(eo_inconsistent_mro) EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -273,7 +103,7 @@ START_TEST(eo_inconsistent_mro) EO_VERSION, "Mixin", EO_CLASS_TYPE_MIXIN, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -284,7 +114,7 @@ START_TEST(eo_inconsistent_mro) EO_VERSION, "Mixin2", EO_CLASS_TYPE_MIXIN, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -295,7 +125,7 @@ START_TEST(eo_inconsistent_mro) EO_VERSION, "Mixin3", EO_CLASS_TYPE_MIXIN, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -312,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, EO_BASE_CLASS, klass_mixin, klass_mixin2, NULL); + klass = eo_class_new(&class_desc_simple, EO_CLASS, klass_mixin, klass_mixin2, NULL); fail_if(klass); fail_unless(ctx.did); - klass = eo_class_new(&class_desc_simple, EO_BASE_CLASS, klass_mixin2, klass_mixin, NULL); + klass = eo_class_new(&class_desc_simple, EO_CLASS, klass_mixin2, klass_mixin, NULL); fail_if(!klass); - klass = eo_class_new(&class_desc_simple, EO_BASE_CLASS, klass_mixin2, klass_mixin3, NULL); + klass = eo_class_new(&class_desc_simple, EO_CLASS, klass_mixin2, klass_mixin3, NULL); fail_if(!klass); eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); @@ -333,7 +163,7 @@ static void _stub_class_constructor(Eo_Class *klass EINA_UNUSED) {} START_TEST(eo_bad_interface) { eo_init(); - eina_log_print_cb_set(_eo_test_safety_print_cb, &ctx); + eina_log_print_cb_set(eo_test_safety_print_cb, &ctx); const Eo_Class *klass; @@ -341,7 +171,7 @@ START_TEST(eo_bad_interface) EO_VERSION, "Interface", EO_CLASS_TYPE_INTERFACE, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 10, NULL, @@ -376,77 +206,136 @@ START_TEST(eo_bad_interface) } END_TEST -static int _const_ops_counter = 0; +static void _null_fct(Eo *eo_obj EINA_UNUSED, void *d EINA_UNUSED) { } +void null_fct (void) {} -static void -_const_ops_a_set(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, va_list *list) -{ - int a = va_arg(*list, int); - (void) a; - _const_ops_counter++; -} - -static void -_const_ops_a_print(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) -{ - _const_ops_counter++; -} - -static void -_const_ops_class_hi_print(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) -{ - _const_ops_counter++; -} - -static void -_const_ops_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_SET), _const_ops_a_set), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_PRINT), _const_ops_a_print), - EO_OP_FUNC_CLASS(SIMPLE_ID(SIMPLE_SUB_ID_A_SET), _const_ops_a_set), - EO_OP_FUNC_CLASS(SIMPLE_ID(SIMPLE_SUB_ID_A_PRINT), _const_ops_a_print), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_CLASS_HI_PRINT), _const_ops_class_hi_print), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_CLASS_HI_PRINT), _const_ops_class_hi_print), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} - -START_TEST(eo_op_types) +START_TEST(eo_null_api) { eo_init(); - eina_log_print_cb_set(_eo_test_print_cb, &ctx); + eina_log_print_cb_set(eo_test_print_cb, &ctx); const Eo_Class *klass; + static Eo_Op_Description op_descs[] = { + EO_OP_FUNC(NULL, _null_fct, "NULL API function"), + EO_OP_SENTINEL + }; static Eo_Class_Description class_desc = { EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 0, - _const_ops_class_constructor, + NULL, NULL }; - TEST_EO_ERROR("eo_class_funcs_set", "Set function's op type (0x%x) is different than the one in the op description (%d) for op '%s:%s'. Func index: %lu"); + 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); + + eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); + + eo_shutdown(); +} +END_TEST + +START_TEST(eo_wrong_override) +{ + eo_init(); + eina_log_print_cb_set(eo_test_print_cb, &ctx); + + const Eo_Class *klass; + + static Eo_Op_Description op_descs[] = { + EO_OP_FUNC_OVERRIDE(null_fct, _null_fct), + EO_OP_SENTINEL + }; + static Eo_Class_Description class_desc = { + EO_VERSION, + "Simple", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(op_descs), + NULL, + 0, + NULL, + NULL + }; + + TEST_EO_ERROR("_eo_class_funcs_set", "Class '%s': Can't find api func description in class hierarchy (%p->%p) (%s)."); + klass = eo_class_new(&class_desc, NULL, NULL); + fail_if(klass); + fail_unless(ctx.did); + + eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); + + eo_shutdown(); +} +END_TEST + +START_TEST(eo_api_redefined) +{ + eo_init(); + eina_log_print_cb_set(eo_test_print_cb, &ctx); + + const Eo_Class *klass; + + 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 = { + EO_VERSION, + "Simple", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(op_descs), + NULL, + 0, + NULL, + NULL + }; + + 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); + + eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); + + eo_shutdown(); +} +END_TEST + +START_TEST(eo_dich_func_override) +{ + eo_init(); + eina_log_print_cb_set(eo_test_print_cb, &ctx); + + const Eo_Class *klass; + + 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 = { + EO_VERSION, + "Simple", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(op_descs), + NULL, + 0, + NULL, + NULL + }; + + TEST_EO_ERROR("_dich_func_set", "Class '%s': Overriding func %p for op %d (%s:'%s') with %p."); klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL); - fail_if(!klass); - - TEST_EO_ERROR("eo_class_name_get", NULL); -#ifdef HAVE_EO_ID - ctx.expected_level = EINA_LOG_LEVEL_ERR; -#else - ctx.expected_level = EINA_LOG_LEVEL_CRITICAL; -#endif - /* Add class checks here... */ - Eo *obj = eo_add(klass, NULL); - eo_do(obj, simple_a_set(7), simple_a_print(), simple_class_hi_print()); - - eo_unref(obj); + fail_if(klass); + fail_unless(ctx.did); eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); @@ -456,9 +345,11 @@ END_TEST void eo_test_class_errors(TCase *tc) { - tcase_add_test(tc, eo_incomplete_desc); tcase_add_test(tc, eo_inherit_errors); tcase_add_test(tc, eo_inconsistent_mro); tcase_add_test(tc, eo_bad_interface); - tcase_add_test(tc, eo_op_types); + tcase_add_test(tc, eo_null_api); + tcase_add_test(tc, eo_wrong_override); + tcase_add_test(tc, eo_api_redefined); + tcase_add_test(tc, eo_dich_func_override); } diff --git a/src/tests/eo/suite/eo_test_class_simple.c b/src/tests/eo/suite/eo_test_class_simple.c index cbeb18362a..cbefee7d1d 100644 --- a/src/tests/eo/suite/eo_test_class_simple.c +++ b/src/tests/eo/suite/eo_test_class_simple.c @@ -7,78 +7,96 @@ #define MY_CLASS SIMPLE_CLASS -EAPI Eo_Op SIMPLE_BASE_ID = 0; - EAPI const Eo_Event_Description _EV_A_CHANGED = EO_EVENT_DESCRIPTION("a,changed", "Called when a has changed."); static void -_a_set(Eo *obj EINA_UNUSED, void *class_data, va_list *list) +_a_set(Eo *obj EINA_UNUSED, void *class_data, int a) { Simple_Public_Data *pd = class_data; - int a; - a = va_arg(*list, int); printf("%s %d\n", eo_class_name_get(MY_CLASS), a); pd->a = a; - eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a, NULL)); + eo_do(obj, eo_event_callback_call(EV_A_CHANGED, &pd->a)); } -static void -_a_print(Eo *obj EINA_UNUSED, void *class_data, va_list *list) +static int +_a_get(Eo *obj EINA_UNUSED, void *class_data) +{ + Simple_Public_Data *pd = class_data; + + return pd->a; +} + +static Eina_Bool +_a_print(Eo *obj EINA_UNUSED, void *class_data) { const Simple_Public_Data *pd = class_data; - (void) list; printf("Print %s %d\n", eo_class_name_get(MY_CLASS), pd->a); + + return EINA_TRUE; } -static void -_class_hi_print(Eo_Class *klass, void *data EINA_UNUSED, va_list *list) +static Eina_Bool +_class_hi_print(Eo_Class *klass, void *data EINA_UNUSED) { - (void) list; printf("Hi Print %s\n", eo_class_name_get(klass)); + + return EINA_TRUE; +} + +EO_VOID_FUNC_BODYV(simple_recursive, EO_FUNC_CALL(n), int n); + +static void +_recursive(Eo *obj, void *class_data EINA_UNUSED, int n) +{ + static int count = 0; + + if (count < n) + { + count++; + eo_do(obj, simple_recursive(n)); + } + else + count = 0; } static void -_dbg_info_get(Eo *eo_obj, void *_pd EINA_UNUSED, va_list *list) +_dbg_info_get(Eo *eo_obj, void *_pd EINA_UNUSED, Eo_Dbg_Info *root) { - Eo_Dbg_Info *root = (Eo_Dbg_Info *) va_arg(*list, Eo_Dbg_Info *); 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); } -static void -_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DBG_INFO_GET), _dbg_info_get), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_SET), _a_set), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_A_PRINT), _a_print), - EO_OP_FUNC_CLASS(SIMPLE_ID(SIMPLE_SUB_ID_CLASS_HI_PRINT), _class_hi_print), - EO_OP_FUNC_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); - eo_class_funcs_set(klass, func_desc); -} - -static const Eo_Op_Description op_desc[] = { - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_A_SET, "Set property A"), - EO_OP_DESCRIPTION(SIMPLE_SUB_ID_A_PRINT, "Print property A"), - EO_OP_DESCRIPTION_CLASS(SIMPLE_SUB_ID_CLASS_HI_PRINT, "Print Hi"), - EO_OP_DESCRIPTION_SENTINEL +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 = { EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(&SIMPLE_BASE_ID, op_desc, SIMPLE_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, sizeof(Simple_Public_Data), - _class_constructor, + NULL, NULL }; -EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_BASE_CLASS, NULL) +EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_CLASS, NULL) diff --git a/src/tests/eo/suite/eo_test_class_simple.h b/src/tests/eo/suite/eo_test_class_simple.h index 699ddb8bbc..7d774b761f 100644 --- a/src/tests/eo/suite/eo_test_class_simple.h +++ b/src/tests/eo/suite/eo_test_class_simple.h @@ -1,25 +1,18 @@ #ifndef SIMPLE_H #define SIMPLE_H -extern EAPI Eo_Op SIMPLE_BASE_ID; - -enum { - SIMPLE_SUB_ID_A_SET, - SIMPLE_SUB_ID_A_PRINT, - SIMPLE_SUB_ID_CLASS_HI_PRINT, - SIMPLE_SUB_ID_LAST -}; - typedef struct { int a; } Simple_Public_Data; -#define SIMPLE_ID(sub_id) (SIMPLE_BASE_ID + sub_id) - -#define simple_a_set(a) SIMPLE_ID(SIMPLE_SUB_ID_A_SET), EO_TYPECHECK(int, a) -#define simple_a_print() SIMPLE_ID(SIMPLE_SUB_ID_A_PRINT) -#define simple_class_hi_print() SIMPLE_ID(SIMPLE_SUB_ID_CLASS_HI_PRINT) +EAPI void simple_a_set(int a); +EAPI int simple_a_get(void); +EAPI Eina_Bool simple_a_print(void); +EAPI Eina_Bool simple_class_hi_print(void); +EAPI void simple_recursive(int n); +EAPI void simple_pure_virtual(void); +EAPI void simple_no_implementation(void); extern const Eo_Event_Description _EV_A_CHANGED; #define EV_A_CHANGED (&(_EV_A_CHANGED)) diff --git a/src/tests/eo/suite/eo_test_general.c b/src/tests/eo/suite/eo_test_general.c index 35f787918a..6547218a53 100644 --- a/src/tests/eo/suite/eo_test_general.c +++ b/src/tests/eo/suite/eo_test_general.c @@ -11,7 +11,7 @@ START_TEST(eo_simple) { eo_init(); - Eo *obj = eo_add(EO_BASE_CLASS, NULL); + Eo *obj = eo_add(EO_CLASS, NULL); fail_if(obj); obj = eo_add(SIMPLE_CLASS, NULL); @@ -24,6 +24,20 @@ START_TEST(eo_simple) } END_TEST +START_TEST(eo_stack) +{ + eo_init(); + Eo *obj = eo_add(SIMPLE_CLASS, NULL); + fail_if(!obj); + + eo_do(obj, simple_recursive(123)); + + eo_unref(obj); + + eo_shutdown(); +} +END_TEST + static int _eo_signals_cb_curent = 0; static int _eo_signals_cb_flag = 0; @@ -87,7 +101,7 @@ START_TEST(eo_signals) 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)); - fail_if(!eo_do(obj, simple_a_set(1))); + eo_do(obj, simple_a_set(1)); ck_assert_int_eq(_eo_signals_cb_flag, 0x3); eo_do(obj, eo_event_callback_array_del(callbacks, (void *) 1)); @@ -96,7 +110,7 @@ START_TEST(eo_signals) /* Try to delete something that doesn't exist. */ eo_do(obj, eo_event_callback_array_del(callbacks, (void *) 4)); _eo_signals_cb_flag = 0; - fail_if(!eo_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); @@ -114,14 +128,14 @@ START_TEST(eo_data_fetch) EO_VERSION, "Simple2", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 10, NULL, NULL }; - const Eo_Class *klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL); + const Eo_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL); fail_if(!klass); Eo *obj = eo_add(klass, NULL); @@ -132,7 +146,7 @@ START_TEST(eo_data_fetch) eo_unref(obj); class_desc.data_size = 0; - klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL); + klass = eo_class_new(&class_desc, EO_CLASS, NULL); fail_if(!klass); obj = eo_add(klass, NULL); @@ -156,7 +170,7 @@ START_TEST(eo_isa_tests) EO_VERSION, "Iface", EO_CLASS_TYPE_INTERFACE, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -173,7 +187,7 @@ START_TEST(eo_isa_tests) EO_VERSION, "Mixin", EO_CLASS_TYPE_MIXIN, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, @@ -190,14 +204,14 @@ START_TEST(eo_isa_tests) EO_VERSION, "Simple2", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 10, NULL, NULL }; - klass = eo_class_new(&class_desc, EO_BASE_CLASS, iface, mixin, NULL); + klass = eo_class_new(&class_desc, EO_CLASS, iface, mixin, NULL); fail_if(!klass); } @@ -207,7 +221,7 @@ START_TEST(eo_isa_tests) fail_if(!eo_isa(obj, iface)); fail_if(!eo_isa(obj, mixin)); fail_if(!eo_isa(obj, klass)); - fail_if(!eo_isa(obj, EO_BASE_CLASS)); + fail_if(!eo_isa(obj, EO_CLASS)); eo_unref(obj); obj = eo_add(SIMPLE_CLASS, NULL); @@ -216,7 +230,7 @@ START_TEST(eo_isa_tests) fail_if(eo_isa(obj, iface)); fail_if(eo_isa(obj, mixin)); fail_if(!eo_isa(obj, SIMPLE_CLASS)); - fail_if(!eo_isa(obj, EO_BASE_CLASS)); + fail_if(!eo_isa(obj, EO_CLASS)); eo_unref(obj); eo_shutdown(); @@ -264,19 +278,11 @@ _man_des(Eo *obj, void *data EINA_UNUSED, va_list *list EINA_UNUSED) eo_manual_free_set(obj, EINA_FALSE); } - -static void -_man_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_CONSTRUCTOR), _man_con), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _man_des), - EO_OP_FUNC(EO_BASE_ID(EO_BASE_SUB_ID_DESTRUCTOR), _man_des), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} +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) { @@ -287,14 +293,14 @@ START_TEST(eo_man_free) EO_VERSION, "Simple2", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_OPS(op_descs), NULL, 10, - _man_class_constructor, + NULL, NULL }; - const Eo_Class *klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL); + const Eo_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL); fail_if(!klass); cur_klass = klass; @@ -308,7 +314,7 @@ START_TEST(eo_man_free) eo_unref(obj); _man_should_des = EINA_FALSE; - klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL); + klass = eo_class_new(&class_desc, EO_CLASS, NULL); cur_klass = klass; fail_if(!klass); @@ -327,7 +333,7 @@ START_TEST(eo_man_free) fail_if(!eo_manual_free(obj)); _man_should_con = EINA_FALSE; - klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL); + klass = eo_class_new(&class_desc, EO_CLASS, NULL); cur_klass = klass; fail_if(!klass); @@ -403,7 +409,7 @@ START_TEST(eo_refs) obj = eo_add(SIMPLE_CLASS, NULL); obj2 = eo_add(SIMPLE_CLASS, obj); - Eo *wref; + Eo *wref = NULL; eo_do(obj2, eo_wref_add(&wref)); fail_if(!wref); @@ -438,7 +444,7 @@ START_TEST(eo_weak_reference) Eo *obj = eo_add(SIMPLE_CLASS, NULL); Eo *obj2 = eo_add(SIMPLE_CLASS, NULL); - Eo *wref, *wref2, *wref3; + Eo *wref = NULL, *wref2 = NULL, *wref3 = NULL; eo_do(obj, eo_wref_add(&wref)); fail_if(!wref); @@ -497,77 +503,6 @@ START_TEST(eo_weak_reference) } END_TEST -static void -_a_set(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) -{ - fail_if(EINA_TRUE); -} - -static void -_op_errors_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_LAST), _a_set), - EO_OP_FUNC(SIMPLE_ID(SIMPLE_SUB_ID_LAST + 1), _a_set), - EO_OP_FUNC(0x0F010111, _a_set), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} - -START_TEST(eo_op_errors) -{ - eo_init(); - - static const Eo_Class_Description class_desc = { - EO_VERSION, - "Simple", - EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), - NULL, - 0, - _op_errors_class_constructor, - NULL - }; - - const Eo_Class *klass = eo_class_new(&class_desc, SIMPLE_CLASS, NULL); - fail_if(!klass); - - Eo *obj = eo_add(klass, NULL); - - /* Out of bounds op for a legal class. */ - fail_if(eo_do(obj, EO_BASE_ID(0x0111))); - - /* Ilegal class. */ - fail_if(eo_do(obj, 0x0F010111)); - - fail_if(eo_ref_get(obj) != 1); - - eo_ref(obj); - fail_if(eo_ref_get(obj) != 2); - - eo_ref(obj); - fail_if(eo_ref_get(obj) != 3); - - eo_unref(obj); - fail_if(eo_ref_get(obj) != 2); - - eo_unref(obj); - fail_if(eo_ref_get(obj) != 1); - - eo_unref(obj); - - obj = eo_add(SIMPLE_CLASS, NULL); - fail_if(!eo_do(obj, simple_a_print())); - fail_if(!eo_do(obj, simple_a_print())); - fail_if(!eo_do(obj, simple_a_set(1))); - eo_unref(obj); - - eo_shutdown(); -} -END_TEST - static void _fake_free_func(void *data) { @@ -582,58 +517,58 @@ START_TEST(eo_generic_data) { eo_init(); Eo *obj = eo_add(SIMPLE_CLASS, NULL); - void *data; + void *data = NULL; - eo_do(obj, eo_base_data_set("test1", (void *) 1, NULL)); - eo_do(obj, eo_base_data_get("test1", &data)); + eo_do(obj, eo_key_data_set("test1", (void *) 1, NULL)); + eo_do(obj, data = eo_key_data_get("test1")); fail_if(1 != (intptr_t) data); - eo_do(obj, eo_base_data_del("test1")); - eo_do(obj, eo_base_data_get("test1", &data)); + eo_do(obj, eo_key_data_del("test1")); + eo_do(obj, data = eo_key_data_get("test1")); fail_if(data); - 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, eo_base_data_get("test1", &data)); + eo_do(obj, eo_key_data_set("test1", (void *) 1, NULL)); + eo_do(obj, eo_key_data_set("test2", (void *) 2, NULL)); + eo_do(obj, data = eo_key_data_get("test1")); fail_if(1 != (intptr_t) data); - eo_do(obj, eo_base_data_get("test2", &data)); + eo_do(obj, data = eo_key_data_get("test2")); fail_if(2 != (intptr_t) data); - eo_do(obj, eo_base_data_get("test2", &data)); + eo_do(obj, data = eo_key_data_get("test2")); fail_if(2 != (intptr_t) data); - eo_do(obj, eo_base_data_del("test2")); - eo_do(obj, eo_base_data_get("test2", &data)); + eo_do(obj, eo_key_data_del("test2")); + eo_do(obj, data = eo_key_data_get("test2")); fail_if(data); - eo_do(obj, eo_base_data_get("test1", &data)); + eo_do(obj, data = eo_key_data_get("test1")); fail_if(1 != (intptr_t) data); - eo_do(obj, eo_base_data_del("test1")); - eo_do(obj, eo_base_data_get("test1", &data)); + eo_do(obj, eo_key_data_del("test1")); + eo_do(obj, data = eo_key_data_get("test1")); fail_if(data); int a = 0; - eo_do(obj, eo_base_data_set("test3", &a, _fake_free_func)); - eo_do(obj, eo_base_data_get("test3", &data)); + eo_do(obj, eo_key_data_set("test3", &a, _fake_free_func)); + eo_do(obj, data = eo_key_data_get("test3")); fail_if(&a != data); - eo_do(obj, eo_base_data_get("test3", NULL)); - eo_do(obj, eo_base_data_del("test3")); + eo_do(obj, eo_key_data_get("test3")); + eo_do(obj, eo_key_data_del("test3")); fail_if(a != 1); a = 0; - eo_do(obj, eo_base_data_set("test3", &a, _fake_free_func)); - eo_do(obj, eo_base_data_set("test3", NULL, _fake_free_func)); + eo_do(obj, eo_key_data_set("test3", &a, _fake_free_func)); + eo_do(obj, eo_key_data_set("test3", NULL, _fake_free_func)); fail_if(a != 1); a = 0; data = (void *) 123; - eo_do(obj, eo_base_data_set(NULL, &a, _fake_free_func)); - eo_do(obj, eo_base_data_get(NULL, &data)); + eo_do(obj, eo_key_data_set(NULL, &a, _fake_free_func)); + eo_do(obj, data = eo_key_data_get(NULL)); fail_if(data); - eo_do(obj, eo_base_data_del(NULL)); + eo_do(obj, eo_key_data_del(NULL)); a = 0; - eo_do(obj, eo_base_data_set("test3", &a, _fake_free_func)); - eo_do(obj, eo_base_data_set("test3", NULL, NULL)); + eo_do(obj, eo_key_data_set("test3", &a, _fake_free_func)); + eo_do(obj, eo_key_data_set("test3", NULL, NULL)); fail_if(a != 1); - eo_do(obj, eo_base_data_set("test3", &a, _fake_free_func)); + eo_do(obj, eo_key_data_set("test3", &a, _fake_free_func)); eo_unref(obj); fail_if(a != 2); @@ -642,6 +577,7 @@ START_TEST(eo_generic_data) } END_TEST + START_TEST(eo_magic_checks) { char _buf[sizeof(long)]; /* Just enough to hold eina magic + a bit more. */ @@ -655,6 +591,7 @@ START_TEST(eo_magic_checks) while (1) { + int i = 20, a = 0; Eo *parent = NULL; Eo *wref = NULL; Eo *obj2 = NULL; @@ -665,18 +602,21 @@ START_TEST(eo_magic_checks) obj = eo_add(SIMPLE_CLASS, NULL); fail_if(!obj); - fail_if(eo_do((Eo *) buf, EO_NOOP)); - fail_if(eo_do_super((Eo *) buf, SIMPLE_CLASS, EO_NOOP)); - fail_if(eo_do_super(obj, (const Eo_Class *) buf, EO_NOOP)); + eo_do((Eo *) buf, simple_a_set(++i), a = simple_a_get()); + ck_assert_int_ne(i, a); + 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); + 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) != EO_CLASS_CLASS); - eo_class_funcs_set((Eo_Class *) buf, NULL); - eo_do((Eo_Class *) buf, NULL); - eo_do_super((Eo_Class *) buf, SIMPLE_CLASS, EO_NOOP); - eo_do_super(SIMPLE_CLASS, (Eo_Class *) buf, EO_NOOP); - + 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); @@ -695,7 +635,7 @@ START_TEST(eo_magic_checks) eo_do((Eo *) buf, eo_wref_add(&wref), - eo_parent_get(&parent)); + parent = eo_parent_get()); fail_if(wref); fail_if(parent); @@ -718,7 +658,7 @@ START_TEST(eo_magic_checks) obj2 = NULL; eo_do(obj, eo_parent_set((Eo *) buf)); - eo_do(obj, eo_parent_get(&obj2)); + eo_do(obj, obj2 = eo_parent_get()); fail_if(obj2 && (obj2 == (Eo *) buf)); eo_unref(obj); @@ -734,48 +674,32 @@ START_TEST(eo_magic_checks) END_TEST /* MULTI */ -static Eo_Op MULTI_BASE_ID; -#define MULTI_ID(sub_id) (MULTI_BASE_ID + sub_id) -#define multi_a_print() MULTI_ID(MULTI_SUB_ID_A_PRINT) -#define multi_class_hi_print() MULTI_ID(MULTI_SUB_ID_CLASS_HI_PRINT) -static void -_a_print(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +static Eina_Bool +_a_print(Eo *obj EINA_UNUSED, void *class_data EINA_UNUSED) { printf("Hey\n"); + + return EINA_TRUE; } -static void -_class_hi_print(Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED, va_list *list EINA_UNUSED) +static Eina_Bool +_class_hi_print(Eo_Class *klass EINA_UNUSED, void *class_data EINA_UNUSED) { printf("Hi\n"); + + return EINA_TRUE; } -enum { - MULTI_SUB_ID_A_PRINT, - MULTI_SUB_ID_CLASS_HI_PRINT, - MULTI_SUB_ID_LAST +EO_FUNC_BODY(multi_a_print, Eina_Bool, EINA_FALSE); +EO_FUNC_BODY(multi_class_hi_print, Eina_Bool, EINA_FALSE); + +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 }; -static void -_eo_multiple_do_class_constructor(Eo_Class *klass) -{ - const Eo_Op_Func_Description func_desc[] = { - EO_OP_FUNC(MULTI_ID(MULTI_SUB_ID_A_PRINT), _a_print), - EO_OP_FUNC_CLASS(MULTI_ID(MULTI_SUB_ID_CLASS_HI_PRINT), _class_hi_print), - EO_OP_FUNC_SENTINEL - }; - - eo_class_funcs_set(klass, func_desc); -} - -static const Eo_Op_Description _eo_multiple_do_op_desc[] = { - EO_OP_DESCRIPTION(MULTI_SUB_ID_A_PRINT, "Print property A"), - EO_OP_DESCRIPTION_CLASS(MULTI_SUB_ID_CLASS_HI_PRINT, "Print Hi"), - EO_OP_DESCRIPTION_SENTINEL -}; - - START_TEST(eo_multiple_do) { eo_init(); @@ -785,10 +709,10 @@ START_TEST(eo_multiple_do) EO_VERSION, "Inherit", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(&MULTI_BASE_ID, _eo_multiple_do_op_desc, MULTI_SUB_ID_LAST), + EO_CLASS_DESCRIPTION_OPS(_multi_do_op_descs), NULL, 0, - _eo_multiple_do_class_constructor, + NULL, NULL }; @@ -798,8 +722,15 @@ START_TEST(eo_multiple_do) Eo *obj = eo_add(klass, NULL); fail_if(!obj); - fail_if(!eo_do(obj, simple_a_print(), multi_a_print(), multi_a_print())); - fail_if(!eo_do(klass, simple_class_hi_print(), multi_class_hi_print(), multi_class_hi_print())); + Eina_Bool ca, cb, cc; + + ca = cb = cc = EINA_FALSE; + 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; + 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); @@ -842,14 +773,14 @@ START_TEST(eo_pointers_indirection) EO_VERSION, "Simple", EO_CLASS_TYPE_REGULAR, - EO_CLASS_DESCRIPTION_OPS(NULL, NULL, 0), + EO_CLASS_DESCRIPTION_NOOPS(), NULL, 0, NULL, NULL }; - const Eo_Class *klass = eo_class_new(&class_desc, EO_BASE_CLASS, NULL); + const Eo_Class *klass = eo_class_new(&class_desc, EO_CLASS, NULL); fail_if(!klass); /* Check simple id validity */ @@ -916,18 +847,18 @@ END_TEST void eo_test_general(TCase *tc) { - tcase_add_test(tc, eo_generic_data); - tcase_add_test(tc, eo_op_errors); tcase_add_test(tc, eo_simple); - tcase_add_test(tc, eo_weak_reference); - tcase_add_test(tc, eo_refs); - tcase_add_test(tc, eo_magic_checks); + tcase_add_test(tc, eo_stack); + tcase_add_test(tc, eo_signals); tcase_add_test(tc, eo_data_fetch); - tcase_add_test(tc, eo_man_free); - tcase_add_test(tc, eo_composite_tests); tcase_add_test(tc, eo_isa_tests); + tcase_add_test(tc, eo_composite_tests); + tcase_add_test(tc, eo_man_free); + tcase_add_test(tc, eo_refs); + tcase_add_test(tc, eo_weak_reference); + 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, eo_add_do_and_custom); - tcase_add_test(tc, eo_signals); 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 new file mode 100644 index 0000000000..ee7b70f526 --- /dev/null +++ b/src/tests/eo/suite/eo_test_threaded_calls.c @@ -0,0 +1,130 @@ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include + +#include "Eo.h" +#include "eo_suite.h" + +static Eina_Barrier barrier; +static Eina_Spinlock locks[2]; + +typedef struct +{ + int v; +} Thread_Test_Public_Data; + +#define THREAD_TEST_CLASS thread_test_class_get() +const Eo_Class *thread_test_class_get(void); + +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) +{ + Thread_Test_Public_Data *pd = class_data; + + return pd->v; +} + +static void +_try_swap_stack(Eo *obj EINA_UNUSED, void *class_data) +{ + Thread_Test_Public_Data *pd = class_data; + + if (pd->v == 0 ) + { + eina_spinlock_release(&locks[0]); + eina_spinlock_take(&locks[1]); + eina_barrier_wait(&barrier); + } + else if (pd->v == 1 ) + { + eina_barrier_wait(&barrier); + eina_spinlock_take(&locks[1]); + } +} + +static void +_constructor(Eo *obj, void *class_data EINA_UNUSED, int v) +{ + Thread_Test_Public_Data *pd = class_data; + + eo_do_super(obj, THREAD_TEST_CLASS, eo_constructor()); + + pd->v = v; +} + +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 = { + EO_VERSION, + "Thread Test", + EO_CLASS_TYPE_REGULAR, + EO_CLASS_DESCRIPTION_OPS(op_descs), + NULL, + sizeof(Thread_Test_Public_Data), + NULL, + NULL +}; + +EO_DEFINE_CLASS(thread_test_class_get, &class_desc, EO_CLASS, NULL) + +static void * +_thread_job(void *data, Eina_Thread t EINA_UNUSED) +{ + Eo *obj; + int v = (int) (uintptr_t) data; + + if (v == 1) + eina_spinlock_take(&locks[0]); + + obj = eo_add_custom(THREAD_TEST_CLASS, NULL, thread_test_constructor(v)); + + eo_do(obj, thread_test_try_swap_stack(), v = thread_test_v_get()); + + eina_spinlock_release(&locks[1]); + + eo_unref(obj); + + return (void *) (uintptr_t) v; +} + +START_TEST(eo_threaded_calls_test) +{ + Eina_Thread threads[2]; + + eo_init(); + + fail_if(!eina_spinlock_new(&locks[0])); + fail_if(!eina_spinlock_new(&locks[1])); + fail_if(!eina_barrier_new(&barrier, 2)); + + eina_spinlock_take(&locks[0]); + + fail_if(!eina_thread_create(&threads[0], EINA_THREAD_NORMAL, 0, _thread_job, (void *) (uintptr_t)0)); + fail_if(!eina_thread_create(&threads[1], EINA_THREAD_NORMAL, 0, _thread_job, (void *) (uintptr_t)1)); + + fail_if(0 != (int)(uintptr_t)eina_thread_join(threads[0])); + fail_if(1 != (int)(uintptr_t)eina_thread_join(threads[1])); + + eina_spinlock_free(&locks[0]); + eina_spinlock_free(&locks[1]); + eina_barrier_free(&barrier); + + eo_shutdown(); +} +END_TEST + +void eo_test_threaded_calls(TCase *tc) +{ + tcase_add_test(tc, eo_threaded_calls_test); +} diff --git a/src/tests/eo/suite/eo_test_value.c b/src/tests/eo/suite/eo_test_value.c index 9f4965ba41..afdec776ce 100644 --- a/src/tests/eo/suite/eo_test_value.c +++ b/src/tests/eo/suite/eo_test_value.c @@ -19,7 +19,7 @@ START_TEST(eo_value) Eo *obj = eo_add(SIMPLE_CLASS, NULL); eo_dbg_info = EO_DBG_INFO_LIST_APPEND(NULL, "Root"); - fail_if(!eo_do(obj, eo_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);