/* 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 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 to get poll() debugging info */

/* #define G_MAIN_POLL_DEBUG */

#include "glib.h"

#include "gthreadinit.h"

#ifndef __SYMBIAN32__

#include <signal.h>

#endif /* __SYMBIAN32__ */

#include <sys/types.h>

#include <time.h>

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif /* HAVE_SYS_TIME_H */

#ifdef GLIB_HAVE_SYS_POLL_H

#  include <sys/poll.h>

#  undef events	 /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */

#  undef revents /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */

/* The poll() emulation on OS/X doesn't handle fds=NULL, nfds=0,

 * so we prefer our own poll emulation.

 */

#ifdef _POLL_EMUL_H_

#undef HAVE_POLL

#endif

#endif /* GLIB_HAVE_SYS_POLL_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 */

#ifdef G_OS_UNIX

#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  

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;

};

struct _GChildWatchSource

{

  GSource     source;

  GPid        pid;

  gint        child_status;

#ifdef G_OS_WIN32

  GPollFD     poll;

#elif defined(__SYMBIAN32__)

#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 */

#if !defined(G_OS_WIN32) && !defined(__SYMBIAN32__)

/* Child status monitoring code */

enum {

  CHILD_WATCH_UNINITIALIZED,

  CHILD_WATCH_INITIALIZED_SINGLE,

  CHILD_WATCH_INITIALIZED_THREADED

};

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 /* !G_OS_WIN32  && !__SYMBIAN32__ */

#if EMULATOR

PLS_MACRO(main_context_list,gmain,GStaticMutex)

PLS(main_context_list,gmain,GSList *)

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

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

#else

G_LOCK_DEFINE_STATIC (main_context_list);

static GSList *main_context_list = NULL;

#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()

{

	return &g_timeout_funcs;

}

EXPORT_C GSourceFuncs * _g_idle_funcs()

{

	return &g_idle_funcs;

}

EXPORT_C GSourceFuncs * _g_child_watch_funcs()

{

	return &g_child_watch_funcs;

}

#endif /* __SYMBIAN32__ */

#ifdef HAVE_POLL

/* SunOS has poll, but doesn't provide a prototype. */

#  if defined (sun) && !defined (__SVR4)

extern gint poll (GPollFD *ufds, guint nfsd, gint timeout);

#  endif  /* !sun */

#else	/* !HAVE_POLL */

#ifdef G_OS_WIN32

static gint

g_poll (GPollFD *fds,

	guint    nfds,

	gint     timeout)

{

  HANDLE handles[MAXIMUM_WAIT_OBJECTS];

  gboolean poll_msgs = FALSE;

  GPollFD *f;

  DWORD ready;

  MSG msg;

  UINT timer;

  gint nhandles = 0;

  for (f = fds; f < &fds[nfds]; ++f)

    if (f->fd >= 0)

      {

	if (f->fd == G_WIN32_MSG_HANDLE)

	  poll_msgs = TRUE;

	else if (nhandles == MAXIMUM_WAIT_OBJECTS)

	  {

	    g_warning (G_STRLOC ": Too many handles to wait for!\n");

	    break;

	  }

	else

	  {

#ifdef G_MAIN_POLL_DEBUG

	    g_print ("g_poll: waiting for %#x\n", f->fd);

#endif

	    handles[nhandles++] = (HANDLE) f->fd;

	  }

      }

  if (timeout == -1)

    timeout = INFINITE;

  if (poll_msgs)

    {

      /* Waiting for messages, and maybe events

       * -> First PeekMessage

       */

#ifdef G_MAIN_POLL_DEBUG

      g_print ("PeekMessage\n");

#endif

      if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))

	ready = WAIT_OBJECT_0 + nhandles;

      else

	{

	  if (nhandles == 0)

	    {

	      /* Waiting just for messages */

	      if (timeout == INFINITE)

		{

		  /* Infinite timeout

		   * -> WaitMessage

		   */

#ifdef G_MAIN_POLL_DEBUG

		  g_print ("WaitMessage\n");

#endif

		  if (!WaitMessage ())

		    {

		      gchar *emsg = g_win32_error_message (GetLastError ());

		      g_warning (G_STRLOC ": WaitMessage() failed: %s", emsg);

		      g_free (emsg);

		    }

		  ready = WAIT_OBJECT_0 + nhandles;

		}

	      else if (timeout == 0)

		{

		  /* Waiting just for messages, zero timeout.

		   * If we got here, there was no message

		   */

		  ready = WAIT_TIMEOUT;

		}

	      else

		{

		  /* Waiting just for messages, some timeout

		   * -> Set a timer, wait for message,

		   * kill timer, use PeekMessage

		   */

		  timer = SetTimer (NULL, 0, timeout, NULL);

		  if (timer == 0)

		    {

		      gchar *emsg = g_win32_error_message (GetLastError ());

		      g_warning (G_STRLOC ": SetTimer() failed: %s", emsg);

		      g_free (emsg);

		      ready = WAIT_TIMEOUT;

		    }

		  else

		    {

#ifdef G_MAIN_POLL_DEBUG

		      g_print ("WaitMessage\n");

#endif

		      WaitMessage ();

		      KillTimer (NULL, timer);

#ifdef G_MAIN_POLL_DEBUG

		      g_print ("PeekMessage\n");

#endif

		      if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE)

			  && msg.message != WM_TIMER)

			ready = WAIT_OBJECT_0;

		      else

			ready = WAIT_TIMEOUT;

		    }

		}

	    }

	  else

	    {

	      /* Wait for either message or event

	       * -> Use MsgWaitForMultipleObjects

	       */

#ifdef G_MAIN_POLL_DEBUG

	      g_print ("MsgWaitForMultipleObjects(%d, %d)\n", nhandles, timeout);

#endif

	      ready = MsgWaitForMultipleObjects (nhandles, handles, FALSE,

						 timeout, QS_ALLINPUT);

	      if (ready == WAIT_FAILED)

		{

		  gchar *emsg = g_win32_error_message (GetLastError ());

		  g_warning (G_STRLOC ": MsgWaitForMultipleObjects() failed: %s", emsg);

		  g_free (emsg);