diff options
| -rw-r--r-- | tests/Makefile.am | 3 | ||||
| -rw-r--r-- | tests/asynchronous/main-block-async-call.c-expected | 216 | ||||
| -rw-r--r-- | tests/asynchronous/main-block-async-call.vala | 8 | ||||
| -rw-r--r-- | tests/asynchronous/main-block-async-creation.c-expected | 456 | ||||
| -rw-r--r-- | tests/asynchronous/main-block-async-creation.vala | 6 | ||||
| -rw-r--r-- | tests/asynchronous/main-block-async-yield.c-expected | 104 | ||||
| -rw-r--r-- | tests/asynchronous/main-block-async-yield.vala | 2 | ||||
| -rw-r--r-- | vala/valamethod.vala | 30 | ||||
| -rw-r--r-- | vala/valaparser.vala | 2 |
9 files changed, 826 insertions, 1 deletions
diff --git a/tests/Makefile.am b/tests/Makefile.am index 31a67f6e7..77eb144a1 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -731,6 +731,9 @@ TESTS = \ asynchronous/constructor-argument-check.vala \ asynchronous/finish-name.vala \ asynchronous/generator.vala \ + asynchronous/main-block-async-call.vala \ + asynchronous/main-block-async-creation.vala \ + asynchronous/main-block-async-yield.vala \ asynchronous/method-main-async.vala \ asynchronous/method-main-async-void.vala \ asynchronous/nowrapper.vala \ diff --git a/tests/asynchronous/main-block-async-call.c-expected b/tests/asynchronous/main-block-async-call.c-expected new file mode 100644 index 000000000..4eae9bfdc --- /dev/null +++ b/tests/asynchronous/main-block-async-call.c-expected @@ -0,0 +1,216 @@ +/* asynchronous_main_block_async_call.c generated by valac, the Vala compiler + * generated from asynchronous_main_block_async_call.vala, do not modify */ + +#include <gio/gio.h> +#include <stdlib.h> +#include <string.h> +#include <glib.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 _g_free0(var) (var = (g_free (var), NULL)) +typedef struct _FooData FooData; +typedef struct _ValaMainAsyncData ValaMainAsyncData; +#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 _FooData { + int _state_; + GObject* _source_object_; + GAsyncResult* _res_; + GTask* _async_result; + gchar* result; + gchar* _tmp0_; +}; + +struct _ValaMainAsyncData { + int _state_; + GObject* _source_object_; + GAsyncResult* _res_; + GTask* _async_result; + gchar* bar; + gchar* _tmp0_; +}; + +static void foo_data_free (gpointer _data); +VALA_EXTERN void foo (GAsyncReadyCallback _callback_, + gpointer _user_data_); +VALA_EXTERN gchar* foo_finish (GAsyncResult* _res_); +static gboolean foo_co (FooData* _data_); +static gboolean _foo_co_gsource_func (gpointer self); +static void _vala_main_async_data_free (gpointer _data); +static void _vala_main_async (GAsyncReadyCallback _callback_, + gpointer _user_data_); +static void _vala_main_finish (GAsyncResult* _res_); +static gboolean _vala_main_async_co (ValaMainAsyncData* _data_); +static void _vala_main_async_ready (GObject* source_object, + GAsyncResult* _res_, + gpointer _user_data_); + +static void +foo_data_free (gpointer _data) +{ + FooData* _data_; + _data_ = _data; + _g_free0 (_data_->result); + g_slice_free (FooData, _data_); +} + +void +foo (GAsyncReadyCallback _callback_, + gpointer _user_data_) +{ + FooData* _data_; + _data_ = g_slice_new0 (FooData); + _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_); + g_task_set_task_data (_data_->_async_result, _data_, foo_data_free); + foo_co (_data_); +} + +gchar* +foo_finish (GAsyncResult* _res_) +{ + gchar* result; + FooData* _data_; + _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL); + result = _data_->result; + _data_->result = NULL; + return result; +} + +static gboolean +_foo_co_gsource_func (gpointer self) +{ + gboolean result; + result = foo_co (self); + return result; +} + +static gboolean +foo_co (FooData* _data_) +{ + switch (_data_->_state_) { + case 0: + goto _state_0; + case 1: + goto _state_1; + default: + g_assert_not_reached (); + } + _state_0: + g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, _foo_co_gsource_func, _data_, NULL); + _data_->_state_ = 1; + return FALSE; + _state_1: + ; + _data_->_tmp0_ = g_strdup ("foo"); + _data_->result = _data_->_tmp0_; + g_task_return_pointer (_data_->_async_result, _data_, NULL); + if (_data_->_state_ != 0) { + while (!g_task_get_completed (_data_->_async_result)) { + g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE); + } + } + g_object_unref (_data_->_async_result); + return FALSE; +} + +static void +_vala_main_async_data_free (gpointer _data) +{ + ValaMainAsyncData* _data_; + _data_ = _data; + g_slice_free (ValaMainAsyncData, _data_); +} + +void +_vala_main_async (GAsyncReadyCallback _callback_, + gpointer _user_data_) +{ + ValaMainAsyncData* _data_; + _data_ = g_slice_new0 (ValaMainAsyncData); + _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_); + g_task_set_task_data (_data_->_async_result, _data_, _vala_main_async_data_free); + _vala_main_async_co (_data_); +} + +void +_vala_main_finish (GAsyncResult* _res_) +{ + ValaMainAsyncData* _data_; + _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL); +} + +static void +_vala_main_async_ready (GObject* source_object, + GAsyncResult* _res_, + gpointer _user_data_) +{ + ValaMainAsyncData* _data_; + _data_ = _user_data_; + _data_->_source_object_ = source_object; + _data_->_res_ = _res_; + _vala_main_async_co (_data_); +} + +static gboolean +_vala_main_async_co (ValaMainAsyncData* _data_) +{ + switch (_data_->_state_) { + case 0: + goto _state_0; + case 1: + goto _state_1; + default: + g_assert_not_reached (); + } + _state_0: + _data_->_state_ = 1; + foo (_vala_main_async_ready, _data_); + return FALSE; + _state_1: + _data_->_tmp0_ = foo_finish (_data_->_res_); + _data_->bar = _data_->_tmp0_; + _vala_assert (g_strcmp0 (_data_->bar, "foo") == 0, "bar == \"foo\""); + _g_free0 (_data_->bar); + g_task_return_pointer (_data_->_async_result, _data_, NULL); + if (_data_->_state_ != 0) { + while (!g_task_get_completed (_data_->_async_result)) { + g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE); + } + } + g_object_unref (_data_->_async_result); + return FALSE; +} + +static void +_vala_main_async_callback (GObject* source_object, + GAsyncResult* res, + gpointer user_data) +{ + GMainLoop* loop = user_data; + _vala_main_finish (res); + g_main_loop_quit (loop); +} + +int +main (int argc, + char ** argv) +{ + GMainLoop* loop = g_main_loop_new (NULL, FALSE); + _vala_main_async (_vala_main_async_callback, loop); + g_main_loop_run (loop); + g_main_loop_unref (loop); + return 0; +} + diff --git a/tests/asynchronous/main-block-async-call.vala b/tests/asynchronous/main-block-async-call.vala new file mode 100644 index 000000000..f1ce72a8e --- /dev/null +++ b/tests/asynchronous/main-block-async-call.vala @@ -0,0 +1,8 @@ +async string foo () { + Idle.add (foo.callback); + yield; + return "foo"; +} + +var bar = yield foo (); +assert (bar == "foo"); diff --git a/tests/asynchronous/main-block-async-creation.c-expected b/tests/asynchronous/main-block-async-creation.c-expected new file mode 100644 index 000000000..f84673cd4 --- /dev/null +++ b/tests/asynchronous/main-block-async-creation.c-expected @@ -0,0 +1,456 @@ +/* asynchronous_main_block_async_creation.c generated by valac, the Vala compiler + * generated from asynchronous_main_block_async_creation.vala, do not modify */ + +#include <glib-object.h> +#include <gio/gio.h> +#include <gobject/gvaluecollector.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_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; +#define _foo_unref0(var) ((var == NULL) ? NULL : (var = (foo_unref (var), NULL))) +typedef struct _FooNewData FooNewData; +typedef struct _ParamSpecFoo ParamSpecFoo; +typedef struct _ValaMainAsyncData ValaMainAsyncData; + +struct _Foo { + GTypeInstance parent_instance; + volatile int ref_count; + FooPrivate * priv; +}; + +struct _FooClass { + GTypeClass parent_class; + void (*finalize) (Foo *self); +}; + +struct _FooNewData { + int _state_; + GObject* _source_object_; + GAsyncResult* _res_; + GTask* _async_result; + GType object_type; + Foo* self; +}; + +struct _ParamSpecFoo { + GParamSpec parent_instance; +}; + +struct _ValaMainAsyncData { + int _state_; + GObject* _source_object_; + GAsyncResult* _res_; + GTask* _async_result; + Foo* bar; + Foo* _tmp0_; +}; + +static gpointer foo_parent_class = NULL; + +VALA_EXTERN gpointer foo_ref (gpointer instance); +VALA_EXTERN void foo_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_foo (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_foo (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_foo (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_foo (const GValue* value); +VALA_EXTERN GType foo_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Foo, foo_unref) +static void foo_construct_data_free (gpointer _data); +VALA_EXTERN void foo_new (GAsyncReadyCallback _callback_, + gpointer _user_data_); +VALA_EXTERN Foo* foo_new_finish (GAsyncResult* _res_); +VALA_EXTERN void foo_construct (GType object_type, + GAsyncReadyCallback _callback_, + gpointer _user_data_); +VALA_EXTERN Foo* foo_construct_finish (GAsyncResult* _res_); +static gboolean foo_construct_co (FooNewData* _data_); +static void foo_finalize (Foo * obj); +static GType foo_get_type_once (void); +static void _vala_main_async_data_free (gpointer _data); +static void _vala_main_async (GAsyncReadyCallback _callback_, + gpointer _user_data_); +static void _vala_main_finish (GAsyncResult* _res_); +static gboolean _vala_main_async_co (ValaMainAsyncData* _data_); +static void _vala_main_async_ready (GObject* source_object, + GAsyncResult* _res_, + gpointer _user_data_); + +static void +foo_construct_data_free (gpointer _data) +{ + FooNewData* _data_; + _data_ = _data; + _foo_unref0 (_data_->self); + g_slice_free (FooNewData, _data_); +} + +void +foo_construct (GType object_type, + GAsyncReadyCallback _callback_, + gpointer _user_data_) +{ + FooNewData* _data_; + _data_ = g_slice_new0 (FooNewData); + _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_); + g_task_set_task_data (_data_->_async_result, _data_, foo_construct_data_free); + _data_->object_type = object_type; + foo_construct_co (_data_); +} + +Foo* +foo_construct_finish (GAsyncResult* _res_) +{ + Foo* result; + FooNewData* _data_; + _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL); + result = _data_->self; + _data_->self = NULL; + return result; +} + +static gboolean +foo_construct_co (FooNewData* _data_) +{ + Foo* self = NULL; + switch (_data_->_state_) { + case 0: + goto _state_0; + default: + g_assert_not_reached (); + } + _state_0: + _data_->self = (Foo*) g_type_create_instance (_data_->object_type); + g_task_return_pointer (_data_->_async_result, _data_, NULL); + if (_data_->_state_ != 0) { + while (!g_task_get_completed (_data_->_async_result)) { + g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE); + } + } + g_object_unref (_data_->_async_result); + return FALSE; +} + +void +foo_new (GAsyncReadyCallback _callback_, + gpointer _user_data_) +{ + foo_construct (TYPE_FOO, _callback_, _user_data_); +} + +Foo* +foo_new_finish (GAsyncResult* _res_) +{ + return foo_construct_finish (_res_); +} + +static void +value_foo_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_foo_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + foo_unref (value->data[0].v_pointer); + } +} + +static void +value_foo_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = foo_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_foo_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_foo_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + Foo * 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 = foo_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_foo_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + Foo ** 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 = foo_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_foo (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecFoo* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_FOO), 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_foo (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FOO), NULL); + return value->data[0].v_pointer; +} + +void +value_set_foo (GValue* value, + gpointer v_object) +{ + Foo * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FOO)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_FOO)); + 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; + foo_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + foo_unref (old); + } +} + +void +value_take_foo (GValue* value, + gpointer v_object) +{ + Foo * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FOO)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_FOO)); + 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) { + foo_unref (old); + } +} + +static void +foo_class_init (FooClass * klass, + gpointer klass_data) +{ + foo_parent_class = g_type_class_peek_parent (klass); + ((FooClass *) klass)->finalize = foo_finalize; +} + +static void +foo_instance_init (Foo * self, + gpointer klass) +{ + self->ref_count = 1; +} + +static void +foo_finalize (Foo * obj) +{ + Foo * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_FOO, Foo); + g_signal_handlers_destroy (self); +} + +static GType +foo_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_foo_init, value_foo_free_value, value_foo_copy_value, value_foo_peek_pointer, "p", value_foo_collect_value, "p", value_foo_lcopy_value }; + 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, &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 foo_type_id; + foo_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Foo", &g_define_type_info, &g_define_type_fundamental_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; +} + +gpointer +foo_ref (gpointer instance) +{ + Foo * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +foo_unref (gpointer instance) +{ + Foo * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + FOO_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + +static void +_vala_main_async_data_free (gpointer _data) +{ + ValaMainAsyncData* _data_; + _data_ = _data; + g_slice_free (ValaMainAsyncData, _data_); +} + +void +_vala_main_async (GAsyncReadyCallback _callback_, + gpointer _user_data_) +{ + ValaMainAsyncData* _data_; + _data_ = g_slice_new0 (ValaMainAsyncData); + _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_); + g_task_set_task_data (_data_->_async_result, _data_, _vala_main_async_data_free); + _vala_main_async_co (_data_); +} + +void +_vala_main_finish (GAsyncResult* _res_) +{ + ValaMainAsyncData* _data_; + _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL); +} + +static void +_vala_main_async_ready (GObject* source_object, + GAsyncResult* _res_, + gpointer _user_data_) +{ + ValaMainAsyncData* _data_; + _data_ = _user_data_; + _data_->_source_object_ = source_object; + _data_->_res_ = _res_; + _vala_main_async_co (_data_); +} + +static gboolean +_vala_main_async_co (ValaMainAsyncData* _data_) +{ + switch (_data_->_state_) { + case 0: + goto _state_0; + case 1: + goto _state_1; + default: + g_assert_not_reached (); + } + _state_0: + _data_->_state_ = 1; + foo_new (_vala_main_async_ready, _data_); + return FALSE; + _state_1: + _data_->_tmp0_ = foo_new_finish (_data_->_res_); + _data_->bar = _data_->_tmp0_; + _foo_unref0 (_data_->bar); + g_task_return_pointer (_data_->_async_result, _data_, NULL); + if (_data_->_state_ != 0) { + while (!g_task_get_completed (_data_->_async_result)) { + g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE); + } + } + g_object_unref (_data_->_async_result); + return FALSE; +} + +static void +_vala_main_async_callback (GObject* source_object, + GAsyncResult* res, + gpointer user_data) +{ + GMainLoop* loop = user_data; + _vala_main_finish (res); + g_main_loop_quit (loop); +} + +int +main (int argc, + char ** argv) +{ + GMainLoop* loop = g_main_loop_new (NULL, FALSE); + _vala_main_async (_vala_main_async_callback, loop); + g_main_loop_run (loop); + g_main_loop_unref (loop); + return 0; +} + diff --git a/tests/asynchronous/main-block-async-creation.vala b/tests/asynchronous/main-block-async-creation.vala new file mode 100644 index 000000000..c147a2e28 --- /dev/null +++ b/tests/asynchronous/main-block-async-creation.vala @@ -0,0 +1,6 @@ +class Foo { + public async Foo () { + } +} + +var bar = yield new Foo (); diff --git a/tests/asynchronous/main-block-async-yield.c-expected b/tests/asynchronous/main-block-async-yield.c-expected new file mode 100644 index 000000000..994191243 --- /dev/null +++ b/tests/asynchronous/main-block-async-yield.c-expected @@ -0,0 +1,104 @@ +/* asynchronous_main_block_async_yield.c generated by valac, the Vala compiler + * generated from asynchronous_main_block_async_yield.vala, do not modify */ + +#include <gio/gio.h> +#include <glib.h> + +typedef struct _ValaMainAsyncData ValaMainAsyncData; + +struct _ValaMainAsyncData { + int _state_; + GObject* _source_object_; + GAsyncResult* _res_; + GTask* _async_result; +}; + +static void _vala_main_async_data_free (gpointer _data); +static void _vala_main_async (GAsyncReadyCallback _callback_, + gpointer _user_data_); +static void _vala_main_finish (GAsyncResult* _res_); +static gboolean _vala_main_async_co (ValaMainAsyncData* _data_); +static gboolean __vala_main_async_co_gsource_func (gpointer self); + +static void +_vala_main_async_data_free (gpointer _data) +{ + ValaMainAsyncData* _data_; + _data_ = _data; + g_slice_free (ValaMainAsyncData, _data_); +} + +void +_vala_main_async (GAsyncReadyCallback _callback_, + gpointer _user_data_) +{ + ValaMainAsyncData* _data_; + _data_ = g_slice_new0 (ValaMainAsyncData); + _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_); + g_task_set_task_data (_data_->_async_result, _data_, _vala_main_async_data_free); + _vala_main_async_co (_data_); +} + +void +_vala_main_finish (GAsyncResult* _res_) +{ + ValaMainAsyncData* _data_; + _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL); +} + +static gboolean +__vala_main_async_co_gsource_func (gpointer self) +{ + gboolean result; + result = _vala_main_async_co (self); + return result; +} + +static gboolean +_vala_main_async_co (ValaMainAsyncData* _data_) +{ + switch (_data_->_state_) { + case 0: + goto _state_0; + case 1: + goto _state_1; + default: + g_assert_not_reached (); + } + _state_0: + g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, __vala_main_async_co_gsource_func, _data_, NULL); + _data_->_state_ = 1; + return FALSE; + _state_1: + ; + g_task_return_pointer (_data_->_async_result, _data_, NULL); + if (_data_->_state_ != 0) { + while (!g_task_get_completed (_data_->_async_result)) { + g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE); + } + } + g_object_unref (_data_->_async_result); + return FALSE; +} + +static void +_vala_main_async_callback (GObject* source_object, + GAsyncResult* res, + gpointer user_data) +{ + GMainLoop* loop = user_data; + _vala_main_finish (res); + g_main_loop_quit (loop); +} + +int +main (int argc, + char ** argv) +{ + GMainLoop* loop = g_main_loop_new (NULL, FALSE); + _vala_main_async (_vala_main_async_callback, loop); + g_main_loop_run (loop); + g_main_loop_unref (loop); + return 0; +} + diff --git a/tests/asynchronous/main-block-async-yield.vala b/tests/asynchronous/main-block-async-yield.vala new file mode 100644 index 000000000..777b627ae --- /dev/null +++ b/tests/asynchronous/main-block-async-yield.vala @@ -0,0 +1,2 @@ +Idle.add (main.callback); +yield; diff --git a/vala/valamethod.vala b/vala/valamethod.vala index 53d5ce72d..fc8491594 100644 --- a/vala/valamethod.vala +++ b/vala/valamethod.vala @@ -133,6 +133,8 @@ public class Vala.Method : Subroutine, Callable { public bool entry_point { get; private set; } + public bool is_main_block { get; private set; } + /** * Specifies the generated `this` parameter for instance methods. */ @@ -222,6 +224,18 @@ public class Vala.Method : Subroutine, Callable { } /** + * Creates a new main block method. + * + * @param source_reference reference to source code + * @return newly created method + */ + public Method.main_block (SourceReference? source_reference = null) { + base ("main", source_reference, null); + return_type = new VoidType (); + is_main_block = true; + } + + /** * Appends parameter to this method. * * @param param a formal parameter @@ -818,6 +832,22 @@ public class Vala.Method : Subroutine, Callable { Report.error (source_reference, "Non-abstract, non-extern methods must have bodies"); } + // auto-convert main block to async if a yield expression is used + if (is_main_block && body != null) { + body.accept (new TraverseVisitor (node => { + if (!(node is Statement || node is Expression || node is Variable || node is CatchClause)) { + return TraverseStatus.STOP; + } + if (node is YieldStatement + || (node is MethodCall && ((MethodCall) node).is_yield_expression) + || (node is ObjectCreationExpression && ((ObjectCreationExpression) node).is_yield_expression)) { + coroutine = true; + return TraverseStatus.STOP; + } + return TraverseStatus.CONTINUE; + })); + } + if (coroutine && !external_package && !context.has_package ("gio-2.0")) { error = true; Report.error (source_reference, "gio-2.0 package required for async methods"); diff --git a/vala/valaparser.vala b/vala/valaparser.vala index 2f3a99016..ebb914da1 100644 --- a/vala/valaparser.vala +++ b/vala/valaparser.vala @@ -2637,7 +2637,7 @@ public class Vala.Parser : CodeVisitor { void parse_main_block (Symbol parent) throws ParseError { var begin = get_location (); - var method = new Method ("main", new VoidType (), new SourceReference (scanner.source_file, begin, begin)); + var method = new Method.main_block (new SourceReference (scanner.source_file, begin, begin)); method.access = SymbolAccessibility.PUBLIC; method.binding = MemberBinding.STATIC; method.body = new Block (get_src (begin)); |