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

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <string.h>

#include "glib.h"

#include "gthreadinit.h"

#include "galias.h"

#ifdef __SYMBIAN32__

#include <glib_wsd.h>

#include "glibbackend.h"

#endif /* __SYMBIAN32__ */

#if GLIB_SIZEOF_SYSTEM_THREAD == SIZEOF_VOID_P

# define g_system_thread_equal_simple(thread1, thread2)			\

   ((thread1).dummy_pointer == (thread2).dummy_pointer)

# define g_system_thread_assign(dest, src)				\

   ((dest).dummy_pointer = (src).dummy_pointer)

#else /* GLIB_SIZEOF_SYSTEM_THREAD != SIZEOF_VOID_P */

# define g_system_thread_equal_simple(thread1, thread2)			\

   (memcmp (&(thread1), &(thread2), GLIB_SIZEOF_SYSTEM_THREAD) == 0)

# define g_system_thread_assign(dest, src)				\

   (memcpy (&(dest), &(src), GLIB_SIZEOF_SYSTEM_THREAD))

#endif /* GLIB_SIZEOF_SYSTEM_THREAD == SIZEOF_VOID_P */

#define g_system_thread_equal(thread1, thread2)				\

  (g_thread_functions_for_glib_use.thread_equal ? 			\

   g_thread_functions_for_glib_use.thread_equal (&(thread1), &(thread2)) :\

   g_system_thread_equal_simple((thread1), (thread2)))

#if EMULATOR

PLS(quark,g_thread_error_quark ,GQuark)

#define quark (*FUNCTION_NAME(quark,g_thread_error_quark )())

#endif /* EMULATOR */

EXPORT_C GQuark 

g_thread_error_quark (void)

{

  #if !(EMULATOR)

  static GQuark quark;

  #endif /* EMULATOR */

  if (!quark)

    quark = g_quark_from_static_string ("g_thread_error");

  return quark;

}

#if !(EMULATOR)

#undef quark

#endif /* EMULATOR */

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

#if !(EMULATOR)

typedef struct _GRealThread GRealThread;

struct  _GRealThread

{

  GThread thread;

  gpointer private_data;

  GRealThread *next;

  gpointer retval;

  GSystemThread system_thread;

};

#endif /* !(EMULATOR) */

typedef struct _GStaticPrivateNode GStaticPrivateNode;

struct _GStaticPrivateNode

{

  gpointer       data;

  GDestroyNotify destroy;

};

static void g_thread_cleanup (gpointer data);

static void g_thread_fail (void);

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

}; 

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

}; 

#endif

#ifdef __SYMBIAN32__

GArray* _g_array_newP               (gboolean          zero_terminated,

				   gboolean          clear_,

				   guint             element_size);			  

#endif // __SYMBIAN32__

#ifdef __SYMBIAN32__

EXPORT_C gboolean *_g_thread_use_default_impl()

{

	return &g_thread_use_default_impl;

}

EXPORT_C gboolean *_g_threads_got_initialized()

{

	return &g_threads_got_initialized;

}

EXPORT_C GThreadFunctions *_g_thread_functions_for_glib_use()

{

	return &g_thread_functions_for_glib_use;

}

EXPORT_C gboolean g_thread_supported ()

{

	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_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__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;

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_convert_thread_init ();

  _g_rand_thread_init ();

  _g_main_thread_init ();

  _g_atomic_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 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)) 

    {

      GMutex *new_mutex = g_mutex_new (); 

      /* The following is a memory barrier to avoid the write 

       * to *new_mutex being reordered to after writing *mutex */

      g_mutex_lock (new_mutex);

      g_mutex_unlock (new_mutex);

      *mutex = new_mutex;

    }

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

  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)

{

  private_key->index = 0;

}

EXPORT_C gpointer

g_static_private_get (GStaticPrivate *private_key)

{

  GRealThread *self = (GRealThread*) g_thread_self ();

  GArray *array;

  array = self->private_data;

  if (!array)

    return NULL;

  if (!private_key->index)

    return NULL;

  else if (private_key->index <= array->len)

    return g_array_index (array, GStaticPrivateNode, 

			  private_key->index - 1).data;

  else

    return NULL;

}