diff options
-rw-r--r-- | tests/basic-types/arrays-move-with-class.c-expected | 527 |
1 files changed, 527 insertions, 0 deletions
diff --git a/tests/basic-types/arrays-move-with-class.c-expected b/tests/basic-types/arrays-move-with-class.c-expected new file mode 100644 index 000000000..b9ca5ba8f --- /dev/null +++ b/tests/basic-types/arrays-move-with-class.c-expected @@ -0,0 +1,527 @@ +/* basic_types_arrays_move_with_class.c generated by valac, the Vala compiler + * generated from basic_types_arrays_move_with_class.vala, do not modify */ + +#include <glib-object.h> +#include <glib.h> +#include <gobject/gvaluecollector.h> +#include <string.h> + +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#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_TEST_DESTRUCTOR_CALLS (test_destructor_calls_get_type ()) +#define TEST_DESTRUCTOR_CALLS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TEST_DESTRUCTOR_CALLS, TestDestructorCalls)) +#define TEST_DESTRUCTOR_CALLS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TEST_DESTRUCTOR_CALLS, TestDestructorCallsClass)) +#define IS_TEST_DESTRUCTOR_CALLS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TEST_DESTRUCTOR_CALLS)) +#define IS_TEST_DESTRUCTOR_CALLS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TEST_DESTRUCTOR_CALLS)) +#define TEST_DESTRUCTOR_CALLS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TEST_DESTRUCTOR_CALLS, TestDestructorCallsClass)) + +typedef struct _TestDestructorCalls TestDestructorCalls; +typedef struct _TestDestructorCallsClass TestDestructorCallsClass; +typedef struct _TestDestructorCallsPrivate TestDestructorCallsPrivate; +typedef struct _ParamSpecTestDestructorCalls ParamSpecTestDestructorCalls; +#define _test_destructor_calls_unref0(var) ((var == NULL) ? NULL : (var = (test_destructor_calls_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 _TestDestructorCalls { + GTypeInstance parent_instance; + volatile int ref_count; + TestDestructorCallsPrivate * priv; +}; + +struct _TestDestructorCallsClass { + GTypeClass parent_class; + void (*finalize) (TestDestructorCalls *self); +}; + +struct _TestDestructorCallsPrivate { + gint idx; +}; + +struct _ParamSpecTestDestructorCalls { + GParamSpec parent_instance; +}; + +static gint TestDestructorCalls_private_offset; +static gpointer test_destructor_calls_parent_class = NULL; +VALA_EXTERN gint test_destructor_calls_destructor_calls; +gint test_destructor_calls_destructor_calls = 0; + +VALA_EXTERN gpointer test_destructor_calls_ref (gpointer instance); +VALA_EXTERN void test_destructor_calls_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_test_destructor_calls (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_test_destructor_calls (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_test_destructor_calls (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_test_destructor_calls (const GValue* value); +VALA_EXTERN GType test_destructor_calls_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (TestDestructorCalls, test_destructor_calls_unref) +VALA_EXTERN TestDestructorCalls* test_destructor_calls_new (gint idx); +VALA_EXTERN TestDestructorCalls* test_destructor_calls_construct (GType object_type, + gint idx); +static void test_destructor_calls_finalize (TestDestructorCalls * obj); +static GType test_destructor_calls_get_type_once (void); +VALA_EXTERN void test_array_with_classes_move (gint src, + gint dest, + gint count, + gint expected_destructor_calls); +VALA_EXTERN void test_unowned_array_move (gint src, + gint dest, + gint count); +static void _vala_main (void); +static void _vala_array_destroy (gpointer array, + gssize array_length, + GDestroyNotify destroy_func); +static void _vala_array_free (gpointer array, + gssize array_length, + GDestroyNotify destroy_func); +static void _vala_array_move (gpointer array, + gsize element_size, + GDestroyNotify free_func, + gssize src, + gssize dest, + gssize length); + +static inline gpointer +test_destructor_calls_get_instance_private (TestDestructorCalls* self) +{ + return G_STRUCT_MEMBER_P (self, TestDestructorCalls_private_offset); +} + +TestDestructorCalls* +test_destructor_calls_construct (GType object_type, + gint idx) +{ + TestDestructorCalls* self = NULL; + self = (TestDestructorCalls*) g_type_create_instance (object_type); + self->priv->idx = idx; + return self; +} + +TestDestructorCalls* +test_destructor_calls_new (gint idx) +{ + return test_destructor_calls_construct (TYPE_TEST_DESTRUCTOR_CALLS, idx); +} + +static void +value_test_destructor_calls_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_test_destructor_calls_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + test_destructor_calls_unref (value->data[0].v_pointer); + } +} + +static void +value_test_destructor_calls_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = test_destructor_calls_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_test_destructor_calls_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_test_destructor_calls_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + TestDestructorCalls * 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 = test_destructor_calls_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_test_destructor_calls_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + TestDestructorCalls ** 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 = test_destructor_calls_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_test_destructor_calls (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecTestDestructorCalls* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_TEST_DESTRUCTOR_CALLS), 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_test_destructor_calls (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST_DESTRUCTOR_CALLS), NULL); + return value->data[0].v_pointer; +} + +void +value_set_test_destructor_calls (GValue* value, + gpointer v_object) +{ + TestDestructorCalls * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST_DESTRUCTOR_CALLS)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST_DESTRUCTOR_CALLS)); + 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; + test_destructor_calls_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + test_destructor_calls_unref (old); + } +} + +void +value_take_test_destructor_calls (GValue* value, + gpointer v_object) +{ + TestDestructorCalls * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST_DESTRUCTOR_CALLS)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST_DESTRUCTOR_CALLS)); + 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) { + test_destructor_calls_unref (old); + } +} + +static void +test_destructor_calls_class_init (TestDestructorCallsClass * klass, + gpointer klass_data) +{ + test_destructor_calls_parent_class = g_type_class_peek_parent (klass); + ((TestDestructorCallsClass *) klass)->finalize = test_destructor_calls_finalize; + g_type_class_adjust_private_offset (klass, &TestDestructorCalls_private_offset); +} + +static void +test_destructor_calls_instance_init (TestDestructorCalls * self, + gpointer klass) +{ + self->priv = test_destructor_calls_get_instance_private (self); + self->ref_count = 1; +} + +static void +test_destructor_calls_finalize (TestDestructorCalls * obj) +{ + TestDestructorCalls * self; + gint _tmp0_; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_TEST_DESTRUCTOR_CALLS, TestDestructorCalls); + g_signal_handlers_destroy (self); + _tmp0_ = test_destructor_calls_destructor_calls; + test_destructor_calls_destructor_calls = _tmp0_ + 1; +} + +static GType +test_destructor_calls_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_test_destructor_calls_init, value_test_destructor_calls_free_value, value_test_destructor_calls_copy_value, value_test_destructor_calls_peek_pointer, "p", value_test_destructor_calls_collect_value, "p", value_test_destructor_calls_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (TestDestructorCallsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) test_destructor_calls_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TestDestructorCalls), 0, (GInstanceInitFunc) test_destructor_calls_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 test_destructor_calls_type_id; + test_destructor_calls_type_id = g_type_register_fundamental (g_type_fundamental_next (), "TestDestructorCalls", &g_define_type_info, &g_define_type_fundamental_info, 0); + TestDestructorCalls_private_offset = g_type_add_instance_private (test_destructor_calls_type_id, sizeof (TestDestructorCallsPrivate)); + return test_destructor_calls_type_id; +} + +GType +test_destructor_calls_get_type (void) +{ + static volatile gsize test_destructor_calls_type_id__once = 0; + if (g_once_init_enter (&test_destructor_calls_type_id__once)) { + GType test_destructor_calls_type_id; + test_destructor_calls_type_id = test_destructor_calls_get_type_once (); + g_once_init_leave (&test_destructor_calls_type_id__once, test_destructor_calls_type_id); + } + return test_destructor_calls_type_id__once; +} + +gpointer +test_destructor_calls_ref (gpointer instance) +{ + TestDestructorCalls * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +test_destructor_calls_unref (gpointer instance) +{ + TestDestructorCalls * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + TEST_DESTRUCTOR_CALLS_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + +void +test_array_with_classes_move (gint src, + gint dest, + gint count, + gint expected_destructor_calls) +{ + static const gint arr_size = 5; + TestDestructorCalls** arr = NULL; + TestDestructorCalls** _tmp0_; + gint arr_length1; + gint _arr_size_; + test_destructor_calls_destructor_calls = 0; + _tmp0_ = g_new0 (TestDestructorCalls*, arr_size + 1); + arr = _tmp0_; + arr_length1 = arr_size; + _arr_size_ = arr_length1; + { + gint i = 0; + i = 0; + { + gboolean _tmp1_ = FALSE; + _tmp1_ = TRUE; + while (TRUE) { + TestDestructorCalls** _tmp3_; + gint _tmp3__length1; + TestDestructorCalls* _tmp4_; + if (!_tmp1_) { + gint _tmp2_; + _tmp2_ = i; + i = _tmp2_ + 1; + } + _tmp1_ = FALSE; + if (!(i < arr_size)) { + break; + } + _tmp3_ = arr; + _tmp3__length1 = arr_length1; + _tmp4_ = test_destructor_calls_new (i); + _test_destructor_calls_unref0 (_tmp3_[i]); + _tmp3_[i] = _tmp4_; + } + } + } + _vala_array_move (arr, sizeof (TestDestructorCalls*), test_destructor_calls_unref, src, dest, count); + _vala_assert (test_destructor_calls_destructor_calls == expected_destructor_calls, "TestDestructorCalls.destructor_calls == expected_destructor_calls"); + arr = (_vala_array_free (arr, arr_length1, (GDestroyNotify) test_destructor_calls_unref), NULL); +} + +static gpointer +_test_destructor_calls_ref0 (gpointer self) +{ + return self ? test_destructor_calls_ref (self) : NULL; +} + +void +test_unowned_array_move (gint src, + gint dest, + gint count) +{ + static const gint arr_size = 5; + TestDestructorCalls** arr = NULL; + TestDestructorCalls** _tmp0_; + gint arr_length1; + gint _arr_size_; + TestDestructorCalls** owner = NULL; + TestDestructorCalls** _tmp1_; + gint owner_length1; + gint _owner_size_; + test_destructor_calls_destructor_calls = 0; + _tmp0_ = g_new0 (TestDestructorCalls*, arr_size + 1); + arr = _tmp0_; + arr_length1 = arr_size; + _arr_size_ = arr_length1; + _tmp1_ = g_new0 (TestDestructorCalls*, arr_size + 1); + owner = _tmp1_; + owner_length1 = arr_size; + _owner_size_ = owner_length1; + { + gint i = 0; + i = 0; + { + gboolean _tmp2_ = FALSE; + _tmp2_ = TRUE; + while (TRUE) { + TestDestructorCalls* obj = NULL; + TestDestructorCalls* _tmp4_; + TestDestructorCalls** _tmp5_; + gint _tmp5__length1; + TestDestructorCalls* _tmp6_; + TestDestructorCalls* _tmp7_; + TestDestructorCalls** _tmp8_; + gint _tmp8__length1; + TestDestructorCalls* _tmp9_; + if (!_tmp2_) { + gint _tmp3_; + _tmp3_ = i; + i = _tmp3_ + 1; + } + _tmp2_ = FALSE; + if (!(i < arr_size)) { + break; + } + _tmp4_ = test_destructor_calls_new (i); + obj = _tmp4_; + _tmp5_ = owner; + _tmp5__length1 = owner_length1; + _tmp6_ = obj; + _tmp7_ = _test_destructor_calls_ref0 (_tmp6_); + _test_destructor_calls_unref0 (_tmp5_[i]); + _tmp5_[i] = _tmp7_; + _tmp8_ = arr; + _tmp8__length1 = arr_length1; + _tmp9_ = obj; + _tmp8_[i] = _tmp9_; + _test_destructor_calls_unref0 (obj); + } + } + } + _vala_array_move (arr, sizeof (TestDestructorCalls*), NULL, src, dest, count); + _vala_assert (test_destructor_calls_destructor_calls == 0, "TestDestructorCalls.destructor_calls == 0"); + owner = (_vala_array_free (owner, owner_length1, (GDestroyNotify) test_destructor_calls_unref), NULL); + arr = (g_free (arr), NULL); +} + +static void +_vala_main (void) +{ + test_array_with_classes_move (0, 2, 3, 1); + test_array_with_classes_move (2, 0, 3, 2); + test_array_with_classes_move (0, 3, 1, 1); + test_unowned_array_move (3, 0, 1); +} + +int +main (int argc, + char ** argv) +{ + _vala_main (); + return 0; +} + +static void +_vala_array_destroy (gpointer array, + gssize array_length, + GDestroyNotify destroy_func) +{ + if ((array != NULL) && (destroy_func != NULL)) { + gssize i; + for (i = 0; i < array_length; i = i + 1) { + if (((gpointer*) array)[i] != NULL) { + destroy_func (((gpointer*) array)[i]); + } + } + } +} + +static void +_vala_array_free (gpointer array, + gssize array_length, + GDestroyNotify destroy_func) +{ + _vala_array_destroy (array, array_length, destroy_func); + g_free (array); +} + +static void +_vala_array_move (gpointer array, + gsize element_size, + GDestroyNotify free_func, + gssize src, + gssize dest, + gssize length) +{ + if (free_func != NULL) { + if ((src < dest) && ((src + length) > dest)) { + gssize i; + for (i = dest; i < (src + length); i++) { + free_func (((void**) array)[i]); + } + } else if ((src > dest) && (src < (dest + length))) { + gssize i; + for (i = dest; i < src; i++) { + free_func (((void**) array)[i]); + } + } else if (src != dest) { + gssize i; + for (i = dest; i < (dest + length); i++) { + free_func (((void**) array)[i]); + } + } + } + memmove (((char*) array) + (dest * element_size), ((char*) array) + (src * element_size), length * element_size); + if ((src < dest) && ((src + length) > dest)) { + memset (((char*) array) + (src * element_size), 0, (dest - src) * element_size); + } else if ((src > dest) && (src < (dest + length))) { + memset (((char*) array) + ((dest + length) * element_size), 0, (src - dest) * element_size); + } else if (src != dest) { + memset (((char*) array) + (src * element_size), 0, length * element_size); + } +} + |