From: Rico Tzschichholz Date: Sat, 29 Jul 2023 12:59:52 +0000 (+0200) Subject: Add new c-expected X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=fe2be99d2cd593f5e5c2377306bae95040082628;p=thirdparty%2Fvala.git Add new c-expected --- diff --git a/tests/generics/no-generic-args.c-expected b/tests/generics/no-generic-args.c-expected new file mode 100644 index 000000000..47a6cd6e7 --- /dev/null +++ b/tests/generics/no-generic-args.c-expected @@ -0,0 +1,334 @@ +/* generics_no_generic_args.c generated by valac, the Vala compiler + * generated from generics_no_generic_args.vala, do not modify */ + +#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 struct _FooPrivate FooPrivate; +enum { + FOO_0_PROPERTY, + FOO_BAR_PROPERTY, + FOO_NUM_PROPERTIES +}; +static GParamSpec* foo_properties[FOO_NUM_PROPERTIES]; + +#define TYPE_BAZ (baz_get_type ()) +#define BAZ(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BAZ, Baz)) +#define BAZ_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BAZ, BazClass)) +#define IS_BAZ(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BAZ)) +#define IS_BAZ_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BAZ)) +#define BAZ_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BAZ, BazClass)) + +typedef struct _Baz Baz; +typedef struct _BazClass BazClass; +typedef struct _BazPrivate BazPrivate; +enum { + BAZ_0_PROPERTY, + BAZ_NUM_PROPERTIES +}; +static GParamSpec* baz_properties[BAZ_NUM_PROPERTIES]; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) + +struct _Foo { + GObject parent_instance; + FooPrivate * priv; +}; + +struct _FooClass { + GObjectClass parent_class; +}; + +struct _FooPrivate { + gpointer _bar; +}; + +struct _Baz { + GObject parent_instance; + BazPrivate * priv; +}; + +struct _BazClass { + GObjectClass parent_class; +}; + +static gint Foo_private_offset; +static gpointer foo_parent_class = NULL; +static gpointer baz_parent_class = NULL; + +VALA_EXTERN GType foo_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Foo, g_object_unref) +VALA_EXTERN gpointer foo_get_b (Foo* self); +VALA_EXTERN gconstpointer foo_get_bar (Foo* self); +VALA_EXTERN void foo_set_b (Foo* self, + gconstpointer b); +VALA_EXTERN void foo_set_bar (Foo* self, + gconstpointer value); +VALA_EXTERN Foo* foo_new (void); +VALA_EXTERN Foo* foo_construct (GType object_type); +static void foo_finalize (GObject * obj); +static GType foo_get_type_once (void); +static void _vala_foo_get_property (GObject * object, + guint property_id, + GValue * value, + GParamSpec * pspec); +static void _vala_foo_set_property (GObject * object, + guint property_id, + const GValue * value, + GParamSpec * pspec); +VALA_EXTERN GType baz_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Baz, g_object_unref) +VALA_EXTERN Baz* baz_new (void); +VALA_EXTERN Baz* baz_construct (GType object_type); +static GType baz_get_type_once (void); +static void _vala_main (void); + +static inline gpointer +foo_get_instance_private (Foo* self) +{ + return G_STRUCT_MEMBER_P (self, Foo_private_offset); +} + +gpointer +foo_get_b (Foo* self) +{ + gconstpointer _tmp0_; + gpointer _tmp1_; + gpointer result; + g_return_val_if_fail (IS_FOO (self), NULL); + _tmp0_ = self->priv->_bar; + _tmp1_ = (_tmp0_ != NULL) ? g_object_ref ((gpointer) _tmp0_) : ((gpointer) _tmp0_); + result = _tmp1_; + return result; +} + +void +foo_set_b (Foo* self, + gconstpointer b) +{ + g_return_if_fail (IS_FOO (self)); + foo_set_bar (self, b); +} + +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); +} + +gconstpointer +foo_get_bar (Foo* self) +{ + gconstpointer result; + gconstpointer _tmp0_; + g_return_val_if_fail (IS_FOO (self), NULL); + _tmp0_ = self->priv->_bar; + result = _tmp0_; + return result; +} + +void +foo_set_bar (Foo* self, + gconstpointer value) +{ + gpointer old_value; + g_return_if_fail (IS_FOO (self)); + old_value = foo_get_bar (self); + if (old_value != value) { + gpointer _tmp0_; + _tmp0_ = (value != NULL) ? g_object_ref ((gpointer) value) : ((gpointer) value); + (self->priv->_bar == NULL) ? NULL : (self->priv->_bar = (g_object_unref (self->priv->_bar), NULL)); + self->priv->_bar = _tmp0_; + g_object_notify_by_pspec ((GObject *) self, foo_properties[FOO_BAR_PROPERTY]); + } +} + +static void +foo_class_init (FooClass * klass, + gpointer klass_data) +{ + foo_parent_class = g_type_class_peek_parent (klass); + g_type_class_adjust_private_offset (klass, &Foo_private_offset); + G_OBJECT_CLASS (klass)->get_property = _vala_foo_get_property; + G_OBJECT_CLASS (klass)->set_property = _vala_foo_set_property; + G_OBJECT_CLASS (klass)->finalize = foo_finalize; + g_object_class_install_property (G_OBJECT_CLASS (klass), FOO_BAR_PROPERTY, foo_properties[FOO_BAR_PROPERTY] = g_param_spec_pointer ("bar", "bar", "bar", G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE)); +} + +static void +foo_instance_init (Foo * self, + gpointer klass) +{ + self->priv = foo_get_instance_private (self); +} + +static void +foo_finalize (GObject * obj) +{ + Foo * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_FOO, Foo); + (self->priv->_bar == NULL) ? NULL : (self->priv->_bar = (g_object_unref (self->priv->_bar), NULL)); + G_OBJECT_CLASS (foo_parent_class)->finalize (obj); +} + +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); + Foo_private_offset = g_type_add_instance_private (foo_type_id, sizeof (FooPrivate)); + 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 void +_vala_foo_get_property (GObject * object, + guint property_id, + GValue * value, + GParamSpec * pspec) +{ + Foo * self; + self = G_TYPE_CHECK_INSTANCE_CAST (object, TYPE_FOO, Foo); + switch (property_id) { + case FOO_BAR_PROPERTY: + g_value_set_pointer (value, foo_get_bar (self)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +_vala_foo_set_property (GObject * object, + guint property_id, + const GValue * value, + GParamSpec * pspec) +{ + Foo * self; + self = G_TYPE_CHECK_INSTANCE_CAST (object, TYPE_FOO, Foo); + switch (property_id) { + case FOO_BAR_PROPERTY: + foo_set_bar (self, g_value_get_pointer (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +Baz* +baz_construct (GType object_type) +{ + Baz * self = NULL; + self = (Baz*) g_object_new (object_type, NULL); + return self; +} + +Baz* +baz_new (void) +{ + return baz_construct (TYPE_BAZ); +} + +static void +baz_class_init (BazClass * klass, + gpointer klass_data) +{ + baz_parent_class = g_type_class_peek_parent (klass); +} + +static void +baz_instance_init (Baz * self, + gpointer klass) +{ +} + +static GType +baz_get_type_once (void) +{ + static const GTypeInfo g_define_type_info = { sizeof (BazClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) baz_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Baz), 0, (GInstanceInitFunc) baz_instance_init, NULL }; + GType baz_type_id; + baz_type_id = g_type_register_static (G_TYPE_OBJECT, "Baz", &g_define_type_info, 0); + return baz_type_id; +} + +GType +baz_get_type (void) +{ + static volatile gsize baz_type_id__once = 0; + if (g_once_init_enter (&baz_type_id__once)) { + GType baz_type_id; + baz_type_id = baz_get_type_once (); + g_once_init_leave (&baz_type_id__once, baz_type_id); + } + return baz_type_id__once; +} + +static void +_vala_main (void) +{ + Foo* f = NULL; + Foo* _tmp0_; + Baz* _tmp1_; + Baz* _tmp2_; + Baz* b = NULL; + gpointer _tmp3_; + _tmp0_ = foo_new (); + f = _tmp0_; + _tmp1_ = baz_new (); + _tmp2_ = _tmp1_; + foo_set_b (f, _tmp2_); + _g_object_unref0 (_tmp2_); + _tmp3_ = foo_get_b (f); + b = (Baz*) _tmp3_; + _g_object_unref0 (b); + _g_object_unref0 (f); +} + +int +main (int argc, + char ** argv) +{ + _vala_main (); + return 0; +} + diff --git a/tests/parser/generics-constraints.c-expected b/tests/parser/generics-constraints.c-expected new file mode 100644 index 000000000..d534d4f72 --- /dev/null +++ b/tests/parser/generics-constraints.c-expected @@ -0,0 +1,595 @@ +/* parser_generics_constraints.c generated by valac, the Vala compiler + * generated from parser_generics_constraints.vala, do not modify */ + +#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_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; +typedef struct _ParamSpecBar ParamSpecBar; + +#define TYPE_IFOO (ifoo_get_type ()) +#define IFOO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_IFOO, IFoo)) +#define IS_IFOO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_IFOO)) +#define IFOO_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_IFOO, IFooIface)) + +typedef struct _IFoo IFoo; +typedef struct _IFooIface IFooIface; + +#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 struct _FooPrivate FooPrivate; +enum { + FOO_0_PROPERTY, + FOO_T_TYPE, + FOO_T_DUP_FUNC, + FOO_T_DESTROY_FUNC, + FOO_NUM_PROPERTIES +}; +static GParamSpec* foo_properties[FOO_NUM_PROPERTIES]; + +#define TYPE_FOO_STRUCT (foo_struct_get_type ()) +typedef struct _FooStruct FooStruct; +typedef gpointer (*FooFunc) (gconstpointer t, gpointer user_data); + +struct _Bar { + GTypeInstance parent_instance; + volatile int ref_count; + BarPrivate * priv; +}; + +struct _BarClass { + GTypeClass parent_class; + void (*finalize) (Bar *self); +}; + +struct _ParamSpecBar { + GParamSpec parent_instance; +}; + +struct _IFooIface { + GTypeInterface parent_iface; +}; + +struct _Foo { + GObject parent_instance; + FooPrivate * priv; +}; + +struct _FooClass { + GObjectClass parent_class; +}; + +struct _FooPrivate { + GType t_type; + GBoxedCopyFunc t_dup_func; + GDestroyNotify t_destroy_func; +}; + +struct _FooStruct { + gpointer t; +}; + +static gpointer bar_parent_class = NULL; +static gint Foo_private_offset; +static gpointer foo_parent_class = NULL; +static IFooIface * foo_ifoo_parent_iface = NULL; + +VALA_EXTERN gpointer bar_ref (gpointer instance); +VALA_EXTERN void bar_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_bar (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_bar (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_bar (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_bar (const GValue* value); +VALA_EXTERN GType bar_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Bar, bar_unref) +VALA_EXTERN Bar* bar_new (void); +VALA_EXTERN Bar* bar_construct (GType object_type); +static void bar_finalize (Bar * obj); +static GType bar_get_type_once (void); +VALA_EXTERN GType ifoo_get_type (void) G_GNUC_CONST ; +static GType ifoo_get_type_once (void); +VALA_EXTERN GType foo_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Foo, g_object_unref) +VALA_EXTERN Foo* foo_new (GType t_type, + GBoxedCopyFunc t_dup_func, + GDestroyNotify t_destroy_func); +VALA_EXTERN Foo* foo_construct (GType object_type, + GType t_type, + GBoxedCopyFunc t_dup_func, + GDestroyNotify t_destroy_func); +static GType foo_get_type_once (void); +static void _vala_foo_get_property (GObject * object, + guint property_id, + GValue * value, + GParamSpec * pspec); +static void _vala_foo_set_property (GObject * object, + guint property_id, + const GValue * value, + GParamSpec * pspec); +VALA_EXTERN GType foo_struct_get_type (void) G_GNUC_CONST ; +VALA_EXTERN FooStruct* foo_struct_dup (const FooStruct* self); +VALA_EXTERN void foo_struct_free (FooStruct* self); +VALA_EXTERN void foo_struct_copy (const FooStruct* self, + FooStruct* dest); +VALA_EXTERN void foo_struct_destroy (FooStruct* self); +G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (FooStruct, foo_struct_destroy) +VALA_EXTERN gpointer foo (GType t_type, + GBoxedCopyFunc t_dup_func, + GDestroyNotify t_destroy_func, + gconstpointer t); +static void _vala_main (void); + +Bar* +bar_construct (GType object_type) +{ + Bar* self = NULL; + self = (Bar*) g_type_create_instance (object_type); + return self; +} + +Bar* +bar_new (void) +{ + return bar_construct (TYPE_BAR); +} + +static void +value_bar_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_bar_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + bar_unref (value->data[0].v_pointer); + } +} + +static void +value_bar_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = bar_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_bar_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_bar_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + Bar * 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 = bar_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_bar_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + Bar ** 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 = bar_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_bar (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecBar* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_BAR), 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_bar (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BAR), NULL); + return value->data[0].v_pointer; +} + +void +value_set_bar (GValue* value, + gpointer v_object) +{ + Bar * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BAR)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_BAR)); + 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; + bar_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + bar_unref (old); + } +} + +void +value_take_bar (GValue* value, + gpointer v_object) +{ + Bar * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BAR)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_BAR)); + 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) { + bar_unref (old); + } +} + +static void +bar_class_init (BarClass * klass, + gpointer klass_data) +{ + bar_parent_class = g_type_class_peek_parent (klass); + ((BarClass *) klass)->finalize = bar_finalize; +} + +static void +bar_instance_init (Bar * self, + gpointer klass) +{ + self->ref_count = 1; +} + +static void +bar_finalize (Bar * obj) +{ + Bar * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_BAR, Bar); + g_signal_handlers_destroy (self); +} + +static GType +bar_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_bar_init, value_bar_free_value, value_bar_copy_value, value_bar_peek_pointer, "p", value_bar_collect_value, "p", value_bar_lcopy_value }; + 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, &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 bar_type_id; + bar_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Bar", &g_define_type_info, &g_define_type_fundamental_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; +} + +gpointer +bar_ref (gpointer instance) +{ + Bar * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +bar_unref (gpointer instance) +{ + Bar * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + BAR_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + +static void +ifoo_default_init (IFooIface * iface, + gpointer iface_data) +{ +} + +static GType +ifoo_get_type_once (void) +{ + static const GTypeInfo g_define_type_info = { sizeof (IFooIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ifoo_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL }; + GType ifoo_type_id; + ifoo_type_id = g_type_register_static (G_TYPE_INTERFACE, "IFoo", &g_define_type_info, 0); + return ifoo_type_id; +} + +GType +ifoo_get_type (void) +{ + static volatile gsize ifoo_type_id__once = 0; + if (g_once_init_enter (&ifoo_type_id__once)) { + GType ifoo_type_id; + ifoo_type_id = ifoo_get_type_once (); + g_once_init_leave (&ifoo_type_id__once, ifoo_type_id); + } + return ifoo_type_id__once; +} + +static inline gpointer +foo_get_instance_private (Foo* self) +{ + return G_STRUCT_MEMBER_P (self, Foo_private_offset); +} + +Foo* +foo_construct (GType object_type, + GType t_type, + GBoxedCopyFunc t_dup_func, + GDestroyNotify t_destroy_func) +{ + Foo * self = NULL; + self = (Foo*) g_object_new (object_type, "t-type", t_type, "t-dup-func", t_dup_func, "t-destroy-func", t_destroy_func, NULL); + self->priv->t_type = t_type; + self->priv->t_dup_func = t_dup_func; + self->priv->t_destroy_func = t_destroy_func; + return self; +} + +Foo* +foo_new (GType t_type, + GBoxedCopyFunc t_dup_func, + GDestroyNotify t_destroy_func) +{ + return foo_construct (TYPE_FOO, t_type, t_dup_func, t_destroy_func); +} + +static void +foo_class_init (FooClass * klass, + gpointer klass_data) +{ + foo_parent_class = g_type_class_peek_parent (klass); + g_type_class_adjust_private_offset (klass, &Foo_private_offset); + G_OBJECT_CLASS (klass)->get_property = _vala_foo_get_property; + G_OBJECT_CLASS (klass)->set_property = _vala_foo_set_property; + g_object_class_install_property (G_OBJECT_CLASS (klass), FOO_T_TYPE, g_param_spec_gtype ("t-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (G_OBJECT_CLASS (klass), FOO_T_DUP_FUNC, g_param_spec_pointer ("t-dup-func", "dup func", "dup func", G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (G_OBJECT_CLASS (klass), FOO_T_DESTROY_FUNC, g_param_spec_pointer ("t-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); +} + +static void +foo_ifoo_interface_init (IFooIface * iface, + gpointer iface_data) +{ + foo_ifoo_parent_iface = g_type_interface_peek_parent (iface); +} + +static void +foo_instance_init (Foo * self, + gpointer klass) +{ + self->priv = foo_get_instance_private (self); +} + +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 }; + static const GInterfaceInfo ifoo_info = { (GInterfaceInitFunc) foo_ifoo_interface_init, (GInterfaceFinalizeFunc) NULL, NULL}; + GType foo_type_id; + foo_type_id = g_type_register_static (G_TYPE_OBJECT, "Foo", &g_define_type_info, 0); + g_type_add_interface_static (foo_type_id, TYPE_IFOO, &ifoo_info); + Foo_private_offset = g_type_add_instance_private (foo_type_id, sizeof (FooPrivate)); + 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 void +_vala_foo_get_property (GObject * object, + guint property_id, + GValue * value, + GParamSpec * pspec) +{ + Foo * self; + self = G_TYPE_CHECK_INSTANCE_CAST (object, TYPE_FOO, Foo); + switch (property_id) { + case FOO_T_TYPE: + g_value_set_gtype (value, self->priv->t_type); + break; + case FOO_T_DUP_FUNC: + g_value_set_pointer (value, self->priv->t_dup_func); + break; + case FOO_T_DESTROY_FUNC: + g_value_set_pointer (value, self->priv->t_destroy_func); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +static void +_vala_foo_set_property (GObject * object, + guint property_id, + const GValue * value, + GParamSpec * pspec) +{ + Foo * self; + self = G_TYPE_CHECK_INSTANCE_CAST (object, TYPE_FOO, Foo); + switch (property_id) { + case FOO_T_TYPE: + self->priv->t_type = g_value_get_gtype (value); + break; + case FOO_T_DUP_FUNC: + self->priv->t_dup_func = g_value_get_pointer (value); + break; + case FOO_T_DESTROY_FUNC: + self->priv->t_destroy_func = g_value_get_pointer (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + break; + } +} + +void +foo_struct_copy (const FooStruct* self, + FooStruct* dest) +{ + gconstpointer _tmp0_; + _tmp0_ = (*self).t; + (*dest).t = _tmp0_; +} + +void +foo_struct_destroy (FooStruct* self) +{ +} + +FooStruct* +foo_struct_dup (const FooStruct* self) +{ + FooStruct* dup; + dup = g_new0 (FooStruct, 1); + foo_struct_copy (self, dup); + return dup; +} + +void +foo_struct_free (FooStruct* self) +{ + foo_struct_destroy (self); + g_free (self); +} + +static GType +foo_struct_get_type_once (void) +{ + GType foo_struct_type_id; + foo_struct_type_id = g_boxed_type_register_static ("FooStruct", (GBoxedCopyFunc) foo_struct_dup, (GBoxedFreeFunc) foo_struct_free); + return foo_struct_type_id; +} + +GType +foo_struct_get_type (void) +{ + static volatile gsize foo_struct_type_id__once = 0; + if (g_once_init_enter (&foo_struct_type_id__once)) { + GType foo_struct_type_id; + foo_struct_type_id = foo_struct_get_type_once (); + g_once_init_leave (&foo_struct_type_id__once, foo_struct_type_id); + } + return foo_struct_type_id__once; +} + +gpointer +foo (GType t_type, + GBoxedCopyFunc t_dup_func, + GDestroyNotify t_destroy_func, + gconstpointer t) +{ + gpointer result; + result = NULL; + return result; +} + +static void +_vala_main (void) +{ +} + +int +main (int argc, + char ** argv) +{ + _vala_main (); + return 0; +} +