vitorsousa pushed a commit to branch master. http://git.enlightenment.org/core/efl.git/commit/?id=8d1bd770df61e14d54ad05e279fe9aac9f8aeeed
commit 8d1bd770df61e14d54ad05e279fe9aac9f8aeeed Author: Vitor Sousa <vitorso...@expertisesolutions.com.br> Date: Fri Jul 26 14:40:38 2019 -0300 csharp: fix EFL# by updating it to reflect the newest changes in Eolian Summary: `Efl.Event` became a builtin type that is no longer declared in `efl_object.eo`, and therefore it is no longer automatically generated in EFL#. Given that, we define a struct manually to reflect the memory layout of the native struct. Containers of value types are now allowed in eolian, so tests that were disabled because of the restriction on `ptr` were re-enabled using the plain type. But since these containers have just arrived, handling of ownership for value types is currently undefined in bindings. Hence, tests that used `ptr(int) @owned` as elements were left disable. This will be solved in a future patch. `void_pr` is now deprecated, so we remove it from tests also. Reviewers: q66, segfaultxavi, lauromoura, felipealmeida Reviewed By: lauromoura Subscribers: cedric, #reviewers, #committers Tags: #efl Differential Revision: https://phab.enlightenment.org/D9417 --- src/bindings/mono/eo_mono/workaround.cs | 82 +++++++++++++++++++++++++++++++++ src/tests/efl_mono/Eina.cs | 18 ++++++-- src/tests/efl_mono/StructHelpers.cs | 3 -- src/tests/efl_mono/dummy_test_object.c | 2 - src/tests/efl_mono/dummy_test_object.eo | 55 +++++++++++++--------- 5 files changed, 130 insertions(+), 30 deletions(-) diff --git a/src/bindings/mono/eo_mono/workaround.cs b/src/bindings/mono/eo_mono/workaround.cs index 9f22b90fa6..49a6e1ef58 100644 --- a/src/bindings/mono/eo_mono/workaround.cs +++ b/src/bindings/mono/eo_mono/workaround.cs @@ -108,6 +108,88 @@ public struct EventDescription } }; +/// <summary> +/// A parameter passed in event callbacks holding extra event parameters. +/// This is the full event information passed to callbacks in C. +/// (Since EFL 1.22) +/// </summary> +[StructLayout(LayoutKind.Sequential)] +[Efl.Eo.BindingEntity] +public struct Event +{ + /// <summary>The object the callback was called on. + /// (Since EFL 1.22)</summary> + public Efl.Object Object; + + /// <summary>The event description. + /// (Since EFL 1.22)</summary> + public Efl.EventDescription Desc; + + /// <summary>Extra event information passed by the event caller. + /// Must be cast to the event type declared in the EO file. Keep in mind that: + /// 1) Objects are passed as a normal Eo*. Event subscribers can call functions on these objects. + /// 2) Structs, built-in types and containers are passed as const pointers, with one level of indirection. + /// (Since EFL 1.22)</summary> + public System.IntPtr Info; + + /// <summary>Constructor for Event.</summary> + public Event( + Efl.Object obj = default(Efl.Object), + Efl.EventDescription desc = default(Efl.EventDescription), + System.IntPtr info = default(System.IntPtr)) + { + this.Object = obj; + this.Desc = desc; + this.Info = info; + } + + /// <summary>Implicit conversion to the managed representation from a native pointer.</summary> + /// <param name="ptr">Native pointer to be converted.</param> + public static implicit operator Event(IntPtr ptr) + { + var tmp = (Event.NativeStruct) Marshal.PtrToStructure(ptr, typeof(Event.NativeStruct)); + return tmp; + } + + /// <summary>Internal wrapper for struct Event.</summary> + [StructLayout(LayoutKind.Sequential)] + public struct NativeStruct + { + /// <summary>Internal wrapper for field Object</summary> + public System.IntPtr Object; + + /// <summary>Internal wrapper for field Desc</summary> + public System.IntPtr Desc; + + /// <summary>Internal wrapper for field Info</summary> + public System.IntPtr Info; + + /// <summary>Implicit conversion to the internal/marshalling representation.</summary> + /// <param name="externalStruct">Managed struct to be converted.</param> + /// <returns>Native representation of the managed struct.</returns> + public static implicit operator Event.NativeStruct(Event externalStruct) + { + var internalStruct = new Event.NativeStruct(); + internalStruct.Object = externalStruct.Object?.NativeHandle ?? System.IntPtr.Zero; + internalStruct.Desc = Eina.PrimitiveConversion.ManagedToPointerAlloc(externalStruct.Desc); + internalStruct.Info = externalStruct.Info; + return internalStruct; + } + + /// <summary>Implicit conversion to the managed representation.</summary> + /// <param name="internalStruct">Native struct to be converted.</param> + /// <returns>Managed representation of the native struct.</returns> + public static implicit operator Event(Event.NativeStruct internalStruct) + { + var externalStruct = new Event(); + externalStruct.Object = (Efl.Object) Efl.Eo.Globals.CreateWrapperFor(internalStruct.Object); + externalStruct.Desc = Eina.PrimitiveConversion.PointerToManaged<Efl.EventDescription>(internalStruct.Desc); + externalStruct.Info = internalStruct.Info; + return externalStruct; + } + } +} + public delegate void EventCb(System.IntPtr data, ref Event.NativeStruct evt); public delegate void FreeWrapperSupervisorCb(System.IntPtr obj); diff --git a/src/tests/efl_mono/Eina.cs b/src/tests/efl_mono/Eina.cs index d71d6c8f7f..07dfd1bed2 100644 --- a/src/tests/efl_mono/Eina.cs +++ b/src/tests/efl_mono/Eina.cs @@ -826,7 +826,6 @@ class TestEinaArray // Integer // - /* public static void test_eina_array_int_in() { var t = new Dummy.TestObject(); @@ -839,6 +838,7 @@ class TestEinaArray Test.Assert(arr.Handle == IntPtr.Zero); } + /* public static void test_eina_array_int_in_own() { var t = new Dummy.TestObject(); @@ -851,6 +851,7 @@ class TestEinaArray Test.Assert(arr.Handle == IntPtr.Zero); Test.Assert(t.CheckEinaArrayIntInOwn()); } + */ public static void test_eina_array_int_out() { @@ -865,6 +866,7 @@ class TestEinaArray Test.Assert(t.CheckEinaArrayIntOut()); } + /* public static void test_eina_array_int_out_own() { var t = new Dummy.TestObject(); @@ -876,6 +878,7 @@ class TestEinaArray arr.Dispose(); Test.Assert(arr.Handle == IntPtr.Zero); } + */ public static void test_eina_array_int_return() { @@ -889,6 +892,7 @@ class TestEinaArray Test.Assert(t.CheckEinaArrayIntReturn()); } + /* public static void test_eina_array_int_return_own() { var t = new Dummy.TestObject(); @@ -1886,7 +1890,6 @@ class TestEinaList // Integer // - /* public static void test_eina_list_int_in() { var t = new Dummy.TestObject(); @@ -1899,6 +1902,7 @@ class TestEinaList Test.Assert(lst.Handle == IntPtr.Zero); } + /* public static void test_eina_list_int_in_own() { var t = new Dummy.TestObject(); @@ -1910,6 +1914,7 @@ class TestEinaList Test.Assert(lst.Handle == IntPtr.Zero); Test.Assert(t.CheckEinaListIntInOwn()); } + */ public static void test_eina_list_int_out() { @@ -1923,6 +1928,7 @@ class TestEinaList Test.Assert(t.CheckEinaListIntOut()); } + /* public static void test_eina_list_int_out_own() { var t = new Dummy.TestObject(); @@ -1934,6 +1940,7 @@ class TestEinaList lst.Dispose(); Test.Assert(lst.Handle == IntPtr.Zero); } + */ public static void test_eina_list_int_return() { @@ -1946,6 +1953,7 @@ class TestEinaList Test.Assert(t.CheckEinaListIntReturn()); } + /* public static void test_eina_list_int_return_own() { var t = new Dummy.TestObject(); @@ -2666,7 +2674,6 @@ class TestEinaHash // Integer // - /* public static void test_eina_hash_int_in() { var t = new Dummy.TestObject(); @@ -2680,6 +2687,7 @@ class TestEinaHash Test.Assert(hsh.Handle == IntPtr.Zero); } + /* public static void test_eina_hash_int_in_own() { var t = new Dummy.TestObject(); @@ -2694,6 +2702,7 @@ class TestEinaHash Test.Assert(hsh.Handle == IntPtr.Zero); Test.Assert(t.CheckEinaHashIntInOwn()); } + */ public static void test_eina_hash_int_out() { @@ -2709,6 +2718,7 @@ class TestEinaHash Test.Assert(t.CheckEinaHashIntOut()); } + /* public static void test_eina_hash_int_out_own() { var t = new Dummy.TestObject(); @@ -2722,6 +2732,7 @@ class TestEinaHash Test.Assert(hsh.Handle == IntPtr.Zero); Test.Assert(t.CheckEinaHashIntOutOwn()); } + */ public static void test_eina_hash_int_return() { @@ -2736,6 +2747,7 @@ class TestEinaHash Test.Assert(t.CheckEinaHashIntReturn()); } + /* public static void test_eina_hash_int_return_own() { var t = new Dummy.TestObject(); diff --git a/src/tests/efl_mono/StructHelpers.cs b/src/tests/efl_mono/StructHelpers.cs index 110432f08f..7af3529055 100644 --- a/src/tests/efl_mono/StructHelpers.cs +++ b/src/tests/efl_mono/StructHelpers.cs @@ -41,7 +41,6 @@ internal class StructHelpers simple.Ffloat = -16777216.0f; simple.Fdouble = -9007199254740992.0; simple.Fbool = true; - simple.Fvoid_ptr = (IntPtr) 0xFE; simple.Fenum = Dummy.SampleEnum.V2; simple.Fstring = "test/string"; simple.Fmstring = "test/mstring"; @@ -78,7 +77,6 @@ internal class StructHelpers Test.Assert(simple.Ffloat == -16777216.0f); Test.Assert(simple.Fdouble == -9007199254740992.0); Test.Assert(simple.Fbool == true); - Test.Assert(simple.Fvoid_ptr == (IntPtr) 0xFE); Test.Assert(simple.Fenum == Dummy.SampleEnum.V2); Test.Assert(simple.Fstring == "test/string"); Test.Assert(simple.Fmstring == "test/mstring"); @@ -113,7 +111,6 @@ internal class StructHelpers Test.Assert(simple.Ffloat == 0); Test.Assert(simple.Fdouble == 0); Test.Assert(simple.Fbool == false); - Test.Assert(simple.Fvoid_ptr == IntPtr.Zero); Test.Assert(simple.Fenum == Dummy.SampleEnum.V0); Test.Assert(simple.Fstring == null); Test.Assert(simple.Fmstring == null); diff --git a/src/tests/efl_mono/dummy_test_object.c b/src/tests/efl_mono/dummy_test_object.c index e6bec29362..6717b12476 100644 --- a/src/tests/efl_mono/dummy_test_object.c +++ b/src/tests/efl_mono/dummy_test_object.c @@ -4040,7 +4040,6 @@ void struct_simple_with_values(Dummy_StructSimple *simple) simple->ffloat = -16777216.0; simple->fdouble = -9007199254740992.0; simple->fbool = EINA_TRUE; - simple->fvoid_ptr = (void*) 0xFE; simple->fenum = DUMMY_SAMPLEENUM_V2; simple->fstring = "test/string"; simple->fmstring = strdup("test/mstring"); @@ -4077,7 +4076,6 @@ Eina_Bool check_and_modify_struct_simple(Dummy_StructSimple *simple) && EQUAL(simple->ffloat, -16777216.0) && EQUAL(simple->fdouble, -9007199254740992.0) && EQUAL(simple->fbool, EINA_TRUE) - && EQUAL(simple->fvoid_ptr, (void*) 0xFE) && EQUAL(simple->fenum, DUMMY_SAMPLEENUM_V2) && STR_EQUAL(simple->fstring, "test/string") && STR_EQUAL(simple->fmstring, "test/mstring") diff --git a/src/tests/efl_mono/dummy_test_object.eo b/src/tests/efl_mono/dummy_test_object.eo index 97b7cf6641..2273c23a20 100644 --- a/src/tests/efl_mono/dummy_test_object.eo +++ b/src/tests/efl_mono/dummy_test_object.eo @@ -51,7 +51,6 @@ struct @free(free) Dummy.StructSimple ffloat: float; fdouble: double; fbool: bool; - fvoid_ptr: void_ptr; fenum: Dummy.SampleEnum; // fboolptr: ptr(bool); // TODO // fbyteptr: ptr(byte); @@ -379,27 +378,28 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface { /* Eina Array */ /* Integer */ - /* eina_array_int_in { params { - @in arr: array<ptr(int)>; + @in arr: array<int>; } return: bool; } + /* eina_array_int_in_own { params { - @in arr: array<free(ptr(int),free) @owned> @owned; + @in arr: array<int> @owned; // <int @owned> } return: bool; } check_eina_array_int_in_own { return: bool; } + */ eina_array_int_out { params { - @out arr: array<ptr(int)>; + @out arr: array<int>; } return: bool; } @@ -407,22 +407,25 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface { return: bool; } + /* eina_array_int_out_own { params { - @out arr: array<free(ptr(int),free) @owned> @owned; + @out arr: array<int> @owned; // <int @owned> } return: bool; } + */ eina_array_int_return { - return: array<ptr(int)>; + return: array<int>; } check_eina_array_int_return { return: bool; } + /* eina_array_int_return_own { - return: array<free(ptr(int),free) @owned> @owned; + return: array<int> @owned; // <int @owned> } */ @@ -574,27 +577,28 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface { /* Eina List */ /* Integer */ - /* eina_list_int_in { params { - @in lst: list<ptr(int)>; + @in lst: list<int>; } return: bool; } + /* eina_list_int_in_own { params { - @in lst: list<free(ptr(int),free) @owned> @owned; + @in lst: list<int> @owned; // <int @owned> } return: bool; } check_eina_list_int_in_own { return: bool; } + */ eina_list_int_out { params { - @out lst: list<ptr(int)>; + @out lst: list<int>; } return: bool; } @@ -602,22 +606,25 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface { return: bool; } + /* eina_list_int_out_own { params { - @out lst: list<free(ptr(int),free) @owned> @owned; + @out lst: list<int> @owned; // <int @owned> } return: bool; } + */ eina_list_int_return { - return: list<ptr(int)>; + return: list<int>; } check_eina_list_int_return { return: bool; } + /* eina_list_int_return_own { - return: list<free(ptr(int),free) @owned> @owned; + return: list<int> @owned; // <int @owned> } */ @@ -769,27 +776,28 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface { // Eina Hash // // Integer // - /* eina_hash_int_in { params { - @in hsh: hash<ptr(int), ptr(int)>; + @in hsh: hash<int, int>; } return: bool; } + /* eina_hash_int_in_own { params { - @in hsh: hash<ptr(int), free(ptr(int),free) @owned> @owned; + @in hsh: hash<int, int> @owned; // <, int @owned> } return: bool; } check_eina_hash_int_in_own { return: bool; } + */ eina_hash_int_out { params { - @out hsh: hash<ptr(int), ptr(int)>; + @out hsh: hash<int, int>; } return: bool; } @@ -797,25 +805,28 @@ class Dummy.Test_Object extends Efl.Object implements Dummy.Test_Iface { return: bool; } + /* eina_hash_int_out_own { params { - @out hsh: hash<ptr(int), free(ptr(int),free) @owned> @owned; + @out hsh: hash<int, int> @owned; // <, int @owned> } return: bool; } check_eina_hash_int_out_own { return: bool; } + */ eina_hash_int_return { - return: hash<ptr(int), ptr(int)>; + return: hash<int, int>; } check_eina_hash_int_return { return: bool; } + /* eina_hash_int_return_own { - return: hash<ptr(int), free(ptr(int),free) @owned> @owned; + return: hash<int, int> @owned; // <, int @owned> } check_eina_hash_int_return_own { return: bool; --