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.
/*
* 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.
// Stl_config.h should be included before this file.
#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_CONFIG_H
#include <stl/_config.h>
#endif
# if ! defined (_STLP_CSTDDEF)
# include <cstddef>
# endif
# if ! defined (_STLP_CSTDLIB)
# include <cstdlib>
# 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
# if defined (_STLP_WIN32) || defined (__sgi) || defined (_STLP_SPARC_SOLARIS_THREADS)
typedef long __stl_atomic_t;
# else
# 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_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 (__GNUC__) && defined (__i386__) && defined (__unix__) && defined (_STLP_USE_INLINE_X86_SPINLOCK)
// gcc on i386 linux, freebsd, etc.
// This enables the memory caching on x86 linux. It is critical for SMP
// without it the performace is DISMAL!
static inline unsigned long __xchg(volatile __stl_atomic_t* target, int source)
{
// The target is refernce in memory rather than the register
// because making a copy of it from memory to the register and
// back again would ruin the atomic nature of the call.
// the source does not need to be delt with atomicly so it can
// be copied about as needed.
//
// The casting of the source is used to prevent gcc from optimizing
// in such a way that breaks the atomic nature of this call.
//
__asm__ __volatile__("xchgl %1,%0"
:"=m" (*(volatile long *) target), "=r" (source)
:"m" (*(volatile long *) target), "r" (source) );
return source;
// The assembly above does the following atomicly:
// int temp=source;
// source=(int)(*target);
// (int)(*target)=temp;
// return source
}
static inline void __inc_and_fetch(volatile __stl_atomic_t* __x)
{
// Referenced in memory rather than register to preserve the atomic nature.
//
__asm__ __volatile__(
"lock; incl %0"
:"=m" (*__x)
:"m" (*__x) );
// The assembly above does the following atomicly:
// ++(int)(*__x);
}
static inline void __dec_and_fetch(volatile __stl_atomic_t* __x)
{
// Referenced in memory rather than register to preserve the atomic nature.
//
__asm__ __volatile__(
"lock; decl %0"
:"=m" (*__x)
:"m" (*__x) );
// The assembly above does the following atomicly:
// --(int)(*__x);
}
# define _STLP_ATOMIC_EXCHANGE(target, newValue) ((__xchg(target, newValue)))
# define _STLP_ATOMIC_INCREMENT(__x) __inc_and_fetch(__x)
# define _STLP_ATOMIC_DECREMENT(__x) __dec_and_fetch(__x)
# elif defined(_STLP_PTHREADS)
# include <pthread.h>
# ifndef _STLP_USE_PTHREAD_SPINLOCK
# if defined(PTHREAD_MUTEX_INITIALIZER) && !defined(_STLP_MUTEX_INITIALIZER)
# 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
# endif // !_STLP_USE_PTHREAD_SPINLOCK
# elif defined(_STLP_WIN32THREADS)
# if !defined (_STLP_WINDOWS_H_INCLUDED) && ! defined (_WINDOWS_H)
# if ! (defined ( _STLP_MSVC ) || defined (__BORLANDC__) || defined (__ICL) || defined (__WATCOMC__) || defined (__MINGW32__) || defined (__DMC__))
# ifdef _STLP_USE_MFC
# include <afx.h>
# else
# include <windows.h>
# endif
# define _STLP_WINDOWS_H_INCLUDED
# else
// This section serves as a replacement for windows.h header for Visual C++
extern "C" {
# if (defined(_M_MRX000) || defined(_M_ALPHA) \
|| (defined(_M_PPC) && (_MSC_VER >= 1000))) && !defined(RC_INVOKED)
# define InterlockedIncrement _InterlockedIncrement
# define InterlockedDecrement _InterlockedDecrement
# define InterlockedExchange _InterlockedExchange
# define _STLP_STDCALL
# else
# ifdef _MAC
# define _STLP_STDCALL _cdecl
# else
# define _STLP_STDCALL __stdcall
# endif
# endif
#if (_MSC_VER >= 1300) || defined (_STLP_NEW_PLATFORM_SDK)
_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedIncrement(long volatile *);
_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedDecrement(long volatile *);
_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedExchange(long volatile *, long);
#else
// boris : for the latest SDK, you may actually need the other version of the declaration (above)
// even for earlier VC++ versions. There is no way to tell SDK versions apart, sorry ...
_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedIncrement(long*);
_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedDecrement(long*);
_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedExchange(long*, long);
#endif
_STLP_IMPORT_DECLSPEC void _STLP_STDCALL Sleep(unsigned long);
_STLP_IMPORT_DECLSPEC void _STLP_STDCALL OutputDebugStringA( const char* lpOutputString );
#ifdef _STLP_DEBUG
typedef unsigned long DWORD;
_STLP_IMPORT_DECLSPEC DWORD _STLP_STDCALL GetCurrentThreadId();
#endif /* _STLP_DEBUG */
# if defined (InterlockedIncrement)
# pragma intrinsic(_InterlockedIncrement)
# pragma intrinsic(_InterlockedDecrement)
# pragma intrinsic(_InterlockedExchange)
# endif
} /* extern "C" */
# endif /* STL_MSVC */
# define _STLP_WINDOWS_H_INCLUDED
# endif /* _STLP_WIN32 */
# ifndef _STLP_ATOMIC_INCREMENT
# define _STLP_ATOMIC_INCREMENT(__x) InterlockedIncrement((long*)__x)
# define _STLP_ATOMIC_DECREMENT(__x) InterlockedDecrement((long*)__x)
# define _STLP_ATOMIC_EXCHANGE(__x, __y) InterlockedExchange((long*)__x, (long)__y)
# 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.
# include <ctime>
# if defined (_STLP_USE_NAMESPACES) && ! defined (_STLP_VENDOR_GLOBAL_CSTD)
using _STLP_VENDOR_CSTD::time_t;
# endif
# include <synch.h>
# include <cstdio>
# include <stl/_cwchar.h>
# elif defined (_STLP_BETHREADS)
# include <OS.h>
#include <cassert>
#include <stdio.h>
# define _STLP_MUTEX_INITIALIZER = { 0 }
#elif defined(_STLP_OS2THREADS)
# ifdef __GNUC__
# define INCL_DOSSEMAPHORES
# include <os2.h>
# else
// This section serves to replace os2.h for VisualAge C++
typedef unsigned long ULONG;
#ifndef __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 */
# elif defined(_STLP_VXWORKS_THREADS)
# include "semLib.h"
# endif
# ifndef _STLP_MUTEX_INITIALIZER
# if defined(_STLP_ATOMIC_EXCHANGE)
// we are using our own spinlock.
# define _STLP_MUTEX_INITIALIZER = { 0 }
# elif defined(_STLP_UITHREADS)
// known case
# define _STLP_MUTEX_INITIALIZER = { DEFAULTMUTEX }
# else
// we do not have static initializer available. therefore, on-demand synchronization is needed.
# define _STLP_MUTEX_INITIALIZER
# define _STLP_MUTEX_NEEDS_ONDEMAND_INITIALIZATION
# endif
# endif
_STLP_BEGIN_NAMESPACE
#ifndef _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
#ifdef _STLP_THREADS
# ifdef _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)
# ifdef _STLP_USE_PTHREAD_SPINLOCK
pthread_spinlock_t _M_lock;
inline void _M_initialize() { pthread_spin_init( &_M_lock, 0 ); }
inline void _M_destroy() { pthread_spin_destroy( &_M_lock ); }
inline void _M_acquire_lock() {
// we do not care about race conditions here : there is only one thread at this point
if(!_M_lock) pthread_spin_init( &_M_lock, 0 );
// fbp: here, initialization on demand should happen before the lock
// we use simple strategy as we are sure this only happens on initialization
pthread_spin_lock( &_M_lock );
}
inline void _M_acquire_lock_nodemand() {
pthread_spin_lock( &_M_lock );
}
inline void _M_release_lock() { pthread_spin_unlock( &_M_lock ); }
# 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_nodemand() {
pthread_mutex_lock(&_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_nodemand() {
DosRequestMutexSem(_M_lock, SEM_INDEFINITE_WAIT);
}
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_nodemand()
{
status_t t;
t = acquire_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_VXWORKS_THREADS)
SEM_ID _M_sem;
inline void _M_initialize()
{
_M_sem = semMCreate(SEM_Q_FIFO);
assert(_M_sem > 0);
}
inline void _M_destroy()
{
STATUS __s;
semDelete (_M_sem);
assert(__s == OK);
}
inline void _M_acquire_lock_nodemand()
{
STATUS __s;
semTake (_M_sem, WAIT_FOREVER);
assert(__s == OK);
}
inline void _M_acquire_lock()
{
if (!_M_sem)
_M_initialize();
_M_acquire_lock_nodemand();
}
inline void _M_release_lock()
{
STATUS __s;
semGive (_M_sem, WAIT_FOREVER);
assert(__s == OK);
}
# 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
};
#if defined (_STLP_THREADS) && defined (_STLP_MUTEX_NEEDS_ONDEMAND_INITIALIZATION)
// for use in _STLP_mutex, our purposes do not require ondemand initialization
// also, mutex_base may use some hacks to determine uninitialized state by zero data, which only works for globals.
class _STLP_CLASS_DECLSPEC _STLP_mutex_nodemand : public _STLP_mutex_base {
inline void _M_acquire_lock() {
_M_acquire_lock_nodemand();
}
};
#else
typedef _STLP_mutex_base _STLP_mutex_nodemand;
#endif
// 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_nodemand {
public:
inline _STLP_mutex () { _M_initialize(); }
inline ~_STLP_mutex () { _M_destroy(); }
private:
_STLP_mutex(const _STLP_mutex&);
void operator=(const _STLP_mutex&);
};
/*
* 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.
*/
struct _STLP_CLASS_DECLSPEC _Refcount_Base
{
// The data member _M_ref_count
volatile __stl_atomic_t _M_ref_count;
# if !defined (_STLP_ATOMIC_EXCHANGE)
_STLP_mutex _M_mutex;
# endif
// Constructor
_Refcount_Base(__stl_atomic_t __n) : _M_ref_count(__n) {}
// _M_incr and _M_decr
# if defined (_STLP_THREADS) && defined (_STLP_ATOMIC_EXCHANGE)
void _M_incr() { _STLP_ATOMIC_INCREMENT((__stl_atomic_t*)&_M_ref_count); }
void _M_decr() { _STLP_ATOMIC_DECREMENT((__stl_atomic_t*)&_M_ref_count); }
# elif defined(_STLP_THREADS)
void _M_incr() {
_M_mutex._M_acquire_lock();
++_M_ref_count;
_M_mutex._M_release_lock();
}
void _M_decr() {
_M_mutex._M_acquire_lock();
--_M_ref_count;
_M_mutex._M_release_lock();
}
# else /* No threads */
void _M_incr() { ++_M_ref_count; }
void _M_decr() { --_M_ref_count; }
# endif
};
// Atomic swap on unsigned long
// 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.
# if defined (_STLP_THREADS)
# ifdef _STLP_ATOMIC_EXCHANGE
inline __stl_atomic_t _Atomic_swap(volatile __stl_atomic_t * __p, __stl_atomic_t __q) {
return (__stl_atomic_t) _STLP_ATOMIC_EXCHANGE(__p,__q);
}
# elif defined(_STLP_PTHREADS) || defined (_STLP_UITHREADS) || defined (_STLP_OS2THREADS) || defined(_STLP_USE_PTHREAD_SPINLOCK)
// We use a template here only to get a unique initialized instance.
template<int __dummy>
struct _Swap_lock_struct {
static _STLP_STATIC_MUTEX _S_swap_lock;
};
// This should be portable, but performance is expected
// to be quite awful. This really needs platform specific
// code.
inline __stl_atomic_t _Atomic_swap(volatile __stl_atomic_t * __p, __stl_atomic_t __q) {
_Swap_lock_struct<0>::_S_swap_lock._M_acquire_lock();
__stl_atomic_t __result = *__p;
*__p = __q;
_Swap_lock_struct<0>::_S_swap_lock._M_release_lock();
return __result;
}
# endif // _STLP_PTHREADS || _STLP_UITHREADS || _STLP_OS2THREADS || _STLP_USE_PTHREAD_SPINLOCK
# else // !_STLP_THREADS
/* no threads */
static inline __stl_atomic_t _STLP_CALL
_Atomic_swap(volatile __stl_atomic_t * __p, __stl_atomic_t __q) {
__stl_atomic_t __result = *__p;
*__p = __q;
return __result;
}
# endif // _STLP_THREADS
// 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.
struct _STLP_CLASS_DECLSPEC _STLP_auto_lock
{
_STLP_STATIC_MUTEX& _M_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:
void operator=(const _STLP_auto_lock&);
_STLP_auto_lock(const _STLP_auto_lock&);
};
typedef _STLP_auto_lock _STLP_mutex_lock;
#ifdef _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();
}
}
_M_acquire_lock_nodemand();
}
#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: