/*

 * Copyright (c) 1997-1999

 * Silicon Graphics Computer Systems, Inc.

 *

 * Copyright (c) 1999

 * Boris Fomitchev

 *

 * This material is provided "as is", with absolutely no warranty expressed

 * or implied. Any use is at your own risk.

 *

 * Permission to use or copy this software for any purpose is hereby granted

 * without fee, provided the above notices are retained on all copies.

 * Permission to modify the code and to distribute modified code is granted,

 * provided the above notices are retained, and a notice that the code was

 * modified is included with the above copyright notice.

 *

 */

// WARNING: This is an internal header file, included by other C++

// standard library headers.  You should not attempt to use this header

// file directly.

#ifndef _STLP_INTERNAL_THREADS_H

#define _STLP_INTERNAL_THREADS_H

// Supported threading models are native SGI, pthreads, uithreads

// (similar to pthreads, but based on an earlier draft of the Posix

// threads standard), and Win32 threads.  Uithread support by Jochen

// Schlick, 1999, and Solaris threads generalized to them.

#ifndef _STLP_INTERNAL_CSTDDEF

#  include <stl/_cstddef.h>

#endif

#ifndef _STLP_INTERNAL_CSTDLIB

#  include <stl/_cstdlib.h>

#endif

// On SUN and Mac OS X gcc, zero-initialization works just fine...

#if defined (__sun) || (defined (__GNUC__) && defined(__APPLE__))

#  define _STLP_MUTEX_INITIALIZER

#endif

/* This header defines the following atomic operation that platform should

 * try to support as much as possible. Atomic operation are exposed as macro

 * in order to easily test for their existance. They are:

 * __stl_atomic_t _STLP_ATOMIC_INCREMENT(volatile __stl_atomic_t* __ptr) :

 * increment *__ptr by 1 and returns the new value

 * __stl_atomic_t _STLP_ATOMIC_DECREMENT(volatile __stl_atomic_t* __ptr) :

 * decrement  *__ptr by 1 and returns the new value

 * __stl_atomic_t _STLP_ATOMIC_EXCHANGE(volatile __stl_atomic_t* __target, __stl_atomic_t __val) :

 * assign __val to *__target and returns former *__target value

 * void* _STLP_ATOMIC_EXCHANGE_PTR(void* volatile* __target, void* __ptr) :

 * assign __ptr to *__target and returns former *__target value

 * __stl_atomic_t _STLP_ATOMIC_ADD(volatile __stl_atomic_t* __target, __stl_atomic_t __val) :

 * does *__target = *__target + __val and returns the old *__target value

 */

#if defined (_STLP_WIN32) || defined (__sgi) || defined (_STLP_SPARC_SOLARIS_THREADS)

typedef long __stl_atomic_t;

#else

/* Don't import whole namespace!!!! - ptr */

// # if defined (_STLP_USE_NAMESPACES) && ! defined (_STLP_VENDOR_GLOBAL_CSTD)

// // using _STLP_VENDOR_CSTD::size_t;

// using namespace _STLP_VENDOR_CSTD;

// # endif

typedef size_t __stl_atomic_t;

#endif

#if defined (_STLP_THREADS)

#  if defined (_STLP_SGI_THREADS)

#    include <mutex.h>

// Hack for SGI o32 compilers.

#    if !defined(__add_and_fetch) && \

        (__mips < 3 || !(defined (_ABIN32) || defined(_ABI64)))

#      define __add_and_fetch(__l,__v) add_then_test((unsigned long*)__l,__v)

#      define __test_and_set(__l,__v)  test_and_set(__l,__v)

#    endif /* o32 */

#    if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64))

#      define _STLP_ATOMIC_EXCHANGE(__p, __q) test_and_set(__p, __q)

#    else

#      define _STLP_ATOMIC_EXCHANGE(__p, __q) __test_and_set((unsigned long*)__p, (unsigned long)__q)

#    endif

#    define _STLP_ATOMIC_INCREMENT(__x) __add_and_fetch(__x, 1)

#    define _STLP_ATOMIC_DECREMENT(__x) __add_and_fetch(__x, (size_t) -1)

#  elif defined (_STLP_PTHREADS)

#    include <pthread.h>

#    if !defined (_STLP_USE_PTHREAD_SPINLOCK)

#      if defined (PTHREAD_MUTEX_INITIALIZER) && !defined (_STLP_MUTEX_INITIALIZER) && defined (_REENTRANT)

#        define _STLP_MUTEX_INITIALIZER = { PTHREAD_MUTEX_INITIALIZER }

#      endif

//HPUX variants have (on some platforms optional) non-standard "DCE" pthreads impl

#      if defined (_DECTHREADS_) && (defined (_PTHREAD_USE_D4) || defined (__hpux)) && !defined (_CMA_SUPPRESS_EXTERNALS_)

#        define _STLP_PTHREAD_ATTR_DEFAULT pthread_mutexattr_default

#      else

#        define _STLP_PTHREAD_ATTR_DEFAULT 0

#      endif

#    else // _STLP_USE_PTHREAD_SPINLOCK

#      if defined (__OpenBSD__)

#        include <spinlock.h>

#      endif

#    endif // _STLP_USE_PTHREAD_SPINLOCK

#    if defined (__GNUC__) && defined (__i386__)

#      if !defined (_STLP_ATOMIC_INCREMENT)

inline long _STLP_atomic_increment_gcc_x86(long volatile* p) {

  long result;

  __asm__ __volatile__

    ("lock; xaddl  %1, %0;"

    :"=m" (*p), "=r" (result)

    :"m" (*p),  "1"  (1)

    :"cc");

  return result + 1;

}

#        define _STLP_ATOMIC_INCREMENT(__x) (_STLP_atomic_increment_gcc_x86((long volatile*)__x))

#      endif

#      if !defined (_STLP_ATOMIC_DECREMENT)

inline long _STLP_atomic_decrement_gcc_x86(long volatile* p) {

  long result;

  __asm__ __volatile__

    ("lock; xaddl  %1, %0;"

    :"=m" (*p), "=r" (result)

    :"m" (*p),  "1"  (-1)

    :"cc");

  return result - 1;

}

#        define _STLP_ATOMIC_DECREMENT(__x) (_STLP_atomic_decrement_gcc_x86((long volatile*)__x))

#      endif

#      if !defined (_STLP_ATOMIC_ADD)

inline long _STLP_atomic_add_gcc_x86(long volatile* p, long addend) {

  long result;

  __asm__ __volatile__

    ("lock; xaddl %1, %0;"

    :"=m" (*p), "=r" (result)

    :"m"  (*p), "1"  (addend)

    :"cc");

 return result + addend;

}

#        define _STLP_ATOMIC_ADD(__dst, __val)  (_STLP_atomic_add_gcc_x86((long volatile*)__dst, (long)__val))

#      endif

#    endif /* if defined(__GNUC__) && defined(__i386__) */

#  elif defined (_STLP_WIN32THREADS)

#    if !defined (_STLP_ATOMIC_INCREMENT)

#      if !defined (_STLP_NEW_PLATFORM_SDK)

#        define _STLP_ATOMIC_INCREMENT(__x)           InterlockedIncrement(__CONST_CAST(long*, __x))

#        define _STLP_ATOMIC_DECREMENT(__x)           InterlockedDecrement(__CONST_CAST(long*, __x))

#        define _STLP_ATOMIC_EXCHANGE(__x, __y)       InterlockedExchange(__CONST_CAST(long*, __x), __y)

#      else

#        define _STLP_ATOMIC_INCREMENT(__x)           InterlockedIncrement(__x)

#        define _STLP_ATOMIC_DECREMENT(__x)           InterlockedDecrement(__x)

#        define _STLP_ATOMIC_EXCHANGE(__x, __y)       InterlockedExchange(__x, __y)

#      endif

#      define _STLP_ATOMIC_EXCHANGE_PTR(__x, __y)     STLPInterlockedExchangePointer(__x, __y)

/*

 * The following functionnality is only available since Windows 98, those that are targeting previous OSes

 * should define _WIN32_WINDOWS to a value lower that the one of Win 98, see Platform SDK documentation for

 * more informations:

 */

#      if defined (_STLP_NEW_PLATFORM_SDK) && (!defined (WINVER) || (WINVER >= 0x0410)) && \

                                              (!defined (_WIN32_WINDOWS) || (_WIN32_WINDOWS >= 0x0410))

#        define _STLP_ATOMIC_ADD(__dst, __val) InterlockedExchangeAdd(__dst, __val)

#      endif

#    endif

#  elif defined (__DECC) || defined (__DECCXX)

#    include <machine/builtins.h>

#    define _STLP_ATOMIC_EXCHANGE __ATOMIC_EXCH_LONG

#    define _STLP_ATOMIC_INCREMENT(__x) __ATOMIC_ADD_LONG(__x, 1)

#    define _STLP_ATOMIC_DECREMENT(__x) __ATOMIC_ADD_LONG(__x, -1)

#  elif defined(_STLP_SPARC_SOLARIS_THREADS)

#    include <stl/_sparc_atomic.h>

#  elif defined (_STLP_UITHREADS)

// this inclusion is potential hazard to bring up all sorts

// of old-style headers. Let's assume vendor already know how

// to deal with that.

#    ifndef _STLP_INTERNAL_CTIME

#      include <stl/_ctime.h>

#    endif

#    if defined (_STLP_USE_NAMESPACES) && ! defined (_STLP_VENDOR_GLOBAL_CSTD)

using _STLP_VENDOR_CSTD::time_t;

#    endif

#    include <synch.h>

#    include <cstdio>

#    include <cwchar>

#  elif defined (_STLP_BETHREADS)

#    include <OS.h>

#    include <cassert>

#    include <stdio.h>

#    define _STLP_MUTEX_INITIALIZER = { 0 }

#  elif defined (_STLP_NWTHREADS)

#    include <nwthread.h>

#    include <nwsemaph.h>

#  elif defined(_STLP_OS2THREADS)

#    if defined (__GNUC__)

#      define INCL_DOSSEMAPHORES

#      include <os2.h>

#    else

// This section serves to replace os2.h for VisualAge C++

  typedef unsigned long ULONG;

#      if !defined (__HEV__)  /* INCL_SEMAPHORE may also define HEV */

#        define __HEV__

  typedef ULONG HEV;

  typedef HEV*  PHEV;

#      endif

  typedef ULONG APIRET;

  typedef ULONG HMTX;

  typedef HMTX*  PHMTX;

  typedef const char*  PCSZ;

  typedef ULONG BOOL32;

  APIRET _System DosCreateMutexSem(PCSZ pszName, PHEV phev, ULONG flAttr, BOOL32 fState);

  APIRET _System DosRequestMutexSem(HMTX hmtx, ULONG ulTimeout);

  APIRET _System DosReleaseMutexSem(HMTX hmtx);

  APIRET _System DosCloseMutexSem(HMTX hmtx);

#      define _STLP_MUTEX_INITIALIZER = { 0 }

#    endif /* GNUC */

#  endif

#else

/* no threads */

#  define _STLP_ATOMIC_INCREMENT(__x) ++(*__x)

#  define _STLP_ATOMIC_DECREMENT(__x) --(*__x)

/* We do not grant other atomic operations as they are useless if STLport do not have

 * to be thread safe

 */

#endif

#if !defined (_STLP_MUTEX_INITIALIZER)

#  if defined(_STLP_ATOMIC_EXCHANGE)

#    define _STLP_MUTEX_INITIALIZER = { 0 }

#  elif defined(_STLP_UITHREADS)

#    define _STLP_MUTEX_INITIALIZER = { DEFAULTMUTEX }

#  else

#    define _STLP_MUTEX_INITIALIZER

#  endif

#endif

_STLP_BEGIN_NAMESPACE

#if defined (_STLP_THREADS) && !defined (_STLP_USE_PTHREAD_SPINLOCK)

// Helper struct.  This is a workaround for various compilers that don't

// handle static variables in inline functions properly.

template <int __inst>

struct _STLP_mutex_spin {

  enum { __low_max = 30, __high_max = 1000 };

  // Low if we suspect uniprocessor, high for multiprocessor.

  static unsigned __max;

  static unsigned __last;

  static void _STLP_CALL _M_do_lock(volatile __stl_atomic_t* __lock);

  static void _STLP_CALL _S_nsec_sleep(int __log_nsec);

};

#endif // !_STLP_USE_PTHREAD_SPINLOCK

// Locking class.  Note that this class *does not have a constructor*.

// It must be initialized either statically, with _STLP_MUTEX_INITIALIZER,

// or dynamically, by explicitly calling the _M_initialize member function.

// (This is similar to the ways that a pthreads mutex can be initialized.)

// There are explicit member functions for acquiring and releasing the lock.

// There is no constructor because static initialization is essential for

// some uses, and only a class aggregate (see section 8.5.1 of the C++

// standard) can be initialized that way.  That means we must have no

// constructors, no base classes, no virtual functions, and no private or

// protected members.

// For non-static cases, clients should use  _STLP_mutex.

struct _STLP_CLASS_DECLSPEC _STLP_mutex_base {

#if defined (_STLP_ATOMIC_EXCHANGE) || defined (_STLP_SGI_THREADS)

  // It should be relatively easy to get this to work on any modern Unix.

  volatile __stl_atomic_t _M_lock;

#endif

#if defined (_STLP_THREADS)

#  if defined (_STLP_ATOMIC_EXCHANGE)

  inline void _M_initialize() { _M_lock = 0; }

  inline void _M_destroy() {}

  void _M_acquire_lock() {

    _STLP_mutex_spin<0>::_M_do_lock(&_M_lock);

  }

  inline void _M_release_lock() {

    volatile __stl_atomic_t* __lock = &_M_lock;

#    if defined(_STLP_SGI_THREADS) && defined(__GNUC__) && __mips >= 3

    asm("sync");

    *__lock = 0;

#    elif defined(_STLP_SGI_THREADS) && __mips >= 3 && \

         (defined (_ABIN32) || defined(_ABI64))

    __lock_release(__lock);

#    elif defined (_STLP_SPARC_SOLARIS_THREADS)

#      if defined (__WORD64) || defined (__arch64__) || defined (__sparcv9) || defined (__sparcv8plus)

    asm("membar #StoreStore ; membar #LoadStore");

#      else

    asm(" stbar ");

#      endif

    *__lock = 0;

#    else

    *__lock = 0;

    // This is not sufficient on many multiprocessors, since

    // writes to protected variables and the lock may be reordered.

#    endif

  }

#  elif defined (_STLP_PTHREADS)

#    if defined (_STLP_USE_PTHREAD_SPINLOCK)

#      if !defined (__OpenBSD__)

  pthread_spinlock_t _M_lock;

  inline void _M_initialize() { pthread_spin_init( &_M_lock, 0 ); }

  inline void _M_destroy() { pthread_spin_destroy( &_M_lock ); }

  // sorry, but no static initializer for pthread_spinlock_t;

  // this will not work for compilers that has problems with call

  // constructor of static object...

  // _STLP_mutex_base()

  //   { pthread_spin_init( &_M_lock, 0 ); }

  // ~_STLP_mutex_base()

  //   { pthread_spin_destroy( &_M_lock ); }

  inline void _M_acquire_lock() { pthread_spin_lock( &_M_lock ); }

  inline void _M_release_lock() { pthread_spin_unlock( &_M_lock ); }

#      else // __OpenBSD__

  spinlock_t _M_lock;

  inline void _M_initialize() { _SPINLOCK_INIT( &_M_lock ); }

  inline void _M_destroy() { }

  inline void _M_acquire_lock() { _SPINLOCK( &_M_lock ); }

  inline void _M_release_lock() { _SPINUNLOCK( &_M_lock ); }

#      endif // __OpenBSD__

#    else // !_STLP_USE_PTHREAD_SPINLOCK

  pthread_mutex_t _M_lock;

  inline void _M_initialize()

  { pthread_mutex_init(&_M_lock,_STLP_PTHREAD_ATTR_DEFAULT); }

  inline void _M_destroy()

  { pthread_mutex_destroy(&_M_lock); }

  inline void _M_acquire_lock() {

#      if defined ( __hpux ) && ! defined (PTHREAD_MUTEX_INITIALIZER)

    if (!_M_lock.field1)  _M_initialize();

#      endif

    pthread_mutex_lock(&_M_lock);

  }

  inline void _M_release_lock() { pthread_mutex_unlock(&_M_lock); }

#    endif // !_STLP_USE_PTHREAD_SPINLOCK

#  elif defined (_STLP_UITHREADS)

  mutex_t _M_lock;

  inline void _M_initialize()

  { mutex_init(&_M_lock, 0, NULL); }

  inline void _M_destroy()

  { mutex_destroy(&_M_lock); }

  inline void _M_acquire_lock() { mutex_lock(&_M_lock); }

  inline void _M_release_lock() { mutex_unlock(&_M_lock); }

#  elif defined (_STLP_OS2THREADS)

  HMTX _M_lock;

  inline void _M_initialize() { DosCreateMutexSem(NULL, &_M_lock, 0, false); }

  inline void _M_destroy() { DosCloseMutexSem(_M_lock); }

  inline void _M_acquire_lock() {

    if (!_M_lock) _M_initialize();

    DosRequestMutexSem(_M_lock, SEM_INDEFINITE_WAIT);

  }

  inline void _M_release_lock() { DosReleaseMutexSem(_M_lock); }

#  elif defined (_STLP_BETHREADS)

  sem_id sem;

  inline void _M_initialize() {

    sem = create_sem(1, "STLPort");

    assert(sem > 0);

  }

  inline void _M_destroy() {

    int t = delete_sem(sem);

    assert(t == B_NO_ERROR);

  }

  inline void _M_acquire_lock();

  inline void _M_release_lock() {

    status_t t = release_sem(sem);

    assert(t == B_NO_ERROR);

  }

#  elif defined (_STLP_NWTHREADS)

  LONG _M_lock;

  inline void _M_initialize()

  { _M_lock = OpenLocalSemaphore(1); }

  inline void _M_destroy()

  { CloseLocalSemaphore(_M_lock); }

  inline void _M_acquire_lock()

  { WaitOnLocalSemaphore(_M_lock); }

  inline void _M_release_lock() { SignalLocalSemaphore(_M_lock); }

#  else      //*ty 11/24/2001 - added configuration check

#    error "Unknown thread facility configuration"

#  endif

#else /* No threads */

  inline void _M_initialize() {}

  inline void _M_destroy() {}

  inline void _M_acquire_lock() {}

  inline void _M_release_lock() {}

#endif // _STLP_PTHREADS

};

// Locking class.  The constructor initializes the lock, the destructor destroys it.

// Well - behaving class, does not need static initializer

class _STLP_CLASS_DECLSPEC _STLP_mutex : public _STLP_mutex_base {

  public:

    inline _STLP_mutex () { _M_initialize(); }

    inline ~_STLP_mutex () { _M_destroy(); }

  private:

    _STLP_mutex(const _STLP_mutex&);

    void operator=(const _STLP_mutex&);

};

// A locking class that uses _STLP_STATIC_MUTEX.  The constructor takes

// a reference to an _STLP_STATIC_MUTEX, and acquires a lock.  The destructor

// releases the lock.

// It's not clear that this is exactly the right functionality.

// It will probably change in the future.

struct _STLP_CLASS_DECLSPEC _STLP_auto_lock {

  _STLP_auto_lock(_STLP_STATIC_MUTEX& __lock) : _M_lock(__lock)

  { _M_lock._M_acquire_lock(); }

  ~_STLP_auto_lock()

  { _M_lock._M_release_lock(); }

private:

  _STLP_STATIC_MUTEX& _M_lock;

  void operator=(const _STLP_auto_lock&);

  _STLP_auto_lock(const _STLP_auto_lock&);

};

/*

 * Class _Refcount_Base provides a type, __stl_atomic_t, a data member,

 * _M_ref_count, and member functions _M_incr and _M_decr, which perform

 * atomic preincrement/predecrement.  The constructor initializes

 * _M_ref_count.

 */

class _STLP_CLASS_DECLSPEC _Refcount_Base {

  // The data member _M_ref_count

#if defined (__DMC__)

public:

#endif

  _STLP_VOLATILE __stl_atomic_t _M_ref_count;

#if !defined (_STLP_ATOMIC_EXCHANGE)

  _STLP_mutex _M_mutex;

#endif

  public:

  // Constructor

  _Refcount_Base(__stl_atomic_t __n) : _M_ref_count(__n) {}

  // _M_incr and _M_decr

#if defined (_STLP_THREADS)

#  if defined (_STLP_ATOMIC_EXCHANGE)

   int _M_incr() { return _STLP_ATOMIC_INCREMENT(&_M_ref_count); }

   int _M_decr() { return _STLP_ATOMIC_DECREMENT(&_M_ref_count); }

#  else

  int _M_incr() {

    _STLP_auto_lock l(_M_mutex);

    return ++_M_ref_count;

  }

  int _M_decr() {

    _STLP_auto_lock l(_M_mutex);

    return --_M_ref_count;

  }

#  endif

#else  /* No threads */

  int _M_incr() { return ++_M_ref_count; }

  int _M_decr() { return --_M_ref_count; }

#endif

};

/* Atomic swap on __stl_atomic_t

 * This is guaranteed to behave as though it were atomic only if all

 * possibly concurrent updates use _Atomic_swap.

 * In some cases the operation is emulated with a lock.

 * Idem for _Atomic_swap_ptr

 */

/* Helper struct to handle following cases:

 * - on platforms where sizeof(__stl_atomic_t) == sizeof(void*) atomic

 *   exchange can be done on pointers

 * - on platform without atomic operation swap is done in a critical section,

 *   portable but inefficient.

 */

template <int __use_ptr_atomic_swap>

class _Atomic_swap_struct {

public:

#if defined (_STLP_THREADS) && \

    !defined (_STLP_ATOMIC_EXCHANGE) && \

    (defined (_STLP_PTHREADS) || defined (_STLP_UITHREADS) || defined (_STLP_OS2THREADS) || \

     defined (_STLP_USE_PTHREAD_SPINLOCK) || defined (_STLP_NWTHREADS))

#  define _STLP_USE_ATOMIC_SWAP_MUTEX

  static _STLP_STATIC_MUTEX _S_swap_lock;

#endif

  static __stl_atomic_t _S_swap(_STLP_VOLATILE __stl_atomic_t* __p, __stl_atomic_t __q) {

#if defined (_STLP_THREADS)

#  if defined (_STLP_ATOMIC_EXCHANGE)

  return _STLP_ATOMIC_EXCHANGE(__p, __q);

#  elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX)

  _S_swap_lock._M_acquire_lock();

  __stl_atomic_t __result = *__p;

  *__p = __q;

  _S_swap_lock._M_release_lock();

  return __result;

#  else

#    error Missing atomic swap implementation

#  endif

#else

  /* no threads */

  __stl_atomic_t __result = *__p;

  *__p = __q;

  return __result;

#endif // _STLP_THREADS

  }

  static void* _S_swap_ptr(void* _STLP_VOLATILE* __p, void* __q) {

#if defined (_STLP_THREADS)

#  if defined (_STLP_ATOMIC_EXCHANGE_PTR)

  return _STLP_ATOMIC_EXCHANGE_PTR(__p, __q);

#  elif defined (_STLP_ATOMIC_EXCHANGE)

  _STLP_STATIC_ASSERT(sizeof(__stl_atomic_t) == sizeof(void*))

  return __REINTERPRET_CAST(void*, _STLP_ATOMIC_EXCHANGE(__REINTERPRET_CAST(volatile __stl_atomic_t*, __p),

                                                         __REINTERPRET_CAST(__stl_atomic_t, __q));

#  elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX)

  _S_swap_lock._M_acquire_lock();

  void *__result = *__p;

  *__p = __q;

  _S_swap_lock._M_release_lock();

  return __result;

#  else

#    error Missing pointer atomic swap implementation

#  endif

#else

  /* no thread */

  void *__result = *__p;

  *__p = __q;

  return __result;

#endif

  }

};

_STLP_TEMPLATE_NULL

class _Atomic_swap_struct<0> {

public:

#if defined (_STLP_THREADS) && \

    (!defined (_STLP_ATOMIC_EXCHANGE) || !defined (_STLP_ATOMIC_EXCHANGE_PTR)) && \

    (defined (_STLP_PTHREADS) || defined (_STLP_UITHREADS) || defined (_STLP_OS2THREADS) || \

     defined (_STLP_USE_PTHREAD_SPINLOCK) || defined (_STLP_NWTHREADS))

#  define _STLP_USE_ATOMIC_SWAP_MUTEX

  static _STLP_STATIC_MUTEX _S_swap_lock;

#endif

  static __stl_atomic_t _S_swap(_STLP_VOLATILE __stl_atomic_t* __p, __stl_atomic_t __q) {

#if defined (_STLP_THREADS)

#  if defined (_STLP_ATOMIC_EXCHANGE)

  return _STLP_ATOMIC_EXCHANGE(__p, __q);

#  elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX)

  /* This should be portable, but performance is expected

   * to be quite awful.  This really needs platform specific

   * code.

   */

  _S_swap_lock._M_acquire_lock();

  __stl_atomic_t __result = *__p;

  *__p = __q;

  _S_swap_lock._M_release_lock();

  return __result;

#  else

#    error Missing atomic swap implementation

#  endif

#else

  /* no threads */

  __stl_atomic_t __result = *__p;

  *__p = __q;

  return __result;

#endif // _STLP_THREADS

  }

  static void* _S_swap_ptr(void* _STLP_VOLATILE* __p, void* __q) {

#if defined (_STLP_THREADS)

#  if defined (_STLP_ATOMIC_EXCHANGE_PTR)

  return _STLP_ATOMIC_EXCHANGE_PTR(__p, __q);

#  elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX)

  _S_swap_lock._M_acquire_lock();

  void *__result = *__p;

  *__p = __q;

  _S_swap_lock._M_release_lock();

  return __result;

#  else

#    error Missing pointer atomic swap implementation

#  endif

#else

  /* no thread */

  void *__result = *__p;

  *__p = __q;

  return __result;

#endif

  }

};

#if defined (_STLP_MSVC) && (_STLP_MSVC == 1300)

#  pragma warning (push)

#  pragma warning (disable : 4189) //__use_ptr_atomic_swap initialized but not used

#endif

inline __stl_atomic_t _STLP_CALL _Atomic_swap(_STLP_VOLATILE __stl_atomic_t * __p, __stl_atomic_t __q) {

  const int __use_ptr_atomic_swap = sizeof(__stl_atomic_t) == sizeof(void*);

  return _Atomic_swap_struct<__use_ptr_atomic_swap>::_S_swap(__p, __q);

}

inline void* _STLP_CALL _Atomic_swap_ptr(void* _STLP_VOLATILE* __p, void* __q) {

  const int __use_ptr_atomic_swap = sizeof(__stl_atomic_t) == sizeof(void*);

  return _Atomic_swap_struct<__use_ptr_atomic_swap>::_S_swap_ptr(__p, __q);

}

#if defined (_STLP_MSVC) && (_STLP_MSVC == 1300)

#  pragma warning (pop)

#endif

#if defined (_STLP_BETHREADS)

template <int __inst>

struct _STLP_beos_static_lock_data {

  static bool is_init;

  struct mutex_t : public _STLP_mutex {

    mutex_t()

    { _STLP_beos_static_lock_data<0>::is_init = true; }

    ~mutex_t()

    { _STLP_beos_static_lock_data<0>::is_init = false; }

  };

  static mutex_t mut;

};

template <int __inst>

bool _STLP_beos_static_lock_data<__inst>::is_init = false;

template <int __inst>

typename _STLP_beos_static_lock_data<__inst>::mutex_t _STLP_beos_static_lock_data<__inst>::mut;

inline void _STLP_mutex_base::_M_acquire_lock() {

  if (sem == 0) {

    // we need to initialise on demand here

    // to prevent race conditions use our global

    // mutex if it's available:

    if (_STLP_beos_static_lock_data<0>::is_init) {

      _STLP_auto_lock al(_STLP_beos_static_lock_data<0>::mut);

      if (sem == 0) _M_initialize();

    }

    else {

      // no lock available, we must still be

      // in startup code, THERE MUST BE ONE THREAD

      // ONLY active at this point.

      _M_initialize();

    }

  }

  status_t t;

  t = acquire_sem(sem);

  assert(t == B_NO_ERROR);

}

#endif

_STLP_END_NAMESPACE

#if !defined (_STLP_LINK_TIME_INSTANTIATION)

#  include <stl/_threads.c>

#endif

#endif /* _STLP_INTERNAL_THREADS_H */

// Local Variables:

// mode:C++

// End: