From: Mazhar Hussain Date: Sat, 24 Dec 2022 11:25:24 +0000 (+0500) Subject: genie: Allow attribute and declaration on the same line X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=a693ed070f507e1f07660d42c40aa7b0b505c38b;p=thirdparty%2Fvala.git genie: Allow attribute and declaration on the same line Fixes https://gitlab.gnome.org/GNOME/vala/issues/1386 --- diff --git a/tests/Makefile.am b/tests/Makefile.am index 00ecce086..f2206a219 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -1387,6 +1387,7 @@ TESTS = \ version/since-local-variable.test \ version/since-method.test \ version/since-parameter.test \ + genie/attributes.gs \ genie/case.gs \ genie/class.gs \ genie/class-abstract.gs \ diff --git a/tests/genie/attributes.c-expected b/tests/genie/attributes.c-expected new file mode 100644 index 000000000..53b456fab --- /dev/null +++ b/tests/genie/attributes.c-expected @@ -0,0 +1,720 @@ +/* genie_attributes.c generated by valac, the Vala compiler + * generated from genie_attributes.gs, 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_TEST1 (test1_get_type ()) +#define TEST1(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TEST1, Test1)) +#define TEST1_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TEST1, Test1Class)) +#define IS_TEST1(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TEST1)) +#define IS_TEST1_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TEST1)) +#define TEST1_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TEST1, Test1Class)) + +typedef struct _Test1 Test1; +typedef struct _Test1Class Test1Class; +typedef struct _Test1Private Test1Private; +typedef struct _ParamSpecTest1 ParamSpecTest1; + +#define TYPE_TEST2 (test2_get_type ()) +#define TEST2(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TEST2, Test2)) +#define TEST2_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TEST2, Test2Class)) +#define IS_TEST2(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TEST2)) +#define IS_TEST2_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TEST2)) +#define TEST2_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TEST2, Test2Class)) + +typedef struct _Test2 Test2; +typedef struct _Test2Class Test2Class; +typedef struct _Test2Private Test2Private; +typedef struct _ParamSpecTest2 ParamSpecTest2; +#define _g_free0(var) (var = (g_free (var), NULL)) +#define _test2_unref0(var) ((var == NULL) ? NULL : (var = (test2_unref (var), NULL))) +#define _test1_unref0(var) ((var == NULL) ? NULL : (var = (test1_unref (var), NULL))) + +struct _Test1 { + GTypeInstance parent_instance; + volatile int ref_count; + Test1Private * priv; + gint c_test1_field; +}; + +struct _Test1Class { + GTypeClass parent_class; + void (*finalize) (Test1 *self); +}; + +struct _Test1Private { + gint _test1_prop; +}; + +struct _ParamSpecTest1 { + GParamSpec parent_instance; +}; + +struct _Test2 { + GTypeInstance parent_instance; + volatile int ref_count; + Test2Private * priv; + gint c_test2_field; +}; + +struct _Test2Class { + GTypeClass parent_class; + void (*finalize) (Test2 *self); +}; + +struct _Test2Private { + gint _test2_prop; +}; + +struct _ParamSpecTest2 { + GParamSpec parent_instance; +}; + +static gint Test1_private_offset; +static gpointer test1_parent_class = NULL; +static gint Test2_private_offset; +static gpointer test2_parent_class = NULL; + +VALA_EXTERN gpointer test1_ref (gpointer instance); +VALA_EXTERN void test1_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_test1 (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_test1 (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_test1 (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_test1 (const GValue* value); +VALA_EXTERN GType test1_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Test1, test1_unref) +VALA_EXTERN gint c_test1_method (Test1* self, + gint c_a, + gint c_b); +VALA_EXTERN Test1* test1_new (void); +VALA_EXTERN Test1* test1_construct (GType object_type); +VALA_EXTERN gint test1_get_test1_prop (Test1* self); +VALA_EXTERN void test1_set_test1_prop (Test1* self, + gint value); +static void test1_finalize (Test1 * obj); +static GType test1_get_type_once (void); +VALA_EXTERN gpointer test2_ref (gpointer instance); +VALA_EXTERN void test2_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_test2 (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_test2 (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_test2 (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_test2 (const GValue* value); +VALA_EXTERN GType test2_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Test2, test2_unref) +VALA_EXTERN gint c_test2_method (Test2* self, + gint c_a, + gint c_b); +VALA_EXTERN Test2* test2_new (void); +VALA_EXTERN Test2* test2_construct (GType object_type); +VALA_EXTERN gint test2_get_test2_prop (Test2* self); +VALA_EXTERN void test2_set_test2_prop (Test2* self, + gint value); +static void test2_finalize (Test2 * obj); +static GType test2_get_type_once (void); +static void _vala_main (gchar** args, + gint args_length1); + +static inline gpointer +test1_get_instance_private (Test1* self) +{ + return G_STRUCT_MEMBER_P (self, Test1_private_offset); +} + +gint +c_test1_method (Test1* self, + gint c_a, + gint c_b) +{ + gint result; + g_return_val_if_fail (IS_TEST1 (self), 0); + result = c_a + c_b; + return result; +} + +Test1* +test1_construct (GType object_type) +{ + Test1* self = NULL; + self = (Test1*) g_type_create_instance (object_type); + return self; +} + +Test1* +test1_new (void) +{ + return test1_construct (TYPE_TEST1); +} + +gint +test1_get_test1_prop (Test1* self) +{ + gint result; + g_return_val_if_fail (IS_TEST1 (self), 0); + result = self->priv->_test1_prop; + return result; +} + +void +test1_set_test1_prop (Test1* self, + gint value) +{ + g_return_if_fail (IS_TEST1 (self)); + self->priv->_test1_prop = value; +} + +static void +value_test1_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_test1_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + test1_unref (value->data[0].v_pointer); + } +} + +static void +value_test1_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = test1_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_test1_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_test1_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + Test1 * 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 = test1_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_test1_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + Test1 ** 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 = test1_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_test1 (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecTest1* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_TEST1), 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_test1 (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST1), NULL); + return value->data[0].v_pointer; +} + +void +value_set_test1 (GValue* value, + gpointer v_object) +{ + Test1 * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST1)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST1)); + 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; + test1_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + test1_unref (old); + } +} + +void +value_take_test1 (GValue* value, + gpointer v_object) +{ + Test1 * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST1)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST1)); + 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) { + test1_unref (old); + } +} + +static void +test1_class_init (Test1Class * klass, + gpointer klass_data) +{ + test1_parent_class = g_type_class_peek_parent (klass); + ((Test1Class *) klass)->finalize = test1_finalize; + g_type_class_adjust_private_offset (klass, &Test1_private_offset); +} + +static void +test1_instance_init (Test1 * self, + gpointer klass) +{ + self->priv = test1_get_instance_private (self); + self->c_test1_field = 2; + self->priv->_test1_prop = 1; + self->ref_count = 1; +} + +static void +test1_finalize (Test1 * obj) +{ + Test1 * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_TEST1, Test1); + g_signal_handlers_destroy (self); +} + +static GType +test1_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_test1_init, value_test1_free_value, value_test1_copy_value, value_test1_peek_pointer, "p", value_test1_collect_value, "p", value_test1_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (Test1Class), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) test1_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Test1), 0, (GInstanceInitFunc) test1_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 test1_type_id; + test1_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Test1", &g_define_type_info, &g_define_type_fundamental_info, 0); + Test1_private_offset = g_type_add_instance_private (test1_type_id, sizeof (Test1Private)); + return test1_type_id; +} + +GType +test1_get_type (void) +{ + static volatile gsize test1_type_id__once = 0; + if (g_once_init_enter (&test1_type_id__once)) { + GType test1_type_id; + test1_type_id = test1_get_type_once (); + g_once_init_leave (&test1_type_id__once, test1_type_id); + } + return test1_type_id__once; +} + +gpointer +test1_ref (gpointer instance) +{ + Test1 * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +test1_unref (gpointer instance) +{ + Test1 * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + TEST1_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + +static inline gpointer +test2_get_instance_private (Test2* self) +{ + return G_STRUCT_MEMBER_P (self, Test2_private_offset); +} + +gint +c_test2_method (Test2* self, + gint c_a, + gint c_b) +{ + gint result; + g_return_val_if_fail (IS_TEST2 (self), 0); + result = c_a + c_b; + return result; +} + +Test2* +test2_construct (GType object_type) +{ + Test2* self = NULL; + self = (Test2*) g_type_create_instance (object_type); + return self; +} + +Test2* +test2_new (void) +{ + return test2_construct (TYPE_TEST2); +} + +gint +test2_get_test2_prop (Test2* self) +{ + gint result; + g_return_val_if_fail (IS_TEST2 (self), 0); + result = self->priv->_test2_prop; + return result; +} + +void +test2_set_test2_prop (Test2* self, + gint value) +{ + g_return_if_fail (IS_TEST2 (self)); + self->priv->_test2_prop = value; +} + +static void +value_test2_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_test2_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + test2_unref (value->data[0].v_pointer); + } +} + +static void +value_test2_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = test2_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_test2_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_test2_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + Test2 * 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 = test2_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_test2_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + Test2 ** 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 = test2_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_test2 (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecTest2* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_TEST2), 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_test2 (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST2), NULL); + return value->data[0].v_pointer; +} + +void +value_set_test2 (GValue* value, + gpointer v_object) +{ + Test2 * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST2)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST2)); + 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; + test2_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + test2_unref (old); + } +} + +void +value_take_test2 (GValue* value, + gpointer v_object) +{ + Test2 * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST2)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST2)); + 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) { + test2_unref (old); + } +} + +static void +test2_class_init (Test2Class * klass, + gpointer klass_data) +{ + test2_parent_class = g_type_class_peek_parent (klass); + ((Test2Class *) klass)->finalize = test2_finalize; + g_type_class_adjust_private_offset (klass, &Test2_private_offset); +} + +static void +test2_instance_init (Test2 * self, + gpointer klass) +{ + self->priv = test2_get_instance_private (self); + self->c_test2_field = 2; + self->priv->_test2_prop = 1; + self->ref_count = 1; +} + +static void +test2_finalize (Test2 * obj) +{ + Test2 * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_TEST2, Test2); + g_signal_handlers_destroy (self); +} + +static GType +test2_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_test2_init, value_test2_free_value, value_test2_copy_value, value_test2_peek_pointer, "p", value_test2_collect_value, "p", value_test2_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (Test2Class), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) test2_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Test2), 0, (GInstanceInitFunc) test2_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 test2_type_id; + test2_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Test2", &g_define_type_info, &g_define_type_fundamental_info, 0); + Test2_private_offset = g_type_add_instance_private (test2_type_id, sizeof (Test2Private)); + return test2_type_id; +} + +GType +test2_get_type (void) +{ + static volatile gsize test2_type_id__once = 0; + if (g_once_init_enter (&test2_type_id__once)) { + GType test2_type_id; + test2_type_id = test2_get_type_once (); + g_once_init_leave (&test2_type_id__once, test2_type_id); + } + return test2_type_id__once; +} + +gpointer +test2_ref (gpointer instance) +{ + Test2 * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +test2_unref (gpointer instance) +{ + Test2 * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + TEST2_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + +static void +_vala_main (gchar** args, + gint args_length1) +{ + Test1* test1 = NULL; + Test1* _tmp0_; + Test2* test2 = NULL; + Test2* _tmp1_; + gchar* _tmp2_; + gchar* _tmp3_; + gint _tmp4_; + gint _tmp5_; + gchar* _tmp6_; + gchar* _tmp7_; + gchar* _tmp8_; + gchar* _tmp9_; + gchar* _tmp10_; + gchar* _tmp11_; + gchar* _tmp12_; + gchar* _tmp13_; + gint _tmp14_; + gint _tmp15_; + gchar* _tmp16_; + gchar* _tmp17_; + gchar* _tmp18_; + gchar* _tmp19_; + gchar* _tmp20_; + gchar* _tmp21_; + _tmp0_ = test1_new (); + test1 = _tmp0_; + _tmp1_ = test2_new (); + test2 = _tmp1_; + _tmp2_ = g_strdup_printf ("%i", test1->c_test1_field); + _tmp3_ = _tmp2_; + _tmp4_ = test1_get_test1_prop (test1); + _tmp5_ = _tmp4_; + _tmp6_ = g_strdup_printf ("%i", _tmp5_); + _tmp7_ = _tmp6_; + _tmp8_ = g_strdup_printf ("%i", c_test1_method (test1, 3, 4)); + _tmp9_ = _tmp8_; + _tmp10_ = g_strconcat ("Test1: ", _tmp3_, " ", _tmp7_, " ", _tmp9_, NULL); + _tmp11_ = _tmp10_; + g_print ("%s\n", _tmp11_); + _g_free0 (_tmp11_); + _g_free0 (_tmp9_); + _g_free0 (_tmp7_); + _g_free0 (_tmp3_); + _tmp12_ = g_strdup_printf ("%i", test2->c_test2_field); + _tmp13_ = _tmp12_; + _tmp14_ = test2_get_test2_prop (test2); + _tmp15_ = _tmp14_; + _tmp16_ = g_strdup_printf ("%i", _tmp15_); + _tmp17_ = _tmp16_; + _tmp18_ = g_strdup_printf ("%i", c_test2_method (test2, 3, 4)); + _tmp19_ = _tmp18_; + _tmp20_ = g_strconcat ("Test2: ", _tmp13_, " ", _tmp17_, " ", _tmp19_, NULL); + _tmp21_ = _tmp20_; + g_print ("%s\n", _tmp21_); + _g_free0 (_tmp21_); + _g_free0 (_tmp19_); + _g_free0 (_tmp17_); + _g_free0 (_tmp13_); + _test2_unref0 (test2); + _test1_unref0 (test1); +} + +int +main (int argc, + char ** argv) +{ + _vala_main (argv, argc); + return 0; +} + diff --git a/tests/genie/attributes.gs b/tests/genie/attributes.gs new file mode 100644 index 000000000..7126a0deb --- /dev/null +++ b/tests/genie/attributes.gs @@ -0,0 +1,30 @@ +class Test1 + [CCode (cname="c_test1_field")] + test1_field: int = 2 + + [CCode (cname="c_test1_prop")] + prop test1_prop: int = 1 + + [CCode (cname="c_test1_method")] + def test1_method ([CCode (cname="c_a")] + a: int = 3, + + [CCode (cname="c_b")] + b: int = 4 + + ): int + return a + b + +class Test2 + [CCode (cname="c_test2_field")] test2_field: int = 2 + [CCode (cname="c_test2_prop")] prop test2_prop: int = 1 + [CCode (cname="c_test2_method")] def test2_method ([CCode (cname="c_a")] a: int = 3, + [CCode (cname="c_b")] b: int = 4 + ): int + return a + b + +init + var test1 = new Test1 + var test2 = new Test2 + print(@"Test1: $(test1.test1_field) $(test1.test1_prop) $(test1.test1_method())") + print(@"Test2: $(test2.test2_field) $(test2.test2_prop) $(test2.test2_method())") diff --git a/vala/valagenieparser.vala b/vala/valagenieparser.vala index 4134b21c8..46c29d272 100644 --- a/vala/valagenieparser.vala +++ b/vala/valagenieparser.vala @@ -2383,7 +2383,7 @@ public class Vala.Genie.Parser : CodeVisitor { } } - List? parse_attributes (bool parameter) throws ParseError { + List? parse_attributes () throws ParseError { if (current () != TokenType.OPEN_BRACKET) { return null; } @@ -2407,8 +2407,8 @@ public class Vala.Genie.Parser : CodeVisitor { } while (accept (TokenType.COMMA)); expect (TokenType.CLOSE_BRACKET); } - if (!parameter) - expect (TokenType.EOL); + accept (TokenType.EOL); + return attrs; } @@ -2425,7 +2425,7 @@ public class Vala.Genie.Parser : CodeVisitor { Symbol parse_declaration (bool is_root = false) throws ParseError { comment = scanner.pop_comment (); - var attrs = parse_attributes (false); + var attrs = parse_attributes (); var begin = get_location (); switch (current ()) { @@ -3132,7 +3132,7 @@ public class Vala.Genie.Parser : CodeVisitor { expect (TokenType.INDENT); while (current () != TokenType.DEDENT) { var accessor_begin = get_location (); - var attribs = parse_attributes (false); + var attribs = parse_attributes (); var value_type = type.copy (); value_type.value_owned = accept (TokenType.OWNED); @@ -3459,7 +3459,7 @@ public class Vala.Genie.Parser : CodeVisitor { // allow trailing comma break; } - var value_attrs = parse_attributes (false); + var value_attrs = parse_attributes (); var value_begin = get_location (); string id = parse_identifier (); comment = scanner.pop_comment (); @@ -3520,7 +3520,7 @@ public class Vala.Genie.Parser : CodeVisitor { // allow trailing comma break; } - var code_attrs = parse_attributes (false); + var code_attrs = parse_attributes (); var code_begin = get_location (); string id = parse_identifier (); comment = scanner.pop_comment (); @@ -3655,7 +3655,7 @@ public class Vala.Genie.Parser : CodeVisitor { } Parameter parse_parameter () throws ParseError { - var attrs = parse_attributes (true); + var attrs = parse_attributes (); var begin = get_location (); if (accept (TokenType.ELLIPSIS)) { // varargs