/* GLIB - Library of useful routines for C programming

 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * gmain.c: Main loop abstraction, timeouts, and idle functions

 * Copyright 1998 Owen Taylor

 * Portions copyright (c) 2006-2009 Nokia Corporation.  All rights reserved.

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GLib Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GLib at ftp://ftp.gtk.org/pub/gtk/. 

 */

/* 

 * MT safe

 */

#include "config.h"

/* Uncomment the next line (and the corresponding line in gpoll.c) to

 * enable debugging printouts if the environment variable

 * G_MAIN_POLL_DEBUG is set to some value.

 */

/* #define G_MAIN_POLL_DEBUG */

#ifdef _WIN32

/* Always enable debugging printout on Windows, as it is more often

 * needed there...

 */

#define G_MAIN_POLL_DEBUG

#endif

#define _GNU_SOURCE  /* for pipe2 */

#include "glib.h"

#include "gthreadprivate.h"

#include <signal.h>

#include <sys/types.h>

#include <time.h>

#include <stdlib.h>

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif /* HAVE_SYS_TIME_H */

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif /* HAVE_UNISTD_H */

#include <errno.h>

#ifdef G_OS_WIN32

#define STRICT

#include <windows.h>

#endif /* G_OS_WIN32 */

#ifdef G_OS_BEOS

#include <sys/socket.h>

#include <sys/wait.h>

#endif /* G_OS_BEOS */

#if (defined (G_OS_UNIX) || defined(__SYMBIAN32__))

#include <fcntl.h>

#include <sys/wait.h>

#endif

#include "galias.h"

#ifdef __SYMBIAN32__

#include "glibbackend.h"

#include "glib_wsd.h"

#endif /* __SYMBIAN32__ */

#if EMULATOR

#define g_thread_functions_for_glib_use (*_g_thread_functions_for_glib_use())

#define g_thread_use_default_impl (*_g_thread_use_default_impl())

#endif /* EMULATOR */

/* Types */

typedef struct _GTimeoutSource GTimeoutSource;

typedef struct _GChildWatchSource GChildWatchSource;

typedef struct _GPollRec GPollRec;

typedef struct _GSourceCallback GSourceCallback;

typedef enum

{

  G_SOURCE_READY = 1 << G_HOOK_FLAG_USER_SHIFT,

  G_SOURCE_CAN_RECURSE = 1 << (G_HOOK_FLAG_USER_SHIFT + 1)

} GSourceFlags;

#ifdef G_THREADS_ENABLED

typedef struct _GMainWaiter GMainWaiter;

struct _GMainWaiter

{

  GCond *cond;

  GMutex *mutex;

};

#endif  

typedef struct _GMainDispatch GMainDispatch;

struct _GMainDispatch

{

  gint depth;

  GSList *dispatching_sources; /* stack of current sources */

};

#ifdef G_MAIN_POLL_DEBUG

gboolean _g_main_poll_debug = FALSE;

#endif

struct _GMainContext

{

#ifdef G_THREADS_ENABLED

  /* The following lock is used for both the list of sources

   * and the list of poll records

   */

  GStaticMutex mutex;

  GCond *cond;

  GThread *owner;

  guint owner_count;

  GSList *waiters;

#endif  

  gint ref_count;

  GPtrArray *pending_dispatches;

  gint timeout;			/* Timeout for current iteration */

  guint next_id;

  GSource *source_list;

  gint in_check_or_prepare;

  GPollRec *poll_records;

  guint n_poll_records;

  GPollFD *cached_poll_array;

  guint cached_poll_array_size;

#ifdef G_THREADS_ENABLED  

#ifndef G_OS_WIN32

/* this pipe is used to wake up the main loop when a source is added.

 */

  gint wake_up_pipe[2];

#else /* G_OS_WIN32 */

  HANDLE wake_up_semaphore;

#endif /* G_OS_WIN32 */

  GPollFD wake_up_rec;

  gboolean poll_waiting;

/* Flag indicating whether the set of fd's changed during a poll */

  gboolean poll_changed;

#endif /* G_THREADS_ENABLED */

  GPollFunc poll_func;

  GTimeVal current_time;

  gboolean time_is_current;

};

struct _GSourceCallback

{

  guint ref_count;

  GSourceFunc func;

  gpointer    data;

  GDestroyNotify notify;

};

struct _GMainLoop

{

  GMainContext *context;

  gboolean is_running;

  gint ref_count;

};

struct _GTimeoutSource

{

  GSource     source;

  GTimeVal    expiration;

  guint       interval;

  guint	      granularity;

};

struct _GChildWatchSource

{

  GSource     source;

  GPid        pid;

  gint        child_status;

#ifdef G_OS_WIN32

  GPollFD     poll;

#else /* G_OS_WIN32 */

  gint        count;

  gboolean    child_exited;

#endif /* G_OS_WIN32 */

};

struct _GPollRec

{

  GPollFD *fd;

  GPollRec *next;

  gint priority;

};

#ifdef G_THREADS_ENABLED

#define LOCK_CONTEXT(context) g_static_mutex_lock (&context->mutex)

#define UNLOCK_CONTEXT(context) g_static_mutex_unlock (&context->mutex)

#define G_THREAD_SELF g_thread_self ()

#else

#define LOCK_CONTEXT(context) (void)0

#define UNLOCK_CONTEXT(context) (void)0

#define G_THREAD_SELF NULL

#endif

#define SOURCE_DESTROYED(source) (((source)->flags & G_HOOK_FLAG_ACTIVE) == 0)

#define SOURCE_BLOCKED(source) (((source)->flags & G_HOOK_FLAG_IN_CALL) != 0 && \

		                ((source)->flags & G_SOURCE_CAN_RECURSE) == 0)

#define SOURCE_UNREF(source, context)                       \

   G_STMT_START {                                           \

    if ((source)->ref_count > 1)                            \

      (source)->ref_count--;                                \

    else                                                    \

      g_source_unref_internal ((source), (context), TRUE);  \

   } G_STMT_END

/* Forward declarations */

static void g_source_unref_internal             (GSource      *source,

						 GMainContext *context,

						 gboolean      have_lock);

static void g_source_destroy_internal           (GSource      *source,

						 GMainContext *context,

						 gboolean      have_lock);

static void g_main_context_poll                 (GMainContext *context,

						 gint          timeout,

						 gint          priority,

						 GPollFD      *fds,

						 gint          n_fds);

static void g_main_context_add_poll_unlocked    (GMainContext *context,

						 gint          priority,

						 GPollFD      *fd);

static void g_main_context_remove_poll_unlocked (GMainContext *context,

						 GPollFD      *fd);

static void g_main_context_wakeup_unlocked      (GMainContext *context);

static gboolean g_timeout_prepare  (GSource     *source,

				    gint        *timeout);

static gboolean g_timeout_check    (GSource     *source);

static gboolean g_timeout_dispatch (GSource     *source,

				    GSourceFunc  callback,

				    gpointer     user_data);

static gboolean g_child_watch_prepare  (GSource     *source,

				        gint        *timeout);

static gboolean g_child_watch_check    (GSource     *source);

static gboolean g_child_watch_dispatch (GSource     *source,

					GSourceFunc  callback,

					gpointer     user_data);

static gboolean g_idle_prepare     (GSource     *source,

				    gint        *timeout);

static gboolean g_idle_check       (GSource     *source);

static gboolean g_idle_dispatch    (GSource     *source,

				    GSourceFunc  callback,

				    gpointer     user_data);

#if EMULATOR

PLS_MACRO(main_loop,gmain,GStaticMutex)

PLS(default_main_context,gmain,GMainContext *)

PLS(main_contexts_without_pipe,gmain,GSList *)

#define g__main_loop_lock (*FUNCTION_NAME_MACRO(main_loop,gmain)())

#define default_main_context (*FUNCTION_NAME(default_main_context,gmain)())

#define main_contexts_without_pipe (*FUNCTION_NAME(main_contexts_without_pipe,gmain)())

#else

G_LOCK_DEFINE_STATIC (main_loop);

static GMainContext *default_main_context;

static GSList *main_contexts_without_pipe = NULL;

#endif /* EMULATOR */

#ifndef G_OS_WIN32

/* Child status monitoring code */

enum {

  CHILD_WATCH_UNINITIALIZED,

  CHILD_WATCH_INITIALIZED_SINGLE,

  CHILD_WATCH_INITIALIZED_THREADED

};

#if EMULATOR

PLS(child_watch_init_state,gmain,gint)

PLS(child_watch_count,gmain,gint)

PLS_ARRAY(child_watch_wake_up_pipe,gmain,gint)

#define child_watch_init_state (*FUNCTION_NAME(child_watch_init_state,gmain)())

#define child_watch_count (*FUNCTION_NAME(child_watch_count,gmain)())

#define child_watch_wake_up_pipe (FUNCTION_NAME(child_watch_wake_up_pipe,gmain)())

#else

static gint child_watch_init_state = CHILD_WATCH_UNINITIALIZED;

static gint child_watch_count = 1;

static gint child_watch_wake_up_pipe[2] = {0, 0};

#endif//EMULATOR

#endif /* !G_OS_WIN32 */

#if EMULATOR

PLS_MACRO(main_context_list,gmain,GStaticMutex)

PLS(main_context_list,gmain,GSList *)

PLS(timer_perturb,gmain,gint)

#define g__main_context_list_lock (*FUNCTION_NAME_MACRO(main_context_list,gmain)())

#define main_context_list (*FUNCTION_NAME(main_context_list,gmain)())

#define timer_perturb (*FUNCTION_NAME(timer_perturb,gmain)())

#else

G_LOCK_DEFINE_STATIC (main_context_list);

static GSList *main_context_list = NULL;

static gint timer_perturb = -1;

#endif /* EMULATOR */

#if EMULATOR

PLS(g_timeout_funcs,gmain,GSourceFuncs)

PLS(g_child_watch_funcs ,gmain,GSourceFuncs)

PLS(g_idle_funcs,gmain,GSourceFuncs)

#define g_timeout_funcs (*FUNCTION_NAME(g_timeout_funcs,gmain)())

#define g_child_watch_funcs  (*FUNCTION_NAME(g_child_watch_funcs ,gmain)())

#define g_idle_funcs (*FUNCTION_NAME(g_idle_funcs,gmain)())

const GSourceFuncs temp_g_timeout_funcs =

{

  g_timeout_prepare,

  g_timeout_check,

  g_timeout_dispatch,

  NULL

};

const GSourceFuncs temp_g_child_watch_funcs =

{

  g_child_watch_prepare,

  g_child_watch_check,

  g_child_watch_dispatch,

  NULL

};

const GSourceFuncs temp_g_idle_funcs =

{

  g_idle_prepare,

  g_idle_check,

  g_idle_dispatch,

  NULL

};

#else

GSourceFuncs g_timeout_funcs =

{

  g_timeout_prepare,

  g_timeout_check,

  g_timeout_dispatch,

  NULL

};

GSourceFuncs g_child_watch_funcs =

{

  g_child_watch_prepare,

  g_child_watch_check,

  g_child_watch_dispatch,

  NULL

};

GSourceFuncs g_idle_funcs =

{

  g_idle_prepare,

  g_idle_check,

  g_idle_dispatch,

  NULL

};

#endif /* EMULATOR */

#ifdef __SYMBIAN32__

EXPORT_C GSourceFuncs * _g_timeout_funcs(void)

{

	return &g_timeout_funcs;

}

EXPORT_C GSourceFuncs * _g_idle_funcs(void)

{

	return &g_idle_funcs;

}

EXPORT_C GSourceFuncs * _g_child_watch_funcs(void)

{

	return &g_child_watch_funcs;

}

#endif /* __SYMBIAN32__ */

/**

 * g_main_context_ref:

 * @context: a #GMainContext

 * 

 * Increases the reference count on a #GMainContext object by one.

 *

 * Returns: the @context that was passed in (since 2.6)

 **/

EXPORT_C GMainContext *

g_main_context_ref (GMainContext *context)

{

  g_return_val_if_fail (context != NULL, NULL);

  g_return_val_if_fail (g_atomic_int_get (&context->ref_count) > 0, NULL); 

  g_atomic_int_inc (&context->ref_count);

  return context;

}

static inline void

poll_rec_list_free (GMainContext *context,

		    GPollRec     *list)

{

  g_slice_free_chain (GPollRec, list, next);

}

/**

 * g_main_context_unref:

 * @context: a #GMainContext

 * 

 * Decreases the reference count on a #GMainContext object by one. If

 * the result is zero, free the context and free all associated memory.

 **/

EXPORT_C void

g_main_context_unref (GMainContext *context)

{

  GSource *source;

  g_return_if_fail (context != NULL);

  g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0); 

  if (!g_atomic_int_dec_and_test (&context->ref_count))

    return;

  #if EMULATOR

  #undef main_context_list

  #endif /* EMULATOR */

  G_LOCK (main_context_list);

  #if EMULATOR

  #define main_context_list (*FUNCTION_NAME(main_context_list,gmain)())

  #endif /* EMULATOR */

  main_context_list = g_slist_remove (main_context_list, context);

  #if EMULATOR

  #undef main_context_list

  #endif /* EMULATOR */

  G_UNLOCK (main_context_list);

  #if EMULATOR

  #define main_context_list (*FUNCTION_NAME(main_context_list,gmain)())

  #endif /* EMULATOR */

  source = context->source_list;

  while (source)

    {

      GSource *next = source->next;

      g_source_destroy_internal (source, context, FALSE);

      source = next;

    }

#ifdef G_THREADS_ENABLED  

  g_static_mutex_free (&context->mutex);

#endif

  g_ptr_array_free (context->pending_dispatches, TRUE);

  g_free (context->cached_poll_array);

  poll_rec_list_free (context, context->poll_records);

#ifdef G_THREADS_ENABLED

  if (g_thread_supported())

    {

#ifndef G_OS_WIN32

      close (context->wake_up_pipe[0]);

      close (context->wake_up_pipe[1]);

#else

      CloseHandle (context->wake_up_semaphore);

#endif

    } 

  else

    main_contexts_without_pipe = g_slist_remove (main_contexts_without_pipe, 

						 context);

  if (context->cond != NULL)

    g_cond_free (context->cond);

#endif

  g_free (context);

}

#ifdef G_THREADS_ENABLED

static void 

g_main_context_init_pipe (GMainContext *context)

{

# ifndef G_OS_WIN32

  if (context->wake_up_pipe[0] != -1)

    return;

#ifdef HAVE_PIPE2

  /* if this fails, we fall through and try pipe */

  pipe2 (context->wake_up_pipe, O_CLOEXEC);

#endif

  if (context->wake_up_pipe[0] == -1)

    {

      if (pipe (context->wake_up_pipe) < 0)

        g_error ("Cannot create pipe main loop wake-up: %s\n",