epoc32/include/stdapis/glib-2.0/glib/gthread.h
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:33:34 +0100
branchSymbian3
changeset 4 837f303aceeb
parent 0 061f57f2323e
permissions -rw-r--r--
Current Symbian^3 public API header files (from PDK 3.0.h)
This is the epoc32/include tree with the "platform" subtrees removed, and
all but a selected few mbg and rsg files removed.
williamr@2
     1
/* GLIB - Library of useful routines for C programming
williamr@2
     2
 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
williamr@2
     3
 * Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.
williamr@2
     4
 *
williamr@2
     5
 * This library is free software; you can redistribute it and/or
williamr@2
     6
 * modify it under the terms of the GNU Lesser General Public
williamr@2
     7
 * License as published by the Free Software Foundation; either
williamr@2
     8
 * version 2 of the License, or (at your option) any later version.
williamr@2
     9
 *
williamr@2
    10
 * This library is distributed in the hope that it will be useful,
williamr@2
    11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
williamr@2
    12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
williamr@2
    13
 * Lesser General Public License for more details.
williamr@2
    14
 *
williamr@2
    15
 * You should have received a copy of the GNU Lesser General Public
williamr@2
    16
 * License along with this library; if not, write to the
williamr@2
    17
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
williamr@2
    18
 * Boston, MA 02111-1307, USA.
williamr@2
    19
 */
williamr@2
    20
williamr@2
    21
/*
williamr@2
    22
 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
williamr@2
    23
 * file for a list of people on the GLib Team.  See the ChangeLog
williamr@2
    24
 * files for a list of changes.  These files are distributed with
williamr@2
    25
 * GLib at ftp://ftp.gtk.org/pub/gtk/. 
williamr@2
    26
 */
williamr@2
    27
williamr@2
    28
#ifndef __G_THREAD_H__
williamr@2
    29
#define __G_THREAD_H__
williamr@2
    30
williamr@2
    31
#include <_ansi.h>
williamr@2
    32
#include <glib/gerror.h>
williamr@2
    33
#include <glib/gtypes.h>
williamr@2
    34
#include <glib/gatomic.h>  /* for g_atomic_pointer_get */
williamr@2
    35
williamr@2
    36
G_BEGIN_DECLS
williamr@2
    37
williamr@2
    38
/* GLib Thread support
williamr@2
    39
 */
williamr@2
    40
#ifdef __SYMBIAN32__
williamr@2
    41
IMPORT_C  GQuark g_thread_error_quark (void);
williamr@2
    42
#else
williamr@2
    43
extern GQuark g_thread_error_quark (void);
williamr@2
    44
#endif /* __SYMBIAN32__ */
williamr@2
    45
#define G_THREAD_ERROR g_thread_error_quark ()
williamr@2
    46
williamr@2
    47
typedef enum
williamr@2
    48
{
williamr@2
    49
  G_THREAD_ERROR_AGAIN /* Resource temporarily unavailable */
williamr@2
    50
} GThreadError;
williamr@2
    51
williamr@2
    52
typedef gpointer (*GThreadFunc) (gpointer data);
williamr@2
    53
williamr@2
    54
typedef enum
williamr@2
    55
{
williamr@2
    56
  G_THREAD_PRIORITY_LOW,
williamr@2
    57
  G_THREAD_PRIORITY_NORMAL,
williamr@2
    58
  G_THREAD_PRIORITY_HIGH,
williamr@2
    59
  G_THREAD_PRIORITY_URGENT
williamr@2
    60
} GThreadPriority;
williamr@2
    61
williamr@2
    62
typedef struct _GThread         GThread;
williamr@2
    63
struct  _GThread
williamr@2
    64
{
williamr@2
    65
  /*< private >*/
williamr@2
    66
  GThreadFunc func;
williamr@2
    67
  gpointer data;
williamr@2
    68
  gboolean joinable;
williamr@2
    69
  GThreadPriority priority;
williamr@2
    70
};
williamr@2
    71
williamr@2
    72
typedef struct _GMutex          GMutex;
williamr@2
    73
typedef struct _GCond           GCond;
williamr@2
    74
typedef struct _GPrivate        GPrivate;
williamr@2
    75
typedef struct _GStaticPrivate  GStaticPrivate;
williamr@2
    76
williamr@2
    77
typedef struct _GThreadFunctions GThreadFunctions;
williamr@2
    78
struct _GThreadFunctions
williamr@2
    79
{
williamr@2
    80
  GMutex*  (*mutex_new)           (void);
williamr@2
    81
  void     (*mutex_lock)          (GMutex               *mutex);
williamr@2
    82
  gboolean (*mutex_trylock)       (GMutex               *mutex);
williamr@2
    83
  void     (*mutex_unlock)        (GMutex               *mutex);
williamr@2
    84
  void     (*mutex_free)          (GMutex               *mutex);
williamr@2
    85
  GCond*   (*cond_new)            (void);
williamr@2
    86
  void     (*cond_signal)         (GCond                *cond);
williamr@2
    87
  void     (*cond_broadcast)      (GCond                *cond);
williamr@2
    88
  void     (*cond_wait)           (GCond                *cond,
williamr@2
    89
                                   GMutex               *mutex);
williamr@2
    90
  gboolean (*cond_timed_wait)     (GCond                *cond,
williamr@2
    91
                                   GMutex               *mutex,
williamr@2
    92
                                   GTimeVal             *end_time);
williamr@2
    93
  void      (*cond_free)          (GCond                *cond);
williamr@2
    94
  GPrivate* (*private_new)        (GDestroyNotify        destructor);
williamr@2
    95
  gpointer  (*private_get)        (GPrivate             *private_key);
williamr@2
    96
  void      (*private_set)        (GPrivate             *private_key,
williamr@2
    97
                                   gpointer              data);
williamr@2
    98
  void      (*thread_create)      (GThreadFunc           func,
williamr@2
    99
                                   gpointer              data,
williamr@2
   100
                                   gulong                stack_size,
williamr@2
   101
                                   gboolean              joinable,
williamr@2
   102
                                   gboolean              bound,
williamr@2
   103
                                   GThreadPriority       priority,
williamr@2
   104
                                   gpointer              thread,
williamr@2
   105
                                   GError              **error);
williamr@2
   106
  void      (*thread_yield)       (void);
williamr@2
   107
  void      (*thread_join)        (gpointer              thread);
williamr@2
   108
  void      (*thread_exit)        (void);
williamr@2
   109
  void      (*thread_set_priority)(gpointer              thread,
williamr@2
   110
                                   GThreadPriority       priority);
williamr@2
   111
  void      (*thread_self)        (gpointer              thread);
williamr@2
   112
  gboolean  (*thread_equal)       (gpointer              thread1,
williamr@2
   113
				   gpointer              thread2);
williamr@2
   114
};
williamr@2
   115
williamr@2
   116
#ifdef __SYMBIAN32__
williamr@2
   117
IMPORT_C GThreadFunctions *_g_thread_functions_for_glib_use();
williamr@2
   118
#endif /* __SYMBIAN32__ */
williamr@2
   119
GLIB_VAR GThreadFunctions       g_thread_functions_for_glib_use;
williamr@2
   120
williamr@2
   121
#ifdef __SYMBIAN32__
williamr@2
   122
IMPORT_C gboolean *_g_thread_use_default_impl();
williamr@2
   123
#endif /* __SYMBIAN32__ */
williamr@2
   124
GLIB_VAR gboolean               g_thread_use_default_impl;
williamr@2
   125
williamr@2
   126
#ifdef __SYMBIAN32__
williamr@2
   127
IMPORT_C gboolean *_g_threads_got_initialized();
williamr@2
   128
#endif /* __SYMBIAN32__ */
williamr@2
   129
GLIB_VAR gboolean               g_threads_got_initialized;
williamr@2
   130
williamr@2
   131
/* initializes the mutex/cond/private implementation for glib, might
williamr@2
   132
 * only be called once, and must not be called directly or indirectly
williamr@2
   133
 * from another glib-function, e.g. as a callback.
williamr@2
   134
 */
williamr@2
   135
IMPORT_C void    g_thread_init   (GThreadFunctions       *vtable);
williamr@2
   136
williamr@2
   137
#ifdef __SYMBIAN32__
williamr@2
   138
IMPORT_C gboolean g_thread_supported();
williamr@2
   139
#else  
williamr@2
   140
#define g_thread_supported()    (g_threads_got_initialized)
williamr@2
   141
#endif
williamr@2
   142
williamr@2
   143
/* Errorcheck mutexes. If you define G_ERRORCHECK_MUTEXES, then all
williamr@2
   144
 * mutexes will check for re-locking and re-unlocking */
williamr@2
   145
williamr@2
   146
/* Initialize thread system with errorcheck mutexes. vtable must be
williamr@2
   147
 * NULL. Do not call directly. Use #define G_ERRORCHECK_MUTEXES
williamr@2
   148
 * instead.
williamr@2
   149
 */
williamr@2
   150
IMPORT_C void    g_thread_init_with_errorcheck_mutexes (GThreadFunctions* vtable);
williamr@2
   151
williamr@2
   152
/* A random number to recognize debug calls to g_mutex_... */
williamr@2
   153
#define G_MUTEX_DEBUG_MAGIC 0xf8e18ad7
williamr@2
   154
williamr@2
   155
#ifdef G_ERRORCHECK_MUTEXES
williamr@2
   156
#define g_thread_init(vtable) g_thread_init_with_errorcheck_mutexes (vtable)
williamr@2
   157
#endif
williamr@2
   158
williamr@2
   159
/* internal function for fallback static mutex implementation */
williamr@2
   160
IMPORT_C GMutex* g_static_mutex_get_mutex_impl   (GMutex **mutex);
williamr@2
   161
williamr@2
   162
#define g_static_mutex_get_mutex_impl_shortcut(mutex) \
williamr@2
   163
  (g_atomic_pointer_get ((gpointer*)(void*)mutex) ? *(mutex) : \
williamr@2
   164
   g_static_mutex_get_mutex_impl (mutex))
williamr@2
   165
williamr@2
   166
/* shorthands for conditional and unconditional function calls */
williamr@2
   167
williamr@2
   168
#define G_THREAD_UF(op, arglist)					\
williamr@2
   169
    (*g_thread_functions_for_glib_use . op) arglist
williamr@2
   170
#define G_THREAD_CF(op, fail, arg)					\
williamr@2
   171
    (g_thread_supported () ? G_THREAD_UF (op, arg) : (fail))
williamr@2
   172
#define G_THREAD_ECF(op, fail, mutex, type)				\
williamr@2
   173
    (g_thread_supported () ? ((type(*)(GMutex*, gulong, gchar*))	\
williamr@2
   174
      (*g_thread_functions_for_glib_use . op))				\
williamr@2
   175
     (mutex, G_MUTEX_DEBUG_MAGIC, G_STRLOC) : (fail))
williamr@2
   176
williamr@2
   177
#ifndef G_ERRORCHECK_MUTEXES
williamr@2
   178
# define g_mutex_lock(mutex)						\
williamr@2
   179
    G_THREAD_CF (mutex_lock,     (void)0, (mutex))
williamr@2
   180
# define g_mutex_trylock(mutex)						\
williamr@2
   181
    G_THREAD_CF (mutex_trylock,  TRUE,    (mutex))
williamr@2
   182
# define g_mutex_unlock(mutex)						\
williamr@2
   183
    G_THREAD_CF (mutex_unlock,   (void)0, (mutex))
williamr@2
   184
# define g_mutex_free(mutex)						\
williamr@2
   185
    G_THREAD_CF (mutex_free,     (void)0, (mutex))
williamr@2
   186
# define g_cond_wait(cond, mutex)					\
williamr@2
   187
    G_THREAD_CF (cond_wait,      (void)0, (cond, mutex))
williamr@2
   188
# define g_cond_timed_wait(cond, mutex, abs_time)			\
williamr@2
   189
    G_THREAD_CF (cond_timed_wait, TRUE,   (cond, mutex, abs_time))
williamr@2
   190
#else /* G_ERRORCHECK_MUTEXES */
williamr@2
   191
# define g_mutex_lock(mutex)						\
williamr@2
   192
    G_THREAD_ECF (mutex_lock,    (void)0, (mutex), void)
williamr@2
   193
# define g_mutex_trylock(mutex)						\
williamr@2
   194
    G_THREAD_ECF (mutex_trylock, TRUE,    (mutex), gboolean)
williamr@2
   195
# define g_mutex_unlock(mutex)						\
williamr@2
   196
    G_THREAD_ECF (mutex_unlock,  (void)0, (mutex), void)
williamr@2
   197
# define g_mutex_free(mutex)						\
williamr@2
   198
    G_THREAD_ECF (mutex_free,    (void)0, (mutex), void)
williamr@2
   199
# define g_cond_wait(cond, mutex)					\
williamr@2
   200
    (g_thread_supported () ? ((void(*)(GCond*, GMutex*, gulong, gchar*))\
williamr@2
   201
      g_thread_functions_for_glib_use.cond_wait)			\
williamr@2
   202
        (cond, mutex, G_MUTEX_DEBUG_MAGIC, G_STRLOC) : (void) 0)
williamr@2
   203
# define g_cond_timed_wait(cond, mutex, abs_time)			\
williamr@2
   204
    (g_thread_supported () ?						\
williamr@2
   205
      ((gboolean(*)(GCond*, GMutex*, GTimeVal*, gulong, gchar*))	\
williamr@2
   206
        g_thread_functions_for_glib_use.cond_timed_wait)		\
williamr@2
   207
          (cond, mutex, abs_time, G_MUTEX_DEBUG_MAGIC, G_STRLOC) : TRUE)
williamr@2
   208
#endif /* G_ERRORCHECK_MUTEXES */
williamr@2
   209
williamr@2
   210
#define g_mutex_new()            G_THREAD_UF (mutex_new,      ())
williamr@2
   211
#define g_cond_new()             G_THREAD_UF (cond_new,       ())
williamr@2
   212
#define g_cond_signal(cond)      G_THREAD_CF (cond_signal,    (void)0, (cond))
williamr@2
   213
#define g_cond_broadcast(cond)   G_THREAD_CF (cond_broadcast, (void)0, (cond))
williamr@2
   214
#define g_cond_free(cond)        G_THREAD_CF (cond_free,      (void)0, (cond))
williamr@2
   215
#define g_private_new(destructor) G_THREAD_UF (private_new, (destructor))
williamr@2
   216
#define g_private_get(private_key) G_THREAD_CF (private_get, \
williamr@2
   217
                                                ((gpointer)private_key), \
williamr@2
   218
                                                (private_key))
williamr@2
   219
#define g_private_set(private_key, value) G_THREAD_CF (private_set, \
williamr@2
   220
                                                       (void) (private_key = \
williamr@2
   221
                                                        (GPrivate*) (value)), \
williamr@2
   222
                                                       (private_key, value))
williamr@2
   223
#define g_thread_yield()              G_THREAD_CF (thread_yield, (void)0, ())
williamr@2
   224
williamr@2
   225
#define g_thread_create(func, data, joinable, error)			\
williamr@2
   226
  (g_thread_create_full (func, data, 0, joinable, FALSE, 		\
williamr@2
   227
                         G_THREAD_PRIORITY_NORMAL, error))
williamr@2
   228
williamr@2
   229
IMPORT_C GThread* g_thread_create_full  (GThreadFunc            func,
williamr@2
   230
                                gpointer               data,
williamr@2
   231
                                gulong                 stack_size,
williamr@2
   232
                                gboolean               joinable,
williamr@2
   233
                                gboolean               bound,
williamr@2
   234
                                GThreadPriority        priority,
williamr@2
   235
                                GError               **error);
williamr@2
   236
IMPORT_C GThread* g_thread_self         (void);
williamr@2
   237
IMPORT_C void     g_thread_exit         (gpointer               retval);
williamr@2
   238
IMPORT_C gpointer g_thread_join         (GThread               *thread);
williamr@2
   239
williamr@2
   240
IMPORT_C void     g_thread_set_priority (GThread               *thread,
williamr@2
   241
                                GThreadPriority        priority);
williamr@2
   242
williamr@2
   243
/* GStaticMutexes can be statically initialized with the value
williamr@2
   244
 * G_STATIC_MUTEX_INIT, and then they can directly be used, that is
williamr@2
   245
 * much easier, than having to explicitly allocate the mutex before
williamr@2
   246
 * use
williamr@2
   247
 */
williamr@2
   248
#define g_static_mutex_lock(mutex) \
williamr@2
   249
    g_mutex_lock (g_static_mutex_get_mutex (mutex))
williamr@2
   250
#define g_static_mutex_trylock(mutex) \
williamr@2
   251
    g_mutex_trylock (g_static_mutex_get_mutex (mutex))
williamr@2
   252
#define g_static_mutex_unlock(mutex) \
williamr@2
   253
    g_mutex_unlock (g_static_mutex_get_mutex (mutex))
williamr@2
   254
IMPORT_C void g_static_mutex_init (GStaticMutex *mutex);
williamr@2
   255
IMPORT_C void g_static_mutex_free (GStaticMutex *mutex);
williamr@2
   256
williamr@2
   257
struct _GStaticPrivate
williamr@2
   258
{
williamr@2
   259
  /*< private >*/
williamr@2
   260
  guint index;
williamr@2
   261
};
williamr@2
   262
#define G_STATIC_PRIVATE_INIT { 0 }
williamr@2
   263
IMPORT_C void     g_static_private_init           (GStaticPrivate   *private_key);
williamr@2
   264
IMPORT_C gpointer g_static_private_get            (GStaticPrivate   *private_key);
williamr@2
   265
IMPORT_C void     g_static_private_set            (GStaticPrivate   *private_key,
williamr@2
   266
					  gpointer          data,
williamr@2
   267
					  GDestroyNotify    notify);
williamr@2
   268
IMPORT_C void     g_static_private_free           (GStaticPrivate   *private_key);
williamr@2
   269
williamr@2
   270
typedef struct _GStaticRecMutex GStaticRecMutex;
williamr@2
   271
struct _GStaticRecMutex
williamr@2
   272
{
williamr@2
   273
  /*< private >*/
williamr@2
   274
  GStaticMutex mutex;
williamr@2
   275
  guint depth;
williamr@2
   276
  GSystemThread owner;
williamr@2
   277
};
williamr@2
   278
williamr@2
   279
#define G_STATIC_REC_MUTEX_INIT { G_STATIC_MUTEX_INIT }
williamr@2
   280
IMPORT_C void     g_static_rec_mutex_init        (GStaticRecMutex *mutex);
williamr@2
   281
IMPORT_C void     g_static_rec_mutex_lock        (GStaticRecMutex *mutex);
williamr@2
   282
IMPORT_C gboolean g_static_rec_mutex_trylock     (GStaticRecMutex *mutex);
williamr@2
   283
IMPORT_C void     g_static_rec_mutex_unlock      (GStaticRecMutex *mutex);
williamr@2
   284
IMPORT_C void     g_static_rec_mutex_lock_full   (GStaticRecMutex *mutex,
williamr@2
   285
                                         guint            depth);
williamr@2
   286
IMPORT_C guint    g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex);
williamr@2
   287
IMPORT_C void     g_static_rec_mutex_free        (GStaticRecMutex *mutex);
williamr@2
   288
williamr@2
   289
typedef struct _GStaticRWLock GStaticRWLock;
williamr@2
   290
struct _GStaticRWLock
williamr@2
   291
{
williamr@2
   292
  /*< private >*/
williamr@2
   293
  GStaticMutex mutex;
williamr@2
   294
  GCond *read_cond;
williamr@2
   295
  GCond *write_cond;
williamr@2
   296
  guint read_counter;
williamr@2
   297
  gboolean have_writer;
williamr@2
   298
  guint want_to_read;
williamr@2
   299
  guint want_to_write;
williamr@2
   300
};
williamr@2
   301
williamr@2
   302
#define G_STATIC_RW_LOCK_INIT { G_STATIC_MUTEX_INIT, NULL, NULL, 0, FALSE, 0, 0 }
williamr@2
   303
williamr@2
   304
IMPORT_C void      g_static_rw_lock_init           (GStaticRWLock* lock);
williamr@2
   305
IMPORT_C void      g_static_rw_lock_reader_lock    (GStaticRWLock* lock);
williamr@2
   306
IMPORT_C gboolean  g_static_rw_lock_reader_trylock (GStaticRWLock* lock);
williamr@2
   307
IMPORT_C void      g_static_rw_lock_reader_unlock  (GStaticRWLock* lock);
williamr@2
   308
IMPORT_C void      g_static_rw_lock_writer_lock    (GStaticRWLock* lock);
williamr@2
   309
IMPORT_C gboolean  g_static_rw_lock_writer_trylock (GStaticRWLock* lock);
williamr@2
   310
IMPORT_C void      g_static_rw_lock_writer_unlock  (GStaticRWLock* lock);
williamr@2
   311
IMPORT_C void      g_static_rw_lock_free           (GStaticRWLock* lock);
williamr@2
   312
williamr@2
   313
IMPORT_C void	  g_thread_foreach         	  (GFunc    	  thread_func,
williamr@2
   314
					   gpointer 	  user_data);
williamr@2
   315
williamr@2
   316
typedef enum
williamr@2
   317
{
williamr@2
   318
  G_ONCE_STATUS_NOTCALLED,
williamr@2
   319
  G_ONCE_STATUS_PROGRESS,
williamr@2
   320
  G_ONCE_STATUS_READY  
williamr@2
   321
} GOnceStatus;
williamr@2
   322
williamr@2
   323
typedef struct _GOnce GOnce;
williamr@2
   324
struct _GOnce
williamr@2
   325
{
williamr@2
   326
  volatile GOnceStatus status;
williamr@2
   327
  volatile gpointer retval;
williamr@2
   328
};
williamr@2
   329
williamr@2
   330
#define G_ONCE_INIT { G_ONCE_STATUS_NOTCALLED, NULL }
williamr@2
   331
williamr@2
   332
IMPORT_C gpointer g_once_impl (GOnce *once, GThreadFunc func, gpointer arg);
williamr@2
   333
williamr@2
   334
#ifdef G_ATOMIC_OP_MEMORY_BARRIER_NEEDED
williamr@2
   335
# define g_once(once, func, arg) g_once_impl ((once), (func), (arg))
williamr@2
   336
#else /* !G_ATOMIC_OP_MEMORY_BARRIER_NEEDED*/
williamr@2
   337
# define g_once(once, func, arg) \
williamr@2
   338
  (((once)->status == G_ONCE_STATUS_READY) ? \
williamr@2
   339
   (once)->retval : \
williamr@2
   340
   g_once_impl ((once), (func), (arg)))
williamr@2
   341
#endif /* G_ATOMIC_OP_MEMORY_BARRIER_NEEDED */
williamr@2
   342
    
williamr@2
   343
/* these are some convenience macros that expand to nothing if GLib
williamr@2
   344
 * was configured with --disable-threads. for using StaticMutexes,
williamr@2
   345
 * you define them with G_LOCK_DEFINE_STATIC (name) or G_LOCK_DEFINE (name)
williamr@2
   346
 * if you need to export the mutex. With G_LOCK_EXTERN (name) you can
williamr@2
   347
 * declare such an globally defined lock. name is a unique identifier
williamr@2
   348
 * for the protected varibale or code portion. locking, testing and
williamr@2
   349
 * unlocking of such mutexes can be done with G_LOCK(), G_UNLOCK() and
williamr@2
   350
 * G_TRYLOCK() respectively.
williamr@2
   351
 */
williamr@2
   352
 #ifdef __SYMBIAN32__
williamr@2
   353
 #ifdef G_DEBUG_LOCKS
williamr@2
   354
 #undef G_DEBUG_LOCKS
williamr@2
   355
 #endif //G_DEBUG_LOCKS
williamr@2
   356
 #endif //__SYMBIAN32__
williamr@2
   357
 
williamr@2
   358
extern void glib_dummy_decl (void);
williamr@2
   359
#define G_LOCK_NAME(name)               g__ ## name ## _lock
williamr@2
   360
#ifdef  G_THREADS_ENABLED
williamr@2
   361
#  define G_LOCK_DEFINE_STATIC(name)    static G_LOCK_DEFINE (name)
williamr@2
   362
#  define G_LOCK_DEFINE(name)           \
williamr@2
   363
    GStaticMutex G_LOCK_NAME (name) = G_STATIC_MUTEX_INIT
williamr@2
   364
#  define G_LOCK_EXTERN(name)           extern GStaticMutex G_LOCK_NAME (name)
williamr@2
   365
williamr@2
   366
#  ifdef G_DEBUG_LOCKS
williamr@2
   367
#    define G_LOCK(name)                G_STMT_START{             \
williamr@2
   368
        g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,                   \
williamr@2
   369
               "file %s: line %d (%s): locking: %s ",             \
williamr@2
   370
               __FILE__,        __LINE__, G_GNUC_PRETTY_FUNCTION, \
williamr@2
   371
               #name);                                            \
williamr@2
   372
        g_static_mutex_lock (&G_LOCK_NAME (name));                \
williamr@2
   373
     }G_STMT_END
williamr@2
   374
#    define G_UNLOCK(name)              G_STMT_START{             \
williamr@2
   375
        g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,                   \
williamr@2
   376
               "file %s: line %d (%s): unlocking: %s ",           \
williamr@2
   377
               __FILE__,        __LINE__, G_GNUC_PRETTY_FUNCTION, \
williamr@2
   378
               #name);                                            \
williamr@2
   379
       g_static_mutex_unlock (&G_LOCK_NAME (name));               \
williamr@2
   380
     }G_STMT_END
williamr@2
   381
#    define G_TRYLOCK(name)                                       \
williamr@2
   382
        (g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,                  \
williamr@2
   383
               "file %s: line %d (%s): try locking: %s ",         \
williamr@2
   384
               __FILE__,        __LINE__, G_GNUC_PRETTY_FUNCTION, \
williamr@2
   385
               #name), g_static_mutex_trylock (&G_LOCK_NAME (name)))
williamr@2
   386
#  else  /* !G_DEBUG_LOCKS */
williamr@2
   387
#    define G_LOCK(name) g_static_mutex_lock       (&G_LOCK_NAME (name))
williamr@2
   388
#    define G_UNLOCK(name) g_static_mutex_unlock   (&G_LOCK_NAME (name))
williamr@2
   389
#    define G_TRYLOCK(name) g_static_mutex_trylock (&G_LOCK_NAME (name))
williamr@2
   390
#  endif /* !G_DEBUG_LOCKS */
williamr@2
   391
#else   /* !G_THREADS_ENABLED */
williamr@2
   392
#  define G_LOCK_DEFINE_STATIC(name)    extern void glib_dummy_decl (void)
williamr@2
   393
#  define G_LOCK_DEFINE(name)           extern void glib_dummy_decl (void)
williamr@2
   394
#  define G_LOCK_EXTERN(name)           extern void glib_dummy_decl (void)
williamr@2
   395
#  define G_LOCK(name)
williamr@2
   396
#  define G_UNLOCK(name)
williamr@2
   397
#  define G_TRYLOCK(name)               (TRUE)
williamr@2
   398
#endif  /* !G_THREADS_ENABLED */
williamr@2
   399
williamr@2
   400
williamr@2
   401
G_END_DECLS
williamr@2
   402
williamr@2
   403
#endif /* __G_THREAD_H__ */
williamr@2
   404