/* GLIB - Library of useful routines for C programming

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

 *

 * gthread.c: MT safety related functions

 * Copyright 1998 Sebastian Wilhelmi; University of Karlsruhe

 *                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

 */

/* implement gthread.h's inline functions */

#define G_IMPLEMENT_INLINES 1

#define __G_THREAD_C__

#include "config.h"

#include "glib.h"

#include "gthreadprivate.h"

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifndef G_OS_WIN32

#include <sys/time.h>

#include <time.h>

#else

#include <windows.h>

#endif /* G_OS_WIN32 */

#include <string.h>

#include "galias.h"

#ifdef __SYMBIAN32__

#include "glib_wsd.h"

#endif /* __SYMBIAN32__ */

EXPORT_C GQuark 

g_thread_error_quark (void)

{

  return g_quark_from_static_string ("g_thread_error");

}

/* Keep this in sync with GRealThread in gmain.c! */

typedef struct _GRealThread GRealThread;

struct  _GRealThread

{

  GThread thread;

  gpointer private_data;

  GRealThread *next;

  gpointer retval;

  GSystemThread system_thread;

};

typedef struct _GStaticPrivateNode GStaticPrivateNode;

struct _GStaticPrivateNode

{

  gpointer       data;

  GDestroyNotify destroy;

};

static void    g_thread_cleanup (gpointer data);

static void    g_thread_fail (void);

#if EMULATOR

guint64 gettime (void);

#else

static guint64 gettime (void);

#endif

#if EMULATOR

PLS(g_thread_gettime,gthread,function_type)

#define g_thread_gettime (*FUNCTION_NAME(g_thread_gettime,gthread)())

#else

guint64        (*g_thread_gettime) (void) = gettime;

#endif//EMULATOR

#ifdef __SYMBIAN32__

EXPORT_C gettimetype *_g_thread_gettime()

	{

	return &g_thread_gettime;

	}

#endif//__SYMBIAN32__

/* Global variables */

#if EMULATOR

PLS(zero_thread,gthread,GSystemThread)

#define zero_thread (*FUNCTION_NAME(zero_thread,gthread)())

#else

static GSystemThread zero_thread; /* This is initialized to all zero */

#endif /* EMULATOR */

#if EMULATOR

PLS(g_thread_use_default_impl,gthread,gboolean)

PLS(g_threads_got_initialized,gthread,gboolean)

PLS(g_thread_functions_for_glib_use,gthread,GThreadFunctions)

#define g_thread_use_default_impl (*FUNCTION_NAME(g_thread_use_default_impl,gthread)())

#define g_threads_got_initialized (*FUNCTION_NAME(g_threads_got_initialized,gthread)())

#define g_thread_functions_for_glib_use (*FUNCTION_NAME(g_thread_functions_for_glib_use,gthread)())

const GThreadFunctions temp_g_thread_functions_for_glib_use = {

  (GMutex*(*)())g_thread_fail,                 /* mutex_new */

  NULL,                                        /* mutex_lock */

  NULL,                                        /* mutex_trylock */

  NULL,                                        /* mutex_unlock */

  NULL,                                        /* mutex_free */

  (GCond*(*)())g_thread_fail,                  /* cond_new */

  NULL,                                        /* cond_signal */

  NULL,                                        /* cond_broadcast */

  NULL,                                        /* cond_wait */

  NULL,                                        /* cond_timed_wait  */

  NULL,                                        /* cond_free */

  (GPrivate*(*)(GDestroyNotify))g_thread_fail, /* private_new */

  NULL,                                        /* private_get */

  NULL,                                        /* private_set */

  (void(*)(GThreadFunc, gpointer, gulong,

	   gboolean, gboolean, GThreadPriority,

	   gpointer, GError**))g_thread_fail,  /* thread_create */

  NULL,                                        /* thread_yield */

  NULL,                                        /* thread_join */

  NULL,                                        /* thread_exit */

  NULL,                                        /* thread_set_priority */

  NULL,                                        /* thread_self */

  NULL                                         /* thread_equal */

};

#else

gboolean g_thread_use_default_impl = TRUE;

gboolean g_threads_got_initialized = FALSE;

GThreadFunctions g_thread_functions_for_glib_use = {

  (GMutex*(*)())g_thread_fail,                 /* mutex_new */

  NULL,                                        /* mutex_lock */

  NULL,                                        /* mutex_trylock */

  NULL,                                        /* mutex_unlock */

  NULL,                                        /* mutex_free */

  (GCond*(*)())g_thread_fail,                  /* cond_new */

  NULL,                                        /* cond_signal */

  NULL,                                        /* cond_broadcast */

  NULL,                                        /* cond_wait */

  NULL,                                        /* cond_timed_wait  */

  NULL,                                        /* cond_free */

  (GPrivate*(*)(GDestroyNotify))g_thread_fail, /* private_new */

  NULL,                                        /* private_get */

  NULL,                                        /* private_set */

  (void(*)(GThreadFunc, gpointer, gulong,

	   gboolean, gboolean, GThreadPriority,

	   gpointer, GError**))g_thread_fail,  /* thread_create */

  NULL,                                        /* thread_yield */

  NULL,                                        /* thread_join */

  NULL,                                        /* thread_exit */

  NULL,                                        /* thread_set_priority */

  NULL,                                        /* thread_self */

  NULL                                         /* thread_equal */

};

#endif

#ifdef __SYMBIAN32__

EXPORT_C gboolean *_g_thread_use_default_impl(void)

{

	return &g_thread_use_default_impl;

}

EXPORT_C gboolean *_g_threads_got_initialized(void)

{

	return &g_threads_got_initialized;

}

EXPORT_C GThreadFunctions *_g_thread_functions_for_glib_use(void)

{

	return &g_thread_functions_for_glib_use;

}

EXPORT_C gboolean g_thread_supported (void)

{

	return g_threads_got_initialized;

}

#endif /* __SYMBIAN32__ */

/* Local data */

#if EMULATOR

PLS(g_once_mutex,gthread,GMutex *)

PLS(g_once_cond,gthread,GCond *)

PLS(g_thread_specific_private ,gthread,GPrivate *)

PLS(g_thread_all_threads,gthread,GRealThread *)

PLS(g_thread_free_indeces,gthread,GSList *)

PLS(g_once_init_list,gthread,GSList *)

PLS_MACRO(g_thread,gthread,GStaticMutex)

#define g_once_mutex (*FUNCTION_NAME(g_once_mutex,gthread)())

#define g_once_cond (*FUNCTION_NAME(g_once_cond,gthread)())

#define g_thread_specific_private  (*FUNCTION_NAME(g_thread_specific_private ,gthread)())

#define g_thread_all_threads (*FUNCTION_NAME(g_thread_all_threads,gthread)())

#define g_thread_free_indeces (*FUNCTION_NAME(g_thread_free_indeces,gthread)())

#define g_once_init_list (*FUNCTION_NAME(g_once_init_list,gthread)())

#define g__g_thread_lock (*FUNCTION_NAME_MACRO(g_thread,gthread)())

#else

static GMutex   *g_once_mutex = NULL;

static GCond    *g_once_cond = NULL;

static GPrivate *g_thread_specific_private = NULL;

static GRealThread *g_thread_all_threads = NULL;

static GSList   *g_thread_free_indeces = NULL;

static GSList*   g_once_init_list = NULL;

G_LOCK_DEFINE_STATIC (g_thread);

#endif /* EMULATOR */

#ifdef G_THREADS_ENABLED

/* This must be called only once, before any threads are created.

 * It will only be called from g_thread_init() in -lgthread.

 */

EXPORT_C void 

g_thread_init_glib (void)

{

  /* We let the main thread (the one that calls g_thread_init) inherit

   * the static_private data set before calling g_thread_init

   */

  GRealThread* main_thread = (GRealThread*) g_thread_self ();

  /* mutex and cond creation works without g_threads_got_initialized */

  g_once_mutex = g_mutex_new ();

  g_once_cond = g_cond_new ();

  /* we may only create mutex and cond in here */

  _g_mem_thread_init_noprivate_nomessage ();

  /* setup the basic threading system */

  g_threads_got_initialized = TRUE;

  g_thread_specific_private = g_private_new (g_thread_cleanup);

  g_private_set (g_thread_specific_private, main_thread);

  G_THREAD_UF (thread_self, (&main_thread->system_thread));

  /* complete memory system initialization, g_private_*() works now */

  _g_slice_thread_init_nomessage ();

  /* accomplish log system initialization to enable messaging */

  _g_messages_thread_init_nomessage ();

  /* we may run full-fledged initializers from here */

  _g_atomic_thread_init ();

  _g_convert_thread_init ();

  _g_rand_thread_init ();

  _g_main_thread_init ();

  _g_utils_thread_init ();

#ifdef G_OS_WIN32

  _g_win32_thread_init ();

#endif

}

#endif /* G_THREADS_ENABLED */

EXPORT_C gpointer

g_once_impl (GOnce       *once,

	     GThreadFunc  func,

	     gpointer     arg)

{

  g_mutex_lock (g_once_mutex);

  while (once->status == G_ONCE_STATUS_PROGRESS)

    g_cond_wait (g_once_cond, g_once_mutex);

  if (once->status != G_ONCE_STATUS_READY)

    {

      once->status = G_ONCE_STATUS_PROGRESS;

      g_mutex_unlock (g_once_mutex);

      once->retval = func (arg);

      g_mutex_lock (g_once_mutex);

      once->status = G_ONCE_STATUS_READY;

      g_cond_broadcast (g_once_cond);

    }

  g_mutex_unlock (g_once_mutex);

  return once->retval;

}

EXPORT_C gboolean

g_once_init_enter_impl (volatile gsize *value_location)

{

  gboolean need_init = FALSE;

  g_mutex_lock (g_once_mutex);

  if (g_atomic_pointer_get (value_location) == NULL)

    {

      if (!g_slist_find (g_once_init_list, (void*) value_location))

        {

          need_init = TRUE;

          g_once_init_list = g_slist_prepend (g_once_init_list, (void*) value_location);

        }

      else

        do

          g_cond_wait (g_once_cond, g_once_mutex);

        while (g_slist_find (g_once_init_list, (void*) value_location));

    }

  g_mutex_unlock (g_once_mutex);

  return need_init;

}

EXPORT_C void 

g_once_init_leave (volatile gsize *value_location,

                   gsize           initialization_value)

{

  g_return_if_fail (g_atomic_pointer_get (value_location) == NULL);

  g_return_if_fail (initialization_value != 0);

  g_return_if_fail (g_once_init_list != NULL);

  g_atomic_pointer_set ((void**)value_location, (void*) initialization_value);

  g_mutex_lock (g_once_mutex);

  g_once_init_list = g_slist_remove (g_once_init_list, (void*) value_location);

  g_cond_broadcast (g_once_cond);

  g_mutex_unlock (g_once_mutex);

}

EXPORT_C void

g_static_mutex_init (GStaticMutex *mutex)

{

  static const GStaticMutex init_mutex = G_STATIC_MUTEX_INIT;

  g_return_if_fail (mutex);

  *mutex = init_mutex;

}

EXPORT_C GMutex *

g_static_mutex_get_mutex_impl (GMutex** mutex)

{

  if (!g_thread_supported ())

    return NULL;

  g_assert (g_once_mutex);

  g_mutex_lock (g_once_mutex);

  if (!(*mutex))

    g_atomic_pointer_set (mutex, g_mutex_new());

  g_mutex_unlock (g_once_mutex);

  return *mutex;

}

EXPORT_C void

g_static_mutex_free (GStaticMutex* mutex)

{

  GMutex **runtime_mutex;

  g_return_if_fail (mutex);

  /* The runtime_mutex is the first (or only) member of GStaticMutex,

   * see both versions (of glibconfig.h) in configure.in. Note, that

   * this variable is NULL, if g_thread_init() hasn't been called or

   * if we're using the default thread implementation and it provides

   * static mutexes. */

  runtime_mutex = ((GMutex**)mutex);

  if (*runtime_mutex)

    g_mutex_free (*runtime_mutex);

  *runtime_mutex = NULL;

}

EXPORT_C void     

g_static_rec_mutex_init (GStaticRecMutex *mutex)

{

  static const GStaticRecMutex init_mutex = G_STATIC_REC_MUTEX_INIT;

  g_return_if_fail (mutex);

  *mutex = init_mutex;

}

EXPORT_C void

g_static_rec_mutex_lock (GStaticRecMutex* mutex)

{

  GSystemThread self;

  g_return_if_fail (mutex);

  if (!g_thread_supported ())

    return;

  G_THREAD_UF (thread_self, (&self));

  if (g_system_thread_equal (self, mutex->owner))

    {

      mutex->depth++;

      return;

    }

  g_static_mutex_lock (&mutex->mutex);

  g_system_thread_assign (mutex->owner, self);

  mutex->depth = 1;

}

EXPORT_C gboolean

g_static_rec_mutex_trylock (GStaticRecMutex* mutex)

{

  GSystemThread self;

  g_return_val_if_fail (mutex, FALSE);

  if (!g_thread_supported ())

    return TRUE;

  G_THREAD_UF (thread_self, (&self));

  if (g_system_thread_equal (self, mutex->owner))

    {

      mutex->depth++;

      return TRUE;

    }

  if (!g_static_mutex_trylock (&mutex->mutex))

    return FALSE;

  g_system_thread_assign (mutex->owner, self);

  mutex->depth = 1;

  return TRUE;

}

EXPORT_C void

g_static_rec_mutex_unlock (GStaticRecMutex* mutex)

{

  g_return_if_fail (mutex);

  if (!g_thread_supported ())

    return;

  if (mutex->depth > 1)

    {

      mutex->depth--;

      return;

    }

  g_system_thread_assign (mutex->owner, zero_thread);

  g_static_mutex_unlock (&mutex->mutex);

}

EXPORT_C void

g_static_rec_mutex_lock_full   (GStaticRecMutex *mutex,

				guint            depth)

{

  GSystemThread self;

  g_return_if_fail (mutex);

  if (!g_thread_supported ())

    return;

  if (depth == 0)

    return;

  G_THREAD_UF (thread_self, (&self));

  if (g_system_thread_equal (self, mutex->owner))

    {

      mutex->depth += depth;

      return;

    }

  g_static_mutex_lock (&mutex->mutex);

  g_system_thread_assign (mutex->owner, self);

  mutex->depth = depth;

}

EXPORT_C guint    

g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex)

{

  guint depth;

  g_return_val_if_fail (mutex, 0);

  if (!g_thread_supported ())

    return 1;

  depth = mutex->depth;

  g_system_thread_assign (mutex->owner, zero_thread);

  mutex->depth = 0;

  g_static_mutex_unlock (&mutex->mutex);

  return depth;

}

EXPORT_C void

g_static_rec_mutex_free (GStaticRecMutex *mutex)

{

  g_return_if_fail (mutex);

  g_static_mutex_free (&mutex->mutex);

}

EXPORT_C void     

g_static_private_init (GStaticPrivate *private_key)