#include <windows.h>
#endif /* G_OS_WIN32 */
+#ifdef HAVE_MACH_MACH_TIME_H
+#include <mach/mach_time.h>
+#endif
+
#include "glib_trace.h"
#include "gmain.h"
* is that new types of event source can be created and used in
* addition to the builtin type of event source. A new event source
* type is used for handling GDK events. A new source type is created
- * by <firstterm>deriving</firstterm> from the #GSource structure.
- * The derived type of source is represented by a structure that has
- * the #GSource structure as a first element, and other elements specific
- * to the new source type. To create an instance of the new source type,
- * call g_source_new() passing in the size of the derived structure and
+ * by "deriving" from the #GSource structure. The derived type of
+ * source is represented by a structure that has the #GSource structure
+ * as a first element, and other elements specific to the new source
+ * type. To create an instance of the new source type, call
+ * g_source_new() passing in the size of the derived structure and
* a table of functions. These #GSourceFuncs determine the behavior of
* the new source type.
*
* g_main_context_prepare(), g_main_context_query(),
* g_main_context_check() and g_main_context_dispatch().
*
+ * ## State of a Main Context # {#mainloop-states}
+ *
* The operation of these functions can best be seen in terms
- * of a state diagram, as shown in <xref linkend="mainloop-states"/>.
- * <figure id="mainloop-states"><title>States of a Main Context</title>
- * <graphic fileref="mainloop-states.gif" format="GIF"></graphic>
- * </figure>
+ * of a state diagram, as shown in this image.
+ *
+ * 
*
* On UNIX, the GLib mainloop is incompatible with fork(). Any program
* using the mainloop must either exec() or exit() from the child
gint ref_count;
+ GHashTable *sources; /* guint -> GSource */
+
GPtrArray *pending_dispatches;
gint timeout; /* Timeout for current iteration */
guint next_id;
- GHashTable *overflow_used_source_ids; /* set<guint> */
GList *source_lists;
gint in_check_or_prepare;
}
g_list_free (context->source_lists);
- if (context->overflow_used_source_ids)
- g_hash_table_destroy (context->overflow_used_source_ids);
+ g_hash_table_destroy (context->sources);
g_mutex_clear (&context->mutex);
*
* Creates a new #GMainContext structure.
*
- * Return value: the new #GMainContext
+ * Returns: the new #GMainContext
**/
GMainContext *
g_main_context_new (void)
g_mutex_init (&context->mutex);
g_cond_init (&context->cond);
+ context->sources = g_hash_table_new (NULL, NULL);
context->owner = NULL;
context->waiters = NULL;
* specified, and corresponds to the "main" main loop. See also
* g_main_context_get_thread_default().
*
- * Return value: (transfer none): the global default main context.
+ * Returns: (transfer none): the global default main context.
**/
GMainContext *
g_main_context_default (void)
*
* Acquires @context and sets it as the thread-default context for the
* current thread. This will cause certain asynchronous operations
- * (such as most <link linkend="gio">gio</link>-based I/O) which are
+ * (such as most [gio][gio]-based I/O) which are
* started in this thread to run under @context and deliver their
* results to its main loop, rather than running under the global
* default context in the main thread. Note that calling this function
* Creates a new #GSource structure. The size is specified to
* allow creating structures derived from #GSource that contain
* additional data. The size passed in must be at least
- * <literal>sizeof (GSource)</literal>.
+ * `sizeof (GSource)`.
*
* The source will not initially be associated with any #GMainContext
* and must be added to one with g_source_attach() before it will be
* executed.
*
- * Return value: the newly-created #GSource.
+ * Returns: the newly-created #GSource.
**/
GSource *
g_source_new (GSourceFuncs *source_funcs,
context->source_lists = g_list_remove (context->source_lists, source_list);
g_slice_free (GSourceList, source_list);
}
-
- if (context->overflow_used_source_ids)
- g_hash_table_remove (context->overflow_used_source_ids,
- GUINT_TO_POINTER (source->source_id));
-
-}
-
-static void
-assign_source_id_unlocked (GMainContext *context,
- GSource *source)
-{
- guint id;
-
- /* Are we about to overflow back to 0?
- * See https://bugzilla.gnome.org/show_bug.cgi?id=687098
- */
- if (G_UNLIKELY (context->next_id == G_MAXUINT &&
- context->overflow_used_source_ids == NULL))
- {
- GSourceIter iter;
- GSource *source;
-
- context->overflow_used_source_ids = g_hash_table_new (NULL, NULL);
-
- g_source_iter_init (&iter, context, FALSE);
- while (g_source_iter_next (&iter, &source))
- {
- g_hash_table_add (context->overflow_used_source_ids,
- GUINT_TO_POINTER (source->source_id));
- }
- id = G_MAXUINT;
- g_hash_table_add (context->overflow_used_source_ids, GUINT_TO_POINTER (id));
- }
- else if (context->overflow_used_source_ids == NULL)
- {
- id = context->next_id++;
- }
- else
- {
- /*
- * If we overran G_MAXUINT, we fall back to randomly probing the
- * source ids for the current context. This will be slower the more
- * sources there are, but we're mainly concerned right now about
- * correctness and code size. There's time for a more clever solution
- * later.
- */
- do
- id = g_random_int ();
- while (id == 0 ||
- g_hash_table_contains (context->overflow_used_source_ids,
- GUINT_TO_POINTER (id)));
- g_hash_table_add (context->overflow_used_source_ids, GUINT_TO_POINTER (id));
- }
-
- source->source_id = id;
}
static guint
gboolean do_wakeup)
{
GSList *tmp_list;
+ guint id;
+
+ /* The counter may have wrapped, so we must ensure that we do not
+ * reuse the source id of an existing source.
+ */
+ do
+ id = context->next_id++;
+ while (id == 0 || g_hash_table_contains (context->sources, GUINT_TO_POINTER (id)));
source->context = context;
- assign_source_id_unlocked (context, source);
+ source->source_id = id;
source->ref_count++;
+
+ g_hash_table_insert (context->sources, GUINT_TO_POINTER (id), source);
+
source_add_to_context (source, context);
if (!SOURCE_BLOCKED (source))
* Adds a #GSource to a @context so that it will be executed within
* that context. Remove it by calling g_source_destroy().
*
- * Return value: the ID (greater than 0) for the source within the
+ * Returns: the ID (greater than 0) for the source within the
* #GMainContext.
**/
guint
* context. The reverse
* mapping from ID to source is done by g_main_context_find_source_by_id().
*
- * Return value: the ID (greater than 0) for the source
+ * Returns: the ID (greater than 0) for the source
**/
guint
g_source_get_id (GSource *source)
* g_main_current_source(). But calling this function on a source
* whose #GMainContext has been destroyed is an error.
*
- * Return value: (transfer none) (allow-none): the #GMainContext with which the
+ * Returns: (transfer none) (allow-none): the #GMainContext with which the
* source is associated, or %NULL if the context has not
* yet been added to a source.
**/
* the @revents field in the #GPollFD struct and return %TRUE if events need
* to be processed.
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* Using this API forces the linear scanning of event sources on each
* main loop iteration. Newly-written event sources should try to use
* g_source_add_unix_fd() instead of this API.
*
* Removes a file descriptor from the set of file descriptors polled for
* this source.
+ *
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
**/
void
g_source_remove_poll (GSource *source,
* @source will hold a reference on @child_source while @child_source
* is attached to it.
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* Since: 2.28
**/
void
*
* Detaches @child_source from @source and destroys it.
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* Since: 2.28
**/
void
* source will be dispatched if it is ready to be dispatched and no
* sources at a higher (numerically smaller) priority are ready to be
* dispatched.
+ *
+ * A child source always has the same priority as its parent. It is not
+ * permitted to change the priority of a source once it has been added
+ * as a child of another source.
**/
void
g_source_set_priority (GSource *source,
GMainContext *context;
g_return_if_fail (source != NULL);
+ g_return_if_fail (source->priv->parent_source == NULL);
context = source->context;
*
* Gets the priority of a source.
*
- * Return value: the priority of the source
+ * Returns: the priority of the source
**/
gint
g_source_get_priority (GSource *source)
* for both sources is reached during the same main context iteration
* then the order of dispatch is undefined.
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* Since: 2.36
**/
void
* Checks whether a source is allowed to be called recursively.
* see g_source_set_can_recurse().
*
- * Return value: whether recursion is allowed.
+ * Returns: whether recursion is allowed.
**/
gboolean
g_source_get_can_recurse (GSource *source)
* The name may be #NULL if it has never been set with
* g_source_set_name().
*
- * Return value: the name of the source
+ * Returns: the name of the source
* Since: 2.26
**/
const char *
*
* Increases the reference count on a source by one.
*
- * Return value: @source
+ * Returns: @source
**/
GSource *
g_source_ref (GSource *source)
if (!SOURCE_DESTROYED (source))
g_warning (G_STRLOC ": ref_count == 0, but source was still attached to a context!");
source_remove_from_context (source, context);
+
+ g_hash_table_remove (context->sources, GUINT_TO_POINTER (source->source_id));
}
if (source->source_funcs->finalize)
/**
* g_main_context_find_source_by_id:
* @context: (allow-none): a #GMainContext (if %NULL, the default context will be used)
- * @source_id: the source ID, as returned by g_source_get_id().
- *
+ * @source_id: the source ID, as returned by g_source_get_id().
+ *
* Finds a #GSource given a pair of context and ID.
- *
- * Return value: (transfer none): the #GSource if found, otherwise, %NULL
+ *
+ * Returns: (transfer none): the #GSource if found, otherwise, %NULL
**/
GSource *
g_main_context_find_source_by_id (GMainContext *context,
- guint source_id)
+ guint source_id)
{
- GSourceIter iter;
GSource *source;
-
+
g_return_val_if_fail (source_id > 0, NULL);
if (context == NULL)
context = g_main_context_default ();
-
- LOCK_CONTEXT (context);
-
- g_source_iter_init (&iter, context, FALSE);
- while (g_source_iter_next (&iter, &source))
- {
- if (!SOURCE_DESTROYED (source) &&
- source->source_id == source_id)
- break;
- }
- g_source_iter_clear (&iter);
+ LOCK_CONTEXT (context);
+ source = g_hash_table_lookup (context->sources, GUINT_TO_POINTER (source_id));
UNLOCK_CONTEXT (context);
+ if (source && SOURCE_DESTROYED (source))
+ source = NULL;
+
return source;
}
* multiple sources exist with the same source function and user data,
* the first one found will be returned.
*
- * Return value: (transfer none): the source, if one was found, otherwise %NULL
+ * Returns: (transfer none): the source, if one was found, otherwise %NULL
**/
GSource *
g_main_context_find_source_by_funcs_user_data (GMainContext *context,
* multiple sources exist with the same user data, the first
* one found will be returned.
*
- * Return value: (transfer none): the source, if one was found, otherwise %NULL
+ * Returns: (transfer none): the source, if one was found, otherwise %NULL
**/
GSource *
g_main_context_find_source_by_user_data (GMainContext *context,
*
* It is a programmer error to attempt to remove a non-existent source.
*
- * Return value: For historical reasons, this function always returns %TRUE
+ * Returns: For historical reasons, this function always returns %TRUE
**/
gboolean
g_source_remove (guint tag)
* data for the callback. If multiple sources exist with the same user
* data, only one will be destroyed.
*
- * Return value: %TRUE if a source was found and removed.
+ * Returns: %TRUE if a source was found and removed.
**/
gboolean
g_source_remove_by_user_data (gpointer user_data)
* source functions and user data. If multiple sources exist with the
* same source functions and user data, only one will be destroyed.
*
- * Return value: %TRUE if a source was found and removed.
+ * Returns: %TRUE if a source was found and removed.
**/
gboolean
g_source_remove_by_funcs_user_data (GSourceFuncs *funcs,
* It is not necessary to remove the fd before destroying the source; it
* will be cleaned up automatically.
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* As the name suggests, this function is not available on Windows.
*
* Returns: an opaque tag
* If you want to remove a fd, don't set its event mask to zero.
* Instead, call g_source_remove_unix_fd().
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* As the name suggests, this function is not available on Windows.
*
* Since: 2.36
* watched while keeping the same source around. In the normal case you
* will just want to destroy the source.
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* As the name suggests, this function is not available on Windows.
*
* Since: 2.36
* The return value of this function is only defined when the function
* is called from the check or dispatch functions for @source.
*
+ * This API is only intended to be used by implementations of #GSource.
+ * Do not call this API on a #GSource that you did not create.
+ *
* As the name suggests, this function is not available on Windows.
*
* Returns: the conditions reported on the fd
return (((gint64) tv.tv_sec) * 1000000) + tv.tv_usec;
}
-#ifdef G_OS_WIN32
+/**
+ * g_get_monotonic_time:
+ *
+ * Queries the system monotonic time.
+ *
+ * The monotonic clock will always increase and doesn't suffer
+ * discontinuities when the user (or NTP) changes the system time. It
+ * may or may not continue to tick during times where the machine is
+ * suspended.
+ *
+ * We try to use the clock that corresponds as closely as possible to
+ * the passage of time as measured by system calls such as poll() but it
+ * may not always be possible to do this.
+ *
+ * Returns: the monotonic time, in microseconds
+ *
+ * Since: 2.28
+ **/
+#if defined (G_OS_WIN32)
static ULONGLONG (*g_GetTickCount64) (void) = NULL;
static guint32 g_win32_tick_epoch = 0;
g_GetTickCount64 = (void *) GetProcAddress (kernel32, "GetTickCount64");
g_win32_tick_epoch = ((guint32)GetTickCount()) >> 31;
}
-#endif
-/**
- * g_get_monotonic_time:
- *
- * Queries the system monotonic time, if available.
- *
- * On POSIX systems with clock_gettime() and <literal>CLOCK_MONOTONIC</literal> this call
- * is a very shallow wrapper for that. Otherwise, we make a best effort
- * that probably involves returning the wall clock time (with at least
- * microsecond accuracy, subject to the limitations of the OS kernel).
- *
- * It's important to note that POSIX <literal>CLOCK_MONOTONIC</literal> does
- * not count time spent while the machine is suspended.
- *
- * On Windows, "limitations of the OS kernel" is a rather substantial
- * statement. Depending on the configuration of the system, the wall
- * clock time is updated as infrequently as 64 times a second (which
- * is approximately every 16ms). Also, on XP (but not on Vista or later)
- * the monotonic clock is locally monotonic, but may differ in exact
- * value between processes due to timer wrap handling.
- *
- * Returns: the monotonic time, in microseconds
- *
- * Since: 2.28
- **/
gint64
g_get_monotonic_time (void)
{
-#ifdef HAVE_CLOCK_GETTIME
- /* librt clock_gettime() is our first choice */
- struct timespec ts;
-
-#ifdef CLOCK_MONOTONIC
- clock_gettime (CLOCK_MONOTONIC, &ts);
-#else
- clock_gettime (CLOCK_REALTIME, &ts);
-#endif
-
- /* In theory monotonic time can have any epoch.
- *
- * glib presently assumes the following:
- *
- * 1) The epoch comes some time after the birth of Jesus of Nazareth, but
- * not more than 10000 years later.
- *
- * 2) The current time also falls sometime within this range.
- *
- * These two reasonable assumptions leave us with a maximum deviation from
- * the epoch of 10000 years, or 315569520000000000 seconds.
- *
- * If we restrict ourselves to this range then the number of microseconds
- * will always fit well inside the constraints of a int64 (by a factor of
- * about 29).
- *
- * If you actually hit the following assertion, probably you should file a
- * bug against your operating system for being excessively silly.
- **/
- g_assert (G_GINT64_CONSTANT (-315569520000000000) < ts.tv_sec &&
- ts.tv_sec < G_GINT64_CONSTANT (315569520000000000));
-
- return (((gint64) ts.tv_sec) * 1000000) + (ts.tv_nsec / 1000);
-
-#elif defined (G_OS_WIN32)
guint64 ticks;
guint32 ticks32;
* is to use it to interpolate the lower precision clocks. Firefox does something like
* this:
* https://bugzilla.mozilla.org/show_bug.cgi?id=363258
- *
+ *
* However this seems quite complicated, so we're not doing this right now.
*
* The approach we take instead is to use the TGT timer, extending it to 64bit
* This means that:
* - We have a globally consistent monotonic clock on Vista and later
* - We have a locally monotonic clock on XP
- * - Apps that need higher precision in timeouts and clock reads can call
+ * - Apps that need higher precision in timeouts and clock reads can call
* timeBeginPeriod() to increase it as much as they want
*/
ticks = g_GetTickCount64 ();
ticks32 = timeGetTime();
- /* GTC64 and TGT are sampled at different times, however they
- * have the same base and source (msecs since system boot).
+ /* GTC64 and TGT are sampled at different times, however they
+ * have the same base and source (msecs since system boot).
* They can differ by as much as -16 to +16 msecs.
- * We can't just inject the low bits into the 64bit counter
+ * We can't just inject the low bits into the 64bit counter
* as one of the counters can have wrapped in 32bit space and
* the other not. Instead we calculate the signed difference
* in 32bit space and apply that difference to the 64bit counter.
/* We could do some 2's complement hack, but we play it safe */
if (ticks32 - ticks_as_32bit <= G_MAXINT32)
- ticks += ticks32 - ticks_as_32bit;
+ ticks += ticks32 - ticks_as_32bit;
else
- ticks -= ticks_as_32bit - ticks32;
+ ticks -= ticks_as_32bit - ticks32;
}
else
{
* processes.
*/
if ((ticks32 >> 31) != (epoch & 1))
- {
- epoch++;
- g_atomic_int_set (&g_win32_tick_epoch, epoch);
- }
+ {
+ epoch++;
+ g_atomic_int_set (&g_win32_tick_epoch, epoch);
+ }
ticks = (guint64)ticks32 | ((guint64)epoch) << 31;
}
return ticks * 1000;
+}
+#elif defined(HAVE_MACH_MACH_TIME_H) /* Mac OS */
+gint64
+g_get_monotonic_time (void)
+{
+ static mach_timebase_info_data_t timebase_info;
-#else /* !HAVE_CLOCK_GETTIME && ! G_OS_WIN32*/
+ if (timebase_info.denom == 0)
+ {
+ /* This is a fraction that we must use to scale
+ * mach_absolute_time() by in order to reach nanoseconds.
+ *
+ * We've only ever observed this to be 1/1, but maybe it could be
+ * 1000/1 if mach time is microseconds already, or 1/1000 if
+ * picoseconds. Try to deal nicely with that.
+ */
+ mach_timebase_info (&timebase_info);
- GTimeVal tv;
+ /* We actually want microseconds... */
+ if (timebase_info.numer % 1000 == 0)
+ timebase_info.numer /= 1000;
+ else
+ timebase_info.denom *= 1000;
- g_get_current_time (&tv);
+ /* We want to make the numer 1 to avoid having to multiply... */
+ if (timebase_info.denom % timebase_info.numer == 0)
+ {
+ timebase_info.denom /= timebase_info.numer;
+ timebase_info.numer = 1;
+ }
+ else
+ {
+ /* We could just multiply by timebase_info.numer below, but why
+ * bother for a case that may never actually exist...
+ *
+ * Plus -- performing the multiplication would risk integer
+ * overflow. If we ever actually end up in this situation, we
+ * should more carefully evaluate the correct course of action.
+ */
+ mach_timebase_info (&timebase_info); /* Get a fresh copy for a better message */
+ g_error ("Got weird mach timebase info of %d/%d. Please file a bug against GLib.",
+ timebase_info.numer, timebase_info.denom);
+ }
+ }
- return (((gint64) tv.tv_sec) * 1000000) + tv.tv_usec;
-#endif
+ return mach_absolute_time () / timebase_info.denom;
}
+#else
+gint64
+g_get_monotonic_time (void)
+{
+ struct timespec ts;
+ gint result;
+
+ result = clock_gettime (CLOCK_MONOTONIC, &ts);
+
+ if G_UNLIKELY (result != 0)
+ g_error ("GLib requires working CLOCK_MONOTONIC");
+
+ return (((gint64) ts.tv_sec) * 1000000) + (ts.tv_nsec / 1000);
+}
+#endif
static void
g_main_dispatch_free (gpointer dispatch)
* simply return to the main loop and then get called again when
* there is more work to do.
*
- * Return value: The main loop recursion level in the current thread
+ * Returns: The main loop recursion level in the current thread
*/
int
g_main_depth (void)
*
* Returns the currently firing source for this thread.
*
- * Return value: (transfer none): The currently firing source or %NULL.
+ * Returns: (transfer none): The currently firing source or %NULL.
*
* Since: 2.12
*/
* SomeWidget *self = data;
*
* GDK_THREADS_ENTER ();
- * /* do stuff with self */
+ * // do stuff with self
* self->idle_id = 0;
* GDK_THREADS_LEAVE ();
*
* GDK_THREADS_ENTER ();
* if (!g_source_is_destroyed (g_main_current_source ()))
* {
- * /* do stuff with self */
+ * // do stuff with self
* }
* GDK_THREADS_LEAVE ();
*
* }
* ]|
*
- * Return value: %TRUE if the source has been destroyed
+ * Returns: %TRUE if the source has been destroyed
*
* Since: 2.12
*/
* can call g_main_context_prepare(), g_main_context_query(),
* g_main_context_check(), g_main_context_dispatch().
*
- * Return value: %TRUE if the operation succeeded, and
+ * Returns: %TRUE if the operation succeeded, and
* this thread is now the owner of @context.
**/
gboolean
* that owner releases ownership or until @cond is signaled, then
* try again (once) to become the owner.
*
- * Return value: %TRUE if the operation succeeded, and
+ * Returns: %TRUE if the operation succeeded, and
* this thread is now the owner of @context.
**/
gboolean
if (context == NULL)
context = g_main_context_default ();
+ if G_UNLIKELY (cond != &context->cond || mutex != &context->mutex)
+ {
+ static gboolean warned;
+
+ if (!warned)
+ {
+ g_critical ("WARNING!! g_main_context_wait() will be removed in a future release. "
+ "If you see this message, please file a bug immediately.");
+ warned = TRUE;
+ }
+ }
+
loop_internal_waiter = (mutex == &context->mutex);
if (!loop_internal_waiter)
* @context: a #GMainContext
* @priority: location to store priority of highest priority
* source already ready.
- *
+ *
* Prepares to poll sources within a main loop. The resulting information
* for polling is determined by calling g_main_context_query ().
- *
- * Return value: %TRUE if some source is ready to be dispatched
+ *
+ * You must have successfully acquired the context with
+ * g_main_context_acquire() before you may call this function.
+ *
+ * Returns: %TRUE if some source is ready to be dispatched
* prior to polling.
**/
gboolean
* @fds: (out caller-allocates) (array length=n_fds): location to
* store #GPollFD records that need to be polled.
* @n_fds: length of @fds.
- *
+ *
* Determines information necessary to poll this main loop.
- *
- * Return value: the number of records actually stored in @fds,
+ *
+ * You must have successfully acquired the context with
+ * g_main_context_acquire() before you may call this function.
+ *
+ * Returns: the number of records actually stored in @fds,
* or, if more than @n_fds records need to be stored, the number
* of records that need to be stored.
**/
* @fds: (array length=n_fds): array of #GPollFD's that was passed to
* the last call to g_main_context_query()
* @n_fds: return value of g_main_context_query()
- *
+ *
* Passes the results of polling back to the main loop.
- *
- * Return value: %TRUE if some sources are ready to be dispatched.
+ *
+ * You must have successfully acquired the context with
+ * g_main_context_acquire() before you may call this function.
+ *
+ * Returns: %TRUE if some sources are ready to be dispatched.
**/
gboolean
g_main_context_check (GMainContext *context,
/**
* g_main_context_dispatch:
* @context: a #GMainContext
- *
+ *
* Dispatches all pending sources.
+ *
+ * You must have successfully acquired the context with
+ * g_main_context_acquire() before you may call this function.
**/
void
g_main_context_dispatch (GMainContext *context)
*
* Checks if any sources have pending events for the given context.
*
- * Return value: %TRUE if events are pending.
+ * Returns: %TRUE if events are pending.
**/
gboolean
g_main_context_pending (GMainContext *context)
* g_main_context_iteration() to return %FALSE, since the wait may
* be interrupted for other reasons than an event source becoming ready.
*
- * Return value: %TRUE if events were dispatched.
+ * Returns: %TRUE if events were dispatched.
**/
gboolean
g_main_context_iteration (GMainContext *context, gboolean may_block)
*
* Creates a new #GMainLoop structure.
*
- * Return value: a new #GMainLoop.
+ * Returns: a new #GMainLoop.
**/
GMainLoop *
g_main_loop_new (GMainContext *context,
*
* Increases the reference count on a #GMainLoop object by one.
*
- * Return value: @loop
+ * Returns: @loop
**/
GMainLoop *
g_main_loop_ref (GMainLoop *loop)
*
* Checks to see if the main loop is currently being run via g_main_loop_run().
*
- * Return value: %TRUE if the mainloop is currently being run.
+ * Returns: %TRUE if the mainloop is currently being run.
**/
gboolean
g_main_loop_is_running (GMainLoop *loop)
*
* Returns the #GMainContext of @loop.
*
- * Return value: (transfer none): the #GMainContext of @loop
+ * Returns: (transfer none): the #GMainContext of @loop
**/
GMainContext *
g_main_loop_get_context (GMainLoop *loop)
*
* Gets the poll function set by g_main_context_set_poll_func().
*
- * Return value: the poll function
+ * Returns: the poll function
**/
GPollFunc
g_main_context_get_poll_func (GMainContext *context)
* The interval given is in terms of monotonic time, not wall clock
* time. See g_get_monotonic_time().
*
- * Return value: the newly-created timeout source
+ * Returns: the newly-created timeout source
**/
GSource *
g_timeout_source_new (guint interval)
* The interval given in terms of monotonic time, not wall clock time.
* See g_get_monotonic_time().
*
- * Return value: the newly-created timeout source
+ * Returns: the newly-created timeout source
*
* Since: 2.14
**/
* The interval given in terms of monotonic time, not wall clock time.
* See g_get_monotonic_time().
*
- * Return value: the ID (greater than 0) of the event source.
+ * Returns: the ID (greater than 0) of the event source.
* Rename to: g_timeout_add
**/
guint
* The interval given is in terms of monotonic time, not wall clock
* time. See g_get_monotonic_time().
*
- * Return value: the ID (greater than 0) of the event source.
+ * Returns: the ID (greater than 0) of the event source.
**/
guint
g_timeout_add (guint32 interval,
* The interval given is in terms of monotonic time, not wall clock
* time. See g_get_monotonic_time().
*
- * Return value: the ID (greater than 0) of the event source.
+ * Returns: the ID (greater than 0) of the event source.
*
* Rename to: g_timeout_add_seconds
* Since: 2.14
* The interval given is in terms of monotonic time, not wall clock
* time. See g_get_monotonic_time().
*
- * Return value: the ID (greater than 0) of the event source.
+ * Returns: the ID (greater than 0) of the event source.
*
* Since: 2.14
**/
pid_t pid;
do
{
+ g_assert (source->pid > 0);
+
pid = waitpid (source->pid, &source->child_status, WNOHANG);
if (pid > 0)
{
/**
* g_child_watch_source_new:
- * @pid: process to watch. On POSIX the pid of a child process. On
+ * @pid: process to watch. On POSIX the positive pid of a child process. On
* Windows a handle for a process (which doesn't have to be a child).
*
* Creates a new child_watch source.
* executed.
*
* Note that child watch sources can only be used in conjunction with
- * <literal>g_spawn...</literal> when the %G_SPAWN_DO_NOT_REAP_CHILD
- * flag is used.
+ * `g_spawn...` when the %G_SPAWN_DO_NOT_REAP_CHILD flag is used.
*
* Note that on platforms where #GPid must be explicitly closed
* (see g_spawn_close_pid()) @pid must not be closed while the
* g_spawn_close_pid() in the callback function for the source.
*
* Note further that using g_child_watch_source_new() is not
- * compatible with calling <literal>waitpid</literal> with a
- * nonpositive first argument in the application. Calling waitpid()
- * for individual pids will still work fine.
- *
- * Return value: the newly-created child watch source
+ * compatible with calling `waitpid` with a nonpositive first
+ * argument in the application. Calling waitpid() for individual
+ * pids will still work fine.
+ *
+ * Similarly, on POSIX platforms, the @pid passed to this function must
+ * be greater than 0 (i.e. this function must wait for a specific child,
+ * and cannot wait for one of many children by using a nonpositive argument).
+ *
+ * Returns: the newly-created child watch source
*
* Since: 2.4
**/
GSource *
g_child_watch_source_new (GPid pid)
{
- GSource *source = g_source_new (&g_child_watch_funcs, sizeof (GChildWatchSource));
- GChildWatchSource *child_watch_source = (GChildWatchSource *)source;
+ GSource *source;
+ GChildWatchSource *child_watch_source;
+
+#ifndef G_OS_WIN32
+ g_return_val_if_fail (pid > 0, NULL);
+#endif
+
+ source = g_source_new (&g_child_watch_funcs, sizeof (GChildWatchSource));
+ child_watch_source = (GChildWatchSource *)source;
child_watch_source->pid = pid;
* g_child_watch_add_full:
* @priority: the priority of the idle source. Typically this will be in the
* range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
- * @pid: process to watch. On POSIX the pid of a child process. On
+ * @pid: process to watch. On POSIX the positive pid of a child process. On
* Windows a handle for a process (which doesn't have to be a child).
* @function: function to call
* @data: data to pass to @function
* using g_source_attach(). You can do these steps manually if you
* need greater control.
*
- * Return value: the ID (greater than 0) of the event source.
+ * Returns: the ID (greater than 0) of the event source.
*
* Rename to: g_child_watch_add
* Since: 2.4
guint id;
g_return_val_if_fail (function != NULL, 0);
+#ifndef G_OS_WIN32
+ g_return_val_if_fail (pid > 0, 0);
+#endif
source = g_child_watch_source_new (pid);
/**
* g_child_watch_add:
- * @pid: process id to watch. On POSIX the pid of a child process. On
- * Windows a handle for a process (which doesn't have to be a child).
+ * @pid: process id to watch. On POSIX the positive pid of a child
+ * process. On Windows a handle for a process (which doesn't have to be
+ * a child).
* @function: function to call
* @data: data to pass to @function
*
* using g_source_attach(). You can do these steps manually if you
* need greater control.
*
- * Return value: the ID (greater than 0) of the event source.
+ * Returns: the ID (greater than 0) of the event source.
*
* Since: 2.4
**/
* %G_PRIORITY_DEFAULT_IDLE, as compared to other sources which
* have a default priority of %G_PRIORITY_DEFAULT.
*
- * Return value: the newly-created idle source
+ * Returns: the newly-created idle source
**/
GSource *
g_idle_source_new (void)
* and attaches it to the main loop context using g_source_attach().
* You can do these steps manually if you need greater control.
*
- * Return value: the ID (greater than 0) of the event source.
+ * Returns: the ID (greater than 0) of the event source.
* Rename to: g_idle_add
**/
guint
* and attaches it to the main loop context using g_source_attach().
* You can do these steps manually if you need greater control.
*
- * Return value: the ID (greater than 0) of the event source.
+ * Returns: the ID (greater than 0) of the event source.
**/
guint
g_idle_add (GSourceFunc function,
*
* Removes the idle function with the given data.
*
- * Return value: %TRUE if an idle source was found and removed.
+ * Returns: %TRUE if an idle source was found and removed.
**/
gboolean
g_idle_remove_by_data (gpointer data)
projects / platform / upstream / glib.git / blobdiff