From cff2e6e470efae1f4e178ab13cb2b3d5dde502c3 Mon Sep 17 00:00:00 2001 From: Rico Tzschichholz Date: Thu, 13 Apr 2023 10:46:45 +0200 Subject: codegen: Fix usage of lambda-expression from delegate initializer Unset delegate-type if a lambda-expression handler was found to use the correct code paths. Fixes https://gitlab.gnome.org/GNOME/vala/issues/1428 --- codegen/valagsignalmodule.vala | 1 + tests/Makefile.am | 1 + tests/objects/signals-lambda-delegate-2.c-expected | 1194 ++++++++++++++++++++ tests/objects/signals-lambda-delegate-2.vala | 94 ++ 4 files changed, 1290 insertions(+) create mode 100644 tests/objects/signals-lambda-delegate-2.c-expected create mode 100644 tests/objects/signals-lambda-delegate-2.vala diff --git a/codegen/valagsignalmodule.vala b/codegen/valagsignalmodule.vala index 7f02b17f1..11389bade 100644 --- a/codegen/valagsignalmodule.vala +++ b/codegen/valagsignalmodule.vala @@ -605,6 +605,7 @@ public class Vala.GSignalModule : GObjectModule { // Use actual lambda expression if available for proper target/destroy handling if (((Variable) handler.symbol_reference).initializer is LambdaExpression) { handler = ((Variable) handler.symbol_reference).initializer; + dt = null; } } var m = handler.symbol_reference as Method; diff --git a/tests/Makefile.am b/tests/Makefile.am index b7a46cb31..99cee6206 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -613,6 +613,7 @@ TESTS = \ objects/signals-generic-return.vala \ objects/signals-gobject-return.vala \ objects/signals-lambda-delegate.vala \ + objects/signals-lambda-delegate-2.vala \ objects/signals-prototype-access.vala \ objects/signals-prototype-access-invalid.test \ objects/signals-prototype-access-invalid-2.test \ diff --git a/tests/objects/signals-lambda-delegate-2.c-expected b/tests/objects/signals-lambda-delegate-2.c-expected new file mode 100644 index 000000000..b9706f399 --- /dev/null +++ b/tests/objects/signals-lambda-delegate-2.c-expected @@ -0,0 +1,1194 @@ +/* objects_signals_lambda_delegate_2.c generated by valac, the Vala compiler + * generated from objects_signals_lambda_delegate_2.vala, do not modify */ + +#include +#include +#include +#include +#include + +#if !defined(VALA_EXTERN) +#if defined(_WIN32) || defined(__CYGWIN__) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define TYPE_FOO (foo_get_type ()) +#define FOO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FOO, Foo)) +#define FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FOO, FooClass)) +#define IS_FOO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FOO)) +#define IS_FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FOO)) +#define FOO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FOO, FooClass)) + +typedef struct _Foo Foo; +typedef struct _FooClass FooClass; +typedef gchar* (*FooFunc) (Foo* foo, const gchar* s, gpointer user_data); +typedef struct _FooPrivate FooPrivate; +enum { + FOO_0_PROPERTY, + FOO_NUM_PROPERTIES +}; +static GParamSpec* foo_properties[FOO_NUM_PROPERTIES]; +enum { + FOO_TEST_SIGNAL, + FOO_NUM_SIGNALS +}; +static guint foo_signals[FOO_NUM_SIGNALS] = {0}; + +#define TYPE_BAR (bar_get_type ()) +#define BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BAR, Bar)) +#define BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BAR, BarClass)) +#define IS_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BAR)) +#define IS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BAR)) +#define BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BAR, BarClass)) + +typedef struct _Bar Bar; +typedef struct _BarClass BarClass; +typedef struct _BarPrivate BarPrivate; +enum { + BAR_0_PROPERTY, + BAR_NUM_PROPERTIES +}; +static GParamSpec* bar_properties[BAR_NUM_PROPERTIES]; +#define _g_free0(var) (var = (g_free (var), NULL)) +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +#define TYPE_FAZ (faz_get_type ()) +#define FAZ(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FAZ, Faz)) +#define FAZ_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FAZ, FazClass)) +#define IS_FAZ(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FAZ)) +#define IS_FAZ_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FAZ)) +#define FAZ_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FAZ, FazClass)) + +typedef struct _Faz Faz; +typedef struct _FazClass FazClass; +typedef gchar* (*FazFunc) (Faz* faz, const gchar* s, gpointer user_data); +typedef struct _FazPrivate FazPrivate; +typedef struct _ParamSpecFaz ParamSpecFaz; +enum { + FAZ_TEST_SIGNAL, + FAZ_NUM_SIGNALS +}; +static guint faz_signals[FAZ_NUM_SIGNALS] = {0}; + +#define TYPE_BOO (boo_get_type ()) +#define BOO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BOO, Boo)) +#define BOO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BOO, BooClass)) +#define IS_BOO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BOO)) +#define IS_BOO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BOO)) +#define BOO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BOO, BooClass)) + +typedef struct _Boo Boo; +typedef struct _BooClass BooClass; +typedef struct _BooPrivate BooPrivate; +#define _faz_unref0(var) ((var == NULL) ? NULL : (var = (faz_unref (var), NULL))) +typedef struct _ParamSpecBoo ParamSpecBoo; +#define _boo_unref0(var) ((var == NULL) ? NULL : (var = (boo_unref (var), NULL))) +#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); +#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; } +#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; } +#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); + +struct _Foo { + GObject parent_instance; + FooPrivate * priv; +}; + +struct _FooClass { + GObjectClass parent_class; +}; + +struct _Bar { + GObject parent_instance; + BarPrivate * priv; +}; + +struct _BarClass { + GObjectClass parent_class; +}; + +struct _Faz { + GTypeInstance parent_instance; + volatile int ref_count; + FazPrivate * priv; +}; + +struct _FazClass { + GTypeClass parent_class; + void (*finalize) (Faz *self); +}; + +struct _ParamSpecFaz { + GParamSpec parent_instance; +}; + +struct _Boo { + GTypeInstance parent_instance; + volatile int ref_count; + BooPrivate * priv; +}; + +struct _BooClass { + GTypeClass parent_class; + void (*finalize) (Boo *self); +}; + +struct _ParamSpecBoo { + GParamSpec parent_instance; +}; + +static gpointer foo_parent_class = NULL; +static gpointer bar_parent_class = NULL; +static gpointer faz_parent_class = NULL; +static gpointer boo_parent_class = NULL; + +VALA_EXTERN GType foo_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Foo, g_object_unref) +VALA_EXTERN Foo* foo_new (void); +VALA_EXTERN Foo* foo_construct (GType object_type); +static void g_cclosure_user_marshal_STRING__STRING (GClosure * closure, + GValue * return_value, + guint n_param_values, + const GValue * param_values, + gpointer invocation_hint, + gpointer marshal_data); +static GType foo_get_type_once (void); +VALA_EXTERN GType bar_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Bar, g_object_unref) +VALA_EXTERN void bar_run (Bar* self); +static gchar* _vala_lambda0_ (Bar* self, + Foo* f, + const gchar* s); +static gchar* __vala_lambda0__foo_func (Foo* foo, + const gchar* s, + gpointer self); +VALA_EXTERN Bar* bar_new (void); +VALA_EXTERN Bar* bar_construct (GType object_type); +static GObject * bar_constructor (GType type, + guint n_construct_properties, + GObjectConstructParam * construct_properties); +static gchar* _vala_lambda1_ (Bar* self, + Foo* f, + const gchar* s); +static gchar* __vala_lambda1__foo_func (Foo* foo, + const gchar* s, + gpointer self); +static GType bar_get_type_once (void); +VALA_EXTERN gpointer faz_ref (gpointer instance); +VALA_EXTERN void faz_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_faz (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_faz (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_faz (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_faz (const GValue* value); +VALA_EXTERN GType faz_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Faz, faz_unref) +VALA_EXTERN Faz* faz_new (void); +VALA_EXTERN Faz* faz_construct (GType object_type); +static void faz_finalize (Faz * obj); +static GType faz_get_type_once (void); +VALA_EXTERN gpointer boo_ref (gpointer instance); +VALA_EXTERN void boo_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_boo (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_boo (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_boo (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_boo (const GValue* value); +VALA_EXTERN GType boo_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Boo, boo_unref) +VALA_EXTERN Boo* boo_new (void); +VALA_EXTERN Boo* boo_construct (GType object_type); +static gchar* _vala_lambda2_ (Boo* self, + Faz* f, + const gchar* s); +static gchar* __vala_lambda2__faz_func (Faz* faz, + const gchar* s, + gpointer self); +VALA_EXTERN void boo_run (Boo* self); +static gchar* _vala_lambda3_ (Boo* self, + Faz* f, + const gchar* s); +static gchar* __vala_lambda3__faz_func (Faz* faz, + const gchar* s, + gpointer self); +static void boo_finalize (Boo * obj); +static GType boo_get_type_once (void); +static void _vala_main (void); +static gchar* _vala_lambda4_ (Foo* f, + const gchar* s); +static gchar* __vala_lambda4__foo_func (Foo* foo, + const gchar* s, + gpointer self); +static gchar* _vala_lambda5_ (Faz* f, + const gchar* s); +static gchar* __vala_lambda5__faz_func (Faz* faz, + const gchar* s, + gpointer self); + +Foo* +foo_construct (GType object_type) +{ + Foo * self = NULL; + self = (Foo*) g_object_new (object_type, NULL); + return self; +} + +Foo* +foo_new (void) +{ + return foo_construct (TYPE_FOO); +} + +static void +g_cclosure_user_marshal_STRING__STRING (GClosure * closure, + GValue * return_value, + guint n_param_values, + const GValue * param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef const char* (*GMarshalFunc_STRING__STRING) (gpointer data1, const char* arg_1, gpointer data2); + register GMarshalFunc_STRING__STRING callback; + register GCClosure * cc; + register gpointer data1; + register gpointer data2; + const char* v_return; + cc = (GCClosure *) closure; + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 2); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_STRING__STRING) (marshal_data ? marshal_data : cc->callback); + v_return = callback (data1, g_value_get_string (param_values + 1), data2); + g_value_take_string (return_value, v_return); +} + +static void +foo_class_init (FooClass * klass, + gpointer klass_data) +{ + foo_parent_class = g_type_class_peek_parent (klass); + foo_signals[FOO_TEST_SIGNAL] = g_signal_new ("test", TYPE_FOO, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_STRING__STRING, G_TYPE_STRING, 1, G_TYPE_STRING); +} + +static void +foo_instance_init (Foo * self, + gpointer klass) +{ +} + +static GType +foo_get_type_once (void) +{ + static const GTypeInfo g_define_type_info = { sizeof (FooClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) foo_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Foo), 0, (GInstanceInitFunc) foo_instance_init, NULL }; + GType foo_type_id; + foo_type_id = g_type_register_static (G_TYPE_OBJECT, "Foo", &g_define_type_info, 0); + return foo_type_id; +} + +GType +foo_get_type (void) +{ + static volatile gsize foo_type_id__once = 0; + if (g_once_init_enter (&foo_type_id__once)) { + GType foo_type_id; + foo_type_id = foo_get_type_once (); + g_once_init_leave (&foo_type_id__once, foo_type_id); + } + return foo_type_id__once; +} + +static gchar* +_vala_lambda0_ (Bar* self, + Foo* f, + const gchar* s) +{ + gchar* _tmp0_; + gchar* result; + g_return_val_if_fail (IS_FOO (f), NULL); + g_return_val_if_fail (s != NULL, NULL); + _vala_assert (g_strcmp0 (s, "foo") == 0, "s == \"foo\""); + _tmp0_ = g_strdup (s); + result = _tmp0_; + return result; +} + +static gchar* +__vala_lambda0__foo_func (Foo* foo, + const gchar* s, + gpointer self) +{ + gchar* result; + result = _vala_lambda0_ ((Bar*) self, foo, s); + return result; +} + +void +bar_run (Bar* self) +{ + Foo* foo = NULL; + Foo* _tmp0_; + FooFunc func = NULL; + gpointer func_target; + GDestroyNotify func_target_destroy_notify; + gchar* _tmp1_ = NULL; + gchar* _tmp2_; + guint _tmp3_; + gchar* _tmp4_ = NULL; + gchar* _tmp5_; + g_return_if_fail (IS_BAR (self)); + _tmp0_ = foo_new (); + foo = _tmp0_; + func = __vala_lambda0__foo_func; + func_target = g_object_ref (self); + func_target_destroy_notify = g_object_unref; + g_signal_connect_object (foo, "test", (GCallback) __vala_lambda0__foo_func, self, 0); + g_signal_emit (foo, foo_signals[FOO_TEST_SIGNAL], 0, "foo", &_tmp1_); + _tmp2_ = _tmp1_; + _vala_assert (g_strcmp0 (_tmp2_, "foo") == 0, "foo.test (\"foo\") == \"foo\""); + _g_free0 (_tmp2_); + g_signal_parse_name ("test", TYPE_FOO, &_tmp3_, NULL, FALSE); + g_signal_handlers_disconnect_matched (foo, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp3_, 0, NULL, (GCallback) __vala_lambda0__foo_func, self); + g_signal_emit (foo, foo_signals[FOO_TEST_SIGNAL], 0, "bar", &_tmp4_); + _tmp5_ = _tmp4_; + _g_free0 (_tmp5_); + (func_target_destroy_notify == NULL) ? NULL : (func_target_destroy_notify (func_target), NULL); + func = NULL; + func_target = NULL; + func_target_destroy_notify = NULL; + _g_object_unref0 (foo); +} + +Bar* +bar_construct (GType object_type) +{ + Bar * self = NULL; + self = (Bar*) g_object_new (object_type, NULL); + return self; +} + +Bar* +bar_new (void) +{ + return bar_construct (TYPE_BAR); +} + +static gchar* +_vala_lambda1_ (Bar* self, + Foo* f, + const gchar* s) +{ + gchar* _tmp0_; + gchar* result; + g_return_val_if_fail (IS_FOO (f), NULL); + g_return_val_if_fail (s != NULL, NULL); + _vala_assert (g_strcmp0 (s, "foo") == 0, "s == \"foo\""); + _tmp0_ = g_strdup (s); + result = _tmp0_; + return result; +} + +static gchar* +__vala_lambda1__foo_func (Foo* foo, + const gchar* s, + gpointer self) +{ + gchar* result; + result = _vala_lambda1_ ((Bar*) self, foo, s); + return result; +} + +static GObject * +bar_constructor (GType type, + guint n_construct_properties, + GObjectConstructParam * construct_properties) +{ + GObject * obj; + GObjectClass * parent_class; + Bar * self; + Foo* foo = NULL; + Foo* _tmp0_; + FooFunc func = NULL; + gpointer func_target; + GDestroyNotify func_target_destroy_notify; + Foo* _tmp1_; + FooFunc _tmp2_; + gpointer _tmp2__target; + Foo* _tmp3_; + gchar* _tmp4_ = NULL; + gchar* _tmp5_; + Foo* _tmp6_; + FooFunc _tmp7_; + gpointer _tmp7__target; + guint _tmp8_; + Foo* _tmp9_; + gchar* _tmp10_ = NULL; + gchar* _tmp11_; + parent_class = G_OBJECT_CLASS (bar_parent_class); + obj = parent_class->constructor (type, n_construct_properties, construct_properties); + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_BAR, Bar); + _tmp0_ = foo_new (); + foo = _tmp0_; + func = __vala_lambda1__foo_func; + func_target = g_object_ref (self); + func_target_destroy_notify = g_object_unref; + _tmp1_ = foo; + _tmp2_ = func; + _tmp2__target = func_target; + g_signal_connect_object (_tmp1_, "test", (GCallback) __vala_lambda1__foo_func, self, 0); + _tmp3_ = foo; + g_signal_emit (_tmp3_, foo_signals[FOO_TEST_SIGNAL], 0, "foo", &_tmp4_); + _tmp5_ = _tmp4_; + _vala_assert (g_strcmp0 (_tmp5_, "foo") == 0, "foo.test (\"foo\") == \"foo\""); + _g_free0 (_tmp5_); + _tmp6_ = foo; + _tmp7_ = func; + _tmp7__target = func_target; + g_signal_parse_name ("test", TYPE_FOO, &_tmp8_, NULL, FALSE); + g_signal_handlers_disconnect_matched (_tmp6_, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp8_, 0, NULL, (GCallback) __vala_lambda1__foo_func, self); + _tmp9_ = foo; + g_signal_emit (_tmp9_, foo_signals[FOO_TEST_SIGNAL], 0, "bar", &_tmp10_); + _tmp11_ = _tmp10_; + _g_free0 (_tmp11_); + (func_target_destroy_notify == NULL) ? NULL : (func_target_destroy_notify (func_target), NULL); + func = NULL; + func_target = NULL; + func_target_destroy_notify = NULL; + _g_object_unref0 (foo); + return obj; +} + +static void +bar_class_init (BarClass * klass, + gpointer klass_data) +{ + bar_parent_class = g_type_class_peek_parent (klass); + G_OBJECT_CLASS (klass)->constructor = bar_constructor; +} + +static void +bar_instance_init (Bar * self, + gpointer klass) +{ +} + +static GType +bar_get_type_once (void) +{ + static const GTypeInfo g_define_type_info = { sizeof (BarClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) bar_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Bar), 0, (GInstanceInitFunc) bar_instance_init, NULL }; + GType bar_type_id; + bar_type_id = g_type_register_static (G_TYPE_OBJECT, "Bar", &g_define_type_info, 0); + return bar_type_id; +} + +GType +bar_get_type (void) +{ + static volatile gsize bar_type_id__once = 0; + if (g_once_init_enter (&bar_type_id__once)) { + GType bar_type_id; + bar_type_id = bar_get_type_once (); + g_once_init_leave (&bar_type_id__once, bar_type_id); + } + return bar_type_id__once; +} + +Faz* +faz_construct (GType object_type) +{ + Faz* self = NULL; + self = (Faz*) g_type_create_instance (object_type); + return self; +} + +Faz* +faz_new (void) +{ + return faz_construct (TYPE_FAZ); +} + +static void +value_faz_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_faz_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + faz_unref (value->data[0].v_pointer); + } +} + +static void +value_faz_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = faz_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_faz_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_faz_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + Faz * object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = faz_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_faz_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + Faz ** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = faz_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_faz (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecFaz* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_FAZ), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + +gpointer +value_get_faz (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FAZ), NULL); + return value->data[0].v_pointer; +} + +void +value_set_faz (GValue* value, + gpointer v_object) +{ + Faz * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FAZ)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_FAZ)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + faz_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + faz_unref (old); + } +} + +void +value_take_faz (GValue* value, + gpointer v_object) +{ + Faz * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FAZ)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_FAZ)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + faz_unref (old); + } +} + +static void +faz_class_init (FazClass * klass, + gpointer klass_data) +{ + faz_parent_class = g_type_class_peek_parent (klass); + ((FazClass *) klass)->finalize = faz_finalize; + faz_signals[FAZ_TEST_SIGNAL] = g_signal_new ("test", TYPE_FAZ, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_STRING__STRING, G_TYPE_STRING, 1, G_TYPE_STRING); +} + +static void +faz_instance_init (Faz * self, + gpointer klass) +{ + self->ref_count = 1; +} + +static void +faz_finalize (Faz * obj) +{ + Faz * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_FAZ, Faz); + g_signal_handlers_destroy (self); +} + +static GType +faz_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_faz_init, value_faz_free_value, value_faz_copy_value, value_faz_peek_pointer, "p", value_faz_collect_value, "p", value_faz_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (FazClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) faz_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Faz), 0, (GInstanceInitFunc) faz_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType faz_type_id; + faz_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Faz", &g_define_type_info, &g_define_type_fundamental_info, 0); + return faz_type_id; +} + +GType +faz_get_type (void) +{ + static volatile gsize faz_type_id__once = 0; + if (g_once_init_enter (&faz_type_id__once)) { + GType faz_type_id; + faz_type_id = faz_get_type_once (); + g_once_init_leave (&faz_type_id__once, faz_type_id); + } + return faz_type_id__once; +} + +gpointer +faz_ref (gpointer instance) +{ + Faz * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +faz_unref (gpointer instance) +{ + Faz * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + FAZ_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + +static gchar* +_vala_lambda2_ (Boo* self, + Faz* f, + const gchar* s) +{ + gchar* _tmp0_; + gchar* result; + g_return_val_if_fail (IS_FAZ (f), NULL); + g_return_val_if_fail (s != NULL, NULL); + _vala_assert (g_strcmp0 (s, "faz") == 0, "s == \"faz\""); + _tmp0_ = g_strdup (s); + result = _tmp0_; + return result; +} + +static gchar* +__vala_lambda2__faz_func (Faz* faz, + const gchar* s, + gpointer self) +{ + gchar* result; + result = _vala_lambda2_ ((Boo*) self, faz, s); + return result; +} + +Boo* +boo_construct (GType object_type) +{ + Boo* self = NULL; + Faz* faz = NULL; + Faz* _tmp0_; + FazFunc func = NULL; + gpointer func_target; + GDestroyNotify func_target_destroy_notify; + gchar* _tmp1_ = NULL; + gchar* _tmp2_; + guint _tmp3_; + gchar* _tmp4_ = NULL; + gchar* _tmp5_; + self = (Boo*) g_type_create_instance (object_type); + _tmp0_ = faz_new (); + faz = _tmp0_; + func = __vala_lambda2__faz_func; + func_target = boo_ref (self); + func_target_destroy_notify = boo_unref; + g_signal_connect (faz, "test", (GCallback) __vala_lambda2__faz_func, self); + g_signal_emit (faz, faz_signals[FAZ_TEST_SIGNAL], 0, "faz", &_tmp1_); + _tmp2_ = _tmp1_; + _vala_assert (g_strcmp0 (_tmp2_, "faz") == 0, "faz.test (\"faz\") == \"faz\""); + _g_free0 (_tmp2_); + g_signal_parse_name ("test", TYPE_FAZ, &_tmp3_, NULL, FALSE); + g_signal_handlers_disconnect_matched (faz, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp3_, 0, NULL, (GCallback) __vala_lambda2__faz_func, self); + g_signal_emit (faz, faz_signals[FAZ_TEST_SIGNAL], 0, "boo", &_tmp4_); + _tmp5_ = _tmp4_; + _g_free0 (_tmp5_); + (func_target_destroy_notify == NULL) ? NULL : (func_target_destroy_notify (func_target), NULL); + func = NULL; + func_target = NULL; + func_target_destroy_notify = NULL; + _faz_unref0 (faz); + return self; +} + +Boo* +boo_new (void) +{ + return boo_construct (TYPE_BOO); +} + +static gchar* +_vala_lambda3_ (Boo* self, + Faz* f, + const gchar* s) +{ + gchar* _tmp0_; + gchar* result; + g_return_val_if_fail (IS_FAZ (f), NULL); + g_return_val_if_fail (s != NULL, NULL); + _vala_assert (g_strcmp0 (s, "faz") == 0, "s == \"faz\""); + _tmp0_ = g_strdup (s); + result = _tmp0_; + return result; +} + +static gchar* +__vala_lambda3__faz_func (Faz* faz, + const gchar* s, + gpointer self) +{ + gchar* result; + result = _vala_lambda3_ ((Boo*) self, faz, s); + return result; +} + +void +boo_run (Boo* self) +{ + Faz* faz = NULL; + Faz* _tmp0_; + FazFunc func = NULL; + gpointer func_target; + GDestroyNotify func_target_destroy_notify; + gchar* _tmp1_ = NULL; + gchar* _tmp2_; + guint _tmp3_; + gchar* _tmp4_ = NULL; + gchar* _tmp5_; + g_return_if_fail (IS_BOO (self)); + _tmp0_ = faz_new (); + faz = _tmp0_; + func = __vala_lambda3__faz_func; + func_target = boo_ref (self); + func_target_destroy_notify = boo_unref; + g_signal_connect (faz, "test", (GCallback) __vala_lambda3__faz_func, self); + g_signal_emit (faz, faz_signals[FAZ_TEST_SIGNAL], 0, "faz", &_tmp1_); + _tmp2_ = _tmp1_; + _vala_assert (g_strcmp0 (_tmp2_, "faz") == 0, "faz.test (\"faz\") == \"faz\""); + _g_free0 (_tmp2_); + g_signal_parse_name ("test", TYPE_FAZ, &_tmp3_, NULL, FALSE); + g_signal_handlers_disconnect_matched (faz, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp3_, 0, NULL, (GCallback) __vala_lambda3__faz_func, self); + g_signal_emit (faz, faz_signals[FAZ_TEST_SIGNAL], 0, "boo", &_tmp4_); + _tmp5_ = _tmp4_; + _g_free0 (_tmp5_); + (func_target_destroy_notify == NULL) ? NULL : (func_target_destroy_notify (func_target), NULL); + func = NULL; + func_target = NULL; + func_target_destroy_notify = NULL; + _faz_unref0 (faz); +} + +static void +value_boo_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_boo_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + boo_unref (value->data[0].v_pointer); + } +} + +static void +value_boo_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = boo_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_boo_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_boo_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + Boo * object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = boo_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_boo_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + Boo ** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = boo_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_boo (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecBoo* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_BOO), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + +gpointer +value_get_boo (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BOO), NULL); + return value->data[0].v_pointer; +} + +void +value_set_boo (GValue* value, + gpointer v_object) +{ + Boo * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BOO)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_BOO)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + boo_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + boo_unref (old); + } +} + +void +value_take_boo (GValue* value, + gpointer v_object) +{ + Boo * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BOO)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_BOO)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + boo_unref (old); + } +} + +static void +boo_class_init (BooClass * klass, + gpointer klass_data) +{ + boo_parent_class = g_type_class_peek_parent (klass); + ((BooClass *) klass)->finalize = boo_finalize; +} + +static void +boo_instance_init (Boo * self, + gpointer klass) +{ + self->ref_count = 1; +} + +static void +boo_finalize (Boo * obj) +{ + Boo * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_BOO, Boo); + g_signal_handlers_destroy (self); +} + +static GType +boo_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_boo_init, value_boo_free_value, value_boo_copy_value, value_boo_peek_pointer, "p", value_boo_collect_value, "p", value_boo_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (BooClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) boo_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Boo), 0, (GInstanceInitFunc) boo_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType boo_type_id; + boo_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Boo", &g_define_type_info, &g_define_type_fundamental_info, 0); + return boo_type_id; +} + +GType +boo_get_type (void) +{ + static volatile gsize boo_type_id__once = 0; + if (g_once_init_enter (&boo_type_id__once)) { + GType boo_type_id; + boo_type_id = boo_get_type_once (); + g_once_init_leave (&boo_type_id__once, boo_type_id); + } + return boo_type_id__once; +} + +gpointer +boo_ref (gpointer instance) +{ + Boo * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +boo_unref (gpointer instance) +{ + Boo * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + BOO_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + +static gchar* +_vala_lambda4_ (Foo* f, + const gchar* s) +{ + gchar* _tmp0_; + gchar* result; + g_return_val_if_fail (IS_FOO (f), NULL); + g_return_val_if_fail (s != NULL, NULL); + _vala_assert (g_strcmp0 (s, "foo") == 0, "s == \"foo\""); + _tmp0_ = g_strdup (s); + result = _tmp0_; + return result; +} + +static gchar* +__vala_lambda4__foo_func (Foo* foo, + const gchar* s, + gpointer self) +{ + gchar* result; + result = _vala_lambda4_ (foo, s); + return result; +} + +static gchar* +_vala_lambda5_ (Faz* f, + const gchar* s) +{ + gchar* _tmp0_; + gchar* result; + g_return_val_if_fail (IS_FAZ (f), NULL); + g_return_val_if_fail (s != NULL, NULL); + _vala_assert (g_strcmp0 (s, "faz") == 0, "s == \"faz\""); + _tmp0_ = g_strdup (s); + result = _tmp0_; + return result; +} + +static gchar* +__vala_lambda5__faz_func (Faz* faz, + const gchar* s, + gpointer self) +{ + gchar* result; + result = _vala_lambda5_ (faz, s); + return result; +} + +static void +_vala_main (void) +{ + { + Bar* bar = NULL; + Bar* _tmp0_; + Foo* foo = NULL; + Foo* _tmp1_; + FooFunc func = NULL; + gpointer func_target; + GDestroyNotify func_target_destroy_notify; + gchar* _tmp2_ = NULL; + gchar* _tmp3_; + guint _tmp4_; + gchar* _tmp5_ = NULL; + gchar* _tmp6_; + _tmp0_ = bar_new (); + bar = _tmp0_; + bar_run (bar); + _tmp1_ = foo_new (); + foo = _tmp1_; + func = __vala_lambda4__foo_func; + func_target = NULL; + func_target_destroy_notify = NULL; + g_signal_connect (foo, "test", (GCallback) __vala_lambda4__foo_func, NULL); + g_signal_emit (foo, foo_signals[FOO_TEST_SIGNAL], 0, "foo", &_tmp2_); + _tmp3_ = _tmp2_; + _vala_assert (g_strcmp0 (_tmp3_, "foo") == 0, "foo.test (\"foo\") == \"foo\""); + _g_free0 (_tmp3_); + g_signal_parse_name ("test", TYPE_FOO, &_tmp4_, NULL, FALSE); + g_signal_handlers_disconnect_matched (foo, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp4_, 0, NULL, (GCallback) __vala_lambda4__foo_func, NULL); + g_signal_emit (foo, foo_signals[FOO_TEST_SIGNAL], 0, "bar", &_tmp5_); + _tmp6_ = _tmp5_; + _g_free0 (_tmp6_); + (func_target_destroy_notify == NULL) ? NULL : (func_target_destroy_notify (func_target), NULL); + func = NULL; + func_target = NULL; + func_target_destroy_notify = NULL; + _g_object_unref0 (foo); + _g_object_unref0 (bar); + } + { + Boo* boo = NULL; + Boo* _tmp7_; + Faz* faz = NULL; + Faz* _tmp8_; + FazFunc func = NULL; + gpointer func_target; + GDestroyNotify func_target_destroy_notify; + gchar* _tmp9_ = NULL; + gchar* _tmp10_; + guint _tmp11_; + gchar* _tmp12_ = NULL; + gchar* _tmp13_; + _tmp7_ = boo_new (); + boo = _tmp7_; + boo_run (boo); + _tmp8_ = faz_new (); + faz = _tmp8_; + func = __vala_lambda5__faz_func; + func_target = NULL; + func_target_destroy_notify = NULL; + g_signal_connect (faz, "test", (GCallback) __vala_lambda5__faz_func, NULL); + g_signal_emit (faz, faz_signals[FAZ_TEST_SIGNAL], 0, "faz", &_tmp9_); + _tmp10_ = _tmp9_; + _vala_assert (g_strcmp0 (_tmp10_, "faz") == 0, "faz.test (\"faz\") == \"faz\""); + _g_free0 (_tmp10_); + g_signal_parse_name ("test", TYPE_FAZ, &_tmp11_, NULL, FALSE); + g_signal_handlers_disconnect_matched (faz, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp11_, 0, NULL, (GCallback) __vala_lambda5__faz_func, NULL); + g_signal_emit (faz, faz_signals[FAZ_TEST_SIGNAL], 0, "boo", &_tmp12_); + _tmp13_ = _tmp12_; + _g_free0 (_tmp13_); + (func_target_destroy_notify == NULL) ? NULL : (func_target_destroy_notify (func_target), NULL); + func = NULL; + func_target = NULL; + func_target_destroy_notify = NULL; + _faz_unref0 (faz); + _boo_unref0 (boo); + } +} + +int +main (int argc, + char ** argv) +{ + _vala_main (); + return 0; +} + diff --git a/tests/objects/signals-lambda-delegate-2.vala b/tests/objects/signals-lambda-delegate-2.vala new file mode 100644 index 000000000..8be4aaed0 --- /dev/null +++ b/tests/objects/signals-lambda-delegate-2.vala @@ -0,0 +1,94 @@ +delegate string FooFunc (Foo foo, string s); + +class Foo : Object { + public signal string test (string s); +} + +class Bar : Object { + construct { + var foo = new Foo (); + FooFunc func = (f,s) => { + assert (s == "foo"); + return s; + }; + foo.test.connect (func); + assert (foo.test ("foo") == "foo"); + foo.test.disconnect (func); + foo.test ("bar"); + } + + public void run () { + var foo = new Foo (); + FooFunc func = (f,s) => { + assert (s == "foo"); + return s; + }; + foo.test.connect (func); + assert (foo.test ("foo") == "foo"); + foo.test.disconnect (func); + foo.test ("bar"); + } +} + +delegate string FazFunc (Faz faz, string s); + +class Faz { + public signal string test (string s); +} + +class Boo { + public Boo () { + var faz = new Faz (); + FazFunc func = (f,s) => { + assert (s == "faz"); + return s; + }; + faz.test.connect (func); + assert (faz.test ("faz") == "faz"); + faz.test.disconnect (func); + faz.test ("boo"); + } + + public void run () { + var faz = new Faz (); + FazFunc func = (f,s) => { + assert (s == "faz"); + return s; + }; + faz.test.connect (func); + assert (faz.test ("faz") == "faz"); + faz.test.disconnect (func); + faz.test ("boo"); + } +} + +void main () { + { + var bar = new Bar (); + bar.run (); + + var foo = new Foo (); + FooFunc func = (f,s) => { + assert (s == "foo"); + return s; + }; + foo.test.connect (func); + assert (foo.test ("foo") == "foo"); + foo.test.disconnect (func); + foo.test ("bar"); + } + { + var boo = new Boo (); + boo.run (); + + var faz = new Faz (); + FazFunc func = (f,s) => { + assert (s == "faz"); + return s; + }; + faz.test.connect (func); + assert (faz.test ("faz") == "faz"); + faz.test.disconnect (func); + faz.test ("boo"); + } +} -- cgit v1.2.1