# gthr.h

    00001 /* Threads compatibility routines for libgcc2.  */
    00002 /* Compile this one with gcc.  */
    00003 /* Copyright (C) 1997, 1998, 2004 Free Software Foundation, Inc.
    00004
    00005 This file is part of GCC.
    00006
    00007 GCC is free software; you can redistribute it and/or modify it under
    00008 the terms of the GNU General Public License as published by the Free
    00009 Software Foundation; either version 2, or (at your option) any later
    00010 version.
    00011
    00012 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
    00013 WARRANTY; without even the implied warranty of MERCHANTABILITY or
    00014 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    00015 for more details.
    00016
    00017 You should have received a copy of the GNU General Public License
    00018 along with GCC; see the file COPYING.  If not, write to the Free
    00019 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
    00020 02110-1301, USA.  */
    00021
    00022 /* As a special exception, if you link this library with other files,
    00023    some of which are compiled with GCC, to produce an executable,
    00024    this library does not by itself cause the resulting executable
    00025    to be covered by the GNU General Public License.
    00026    This exception does not however invalidate any other reasons why
    00027    the executable file might be covered by the GNU General Public License.  */
    00028
    00029 #ifndef _GLIBCXX_GCC_GTHR_H
    00030 #define _GLIBCXX_GCC_GTHR_H
    00031
    00032 #ifndef _GLIBCXX_HIDE_EXPORTS
    00033 #pragma GCC visibility push(default)
    00034 #endif
    00035
    00036 /* If this file is compiled with threads support, it must
    00037        #define __GTHREADS 1
    00038    to indicate that threads support is present.  Also it has define
    00039    function
    00040      int __gthread_active_p ()
    00041    that returns 1 if thread system is active, 0 if not.
    00042
    00043    The threads interface must define the following types:
    00044      __gthread_key_t
    00045      __gthread_once_t
    00046      __gthread_mutex_t
    00047      __gthread_recursive_mutex_t
    00048
    00049    The threads interface must define the following macros:
    00050
    00051      __GTHREAD_ONCE_INIT
    00052             to initialize __gthread_once_t
    00053      __GTHREAD_MUTEX_INIT
    00054             to initialize __gthread_mutex_t to get a fast
    00055         non-recursive mutex.
    00056      __GTHREAD_MUTEX_INIT_FUNCTION
    00057             some systems can't initialize a mutex without a
    00058         function call.  On such systems, define this to a
    00059         function which looks like this:
    00060           void __GTHREAD_MUTEX_INIT_FUNCTION (__gthread_mutex_t *)
    00061         Don't define __GTHREAD_MUTEX_INIT in this case
    00062      __GTHREAD_RECURSIVE_MUTEX_INIT
    00063      __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION
    00064             as above, but for a recursive mutex.
    00065
    00066    The threads interface must define the following static functions:
    00067
    00068      int __gthread_once (__gthread_once_t *once, void (*func) ())
    00069
    00070      int __gthread_key_create (__gthread_key_t *keyp, void (*dtor) (void *))
    00071      int __gthread_key_delete (__gthread_key_t key)
    00072
    00073      void *__gthread_getspecific (__gthread_key_t key)
    00074      int __gthread_setspecific (__gthread_key_t key, const void *ptr)
    00075
    00076      int __gthread_mutex_lock (__gthread_mutex_t *mutex);
    00077      int __gthread_mutex_trylock (__gthread_mutex_t *mutex);
    00078      int __gthread_mutex_unlock (__gthread_mutex_t *mutex);
    00079
    00080      int __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex);
    00081      int __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex);
    00082      int __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex);
    00083
    00084    All functions returning int should return zero on success or the error
    00085    number.  If the operation is not supported, -1 is returned.
    00086
    00087    Currently supported threads packages are
    00088      TPF threads with -D__tpf__
    00089      POSIX/Unix98 threads with -D_PTHREADS
    00090      POSIX/Unix95 threads with -D_PTHREADS95
    00091      DCE threads with -D_DCE_THREADS
    00092      Solaris/UI threads with -D_SOLARIS_THREADS
    00093 */
    00094
    00095 /* Check first for thread specific defines.  */
    00096 #if defined (_GLIBCXX___tpf_GLIBCXX___)
    00097 #include <bits/gthr-tpf.h>
    00098 #elif _GLIBCXX__PTHREADS
    00099 #include <bits/gthr-posix.h>
    00100 #elif _GLIBCXX__PTHREADS95
    00101 #include <bits/gthr-posix95.h>
    00102 #elif _GLIBCXX__DCE_THREADS
    00103 #include <bits/gthr-dce.h>
    00104 #elif _GLIBCXX__SOLARIS_THREADS
    00105 #include <bits/gthr-solaris.h>
    00106
    00107 /* Include GTHREAD_FILE if one is defined.  */
    00108 #elif defined(_GLIBCXX_HAVE_GTHR_DEFAULT)
    00109 #if __GXX_WEAK__
    00110 #ifndef _GLIBCXX_GTHREAD_USE_WEAK
    00111 #define _GLIBCXX_GTHREAD_USE_WEAK 1
    00112 #endif
    00113 #endif
    00114 #include <bits/gthr-default.h>
    00115
    00116 /* Fallback to single thread definitions.  */
    00117 #else
    00118 #include <bits/gthr-single.h>
    00119 #endif
    00120
    00121 #ifndef _GLIBCXX_HIDE_EXPORTS
    00122 #pragma GCC visibility pop
    00123 #endif
    00124
    00125 #endif /* ! _GLIBCXX_GCC_GTHR_H */