/*

  *

  * Copyright (c) 1994

  * Hewlett-Packard Company

  *

  * Copyright (c) 1996,1997

  * Silicon Graphics Computer Systems, Inc.

  *

  * Copyright (c) 1997

  * Moscow Center for SPARC Technology

  *

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

  *

  */

#ifndef _STLP_FEATURES_H

#define _STLP_FEATURES_H

/*

 * Purpose of this file:

 *

 * Defines all STLport settings.

 * This file is actually a wrapper : it includes compiler-specific

 * settings from <config/stlcomp.h>

 * and user-defined settings from <stl_user_config.h>.

 * See <config/stl_mycomp.h> and <stl_user_config.h> for the description

 * of those macros

 *

 */

/* Definition of the STLport version informations */

#include <stl/_stlport_version.h>

/* Other macros defined by this file:

 * bool, true, and false, if _STLP_NO_BOOL is defined.

 * typename, as a null macro if it's not already a keyword.

 * explicit, as a null macro if it's not already a keyword.

 * namespace-related macros (_STLP_STD, _STLP_BEGIN_NAMESPACE, etc.)

 * exception-related macros (_STLP_TRY, _STLP_UNWIND, etc.)

 * _STLP_ASSERT, either as a test or as a null macro, depending on

   whether or not _STLP_ASSERTIONS is defined.

*/

/* Definition of the 2 STLport debug levels */

#define _STLP_STLPORT_DBG_LEVEL 1

#define _STLP_STANDARD_DBG_LEVEL 2

/* Placeholder for user to override settings.

 * It could be also used to mask settings from

 * different directories.

 */

#include <stl/config/user_config.h>

#if defined (_STLP_DEBUG) && !defined (_STLP_DEBUG_LEVEL)

#  define _STLP_DEBUG_LEVEL _STLP_STLPORT_DBG_LEVEL

#endif

#if defined (__BUILDING_STLPORT)

/* For the STLport implementation we can use everything:

 */

#  if defined (_STLP_NO_ANACHRONISMS)

#    undef _STLP_NO_ANACHRONISMS

#  endif

#  if defined (_STLP_NO_EXTENSIONS)

#    undef _STLP_NO_EXTENSIONS

#  endif

/* Moreover there are things that has no sens:

 */

#  if defined (_STLP_NO_IOSTREAMS)

#    error If you do not use iostreams you do not need to build the STLport library.

#  endif

#endif

/* ========================================================= */

/* This file is used for compatibility; it accepts old-style config

   switches */

#include <stl/config/compat.h>

/* Common configuration file for this particular installation. */

#include <stl/config/host.h>

/* Operational Environment specific */

#include <stl/config/_system.h>

/* ========================================================= */

/* some fixes to configuration. This also includes modifications

 * of STLport switches depending on compiler flags,

 * or settings applicable to a group of compilers, such as

 * to all who use EDG front-end.

 */

#include <stl/config/stl_confix.h>

#ifdef _STLP_USE_BOOST_SUPPORT

/* We are going to use the boost library support. To limit the problem

 * of self referencing headers we have to specify clearly to the boost

 * library that the Standard lib is STLport:

 */

#  ifndef BOOST_STDLIB_CONFIG

#    define BOOST_STDLIB_CONFIG <boost/config/stdlib/stlport.hpp>

#  endif

#endif

/*

 * Performs integrity check on user-specified parameters

 * and site-specific settings.

 */

/*

# include <stl/_check_config.h>

*/

/* SGI terms */

#if !defined (_STLP_NO_MEMBER_TEMPLATES) && !defined (_STLP_MEMBER_TEMPLATES)

#  define _STLP_MEMBER_TEMPLATES 1

#endif

#if !defined (_STLP_NO_FRIEND_TEMPLATES) && !defined (_STLP_FRIEND_TEMPLATES)

#  define _STLP_FRIEND_TEMPLATES 1

#endif

#if !defined (_STLP_NO_MEMBER_TEMPLATE_CLASSES) && !defined (_STLP_MEMBER_TEMPLATE_CLASSES)

#  define _STLP_MEMBER_TEMPLATE_CLASSES 1

#endif

#if defined (_STLP_NO_MEMBER_TEMPLATE_CLASSES) && !defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)

#  define _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE 1

#endif

#if !defined (_STLP_NO_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)

#  define _STLP_CLASS_PARTIAL_SPECIALIZATION 1

#endif

#if !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) && !defined (_STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER)

#  define _STLP_FUNCTION_TMPL_PARTIAL_ORDER 1

#endif

#if !defined (_STLP_DONT_USE_SHORT_STRING_OPTIM) && !defined (_STLP_USE_SHORT_STRING_OPTIM)

#  define _STLP_USE_SHORT_STRING_OPTIM 1

#endif

#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_NO_EXTENSIONS) && \

   !defined (_STLP_NO_CONTAINERS_EXTENSION) && !defined (_STLP_USE_CONTAINERS_EXTENSION)

#  define _STLP_USE_CONTAINERS_EXTENSION

#endif

#if defined (_STLP_USE_CONTAINERS_EXTENSION)

#  define _STLP_TEMPLATE_FOR_CONT_EXT template <class _KT>

#else

#  define _STLP_TEMPLATE_FOR_CONT_EXT

#endif

#if defined (_STLP_USE_PTR_SPECIALIZATIONS) && \

    (defined (_STLP_NO_CLASS_PARTIAL_SPECIALIZATION) && defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS))

#  error "Sorry but according the STLport settings your compiler can not support the pointer specialization feature."

#endif

#if defined (_STLP_NO_IOSTREAMS) && \

   !defined (_STLP_USE_NEWALLOC) && !defined (_STLP_USE_MALLOC)

#  define _STLP_USE_NEWALLOC

#endif

#if !defined (_STLP_BIG_ENDIAN) && !defined (_STLP_LITTLE_ENDIAN)

#  if defined (_MIPSEB) || defined (__sparc) || defined (_AIX) || \

      defined (__hpux) || defined (macintosh) || defined (_MAC)

#    define _STLP_BIG_ENDIAN 1

#  elif defined (__i386) || defined (_M_IX86) || defined (_M_ARM) || \

        defined (__amd64__) || defined (_M_AMD64) || defined (__x86_64__) || \

        defined (__alpha__)

#    define _STLP_LITTLE_ENDIAN 1

#  elif defined (__ia64__)

    /* itanium allows both settings (for instance via gcc -mbig-endian) - hence a seperate check is required */

#    if defined (__BIG_ENDIAN__)

#      define _STLP_BIG_ENDIAN 1

#    else

#      define _STLP_LITTLE_ENDIAN 1

#    endif

#  else

#    error "can't determine endianess"

#  endif

#endif /* _STLP_BIG_ENDIAN */

/* ==========================================================

 * final workaround tuning based on given flags

 * ========================================================== */

#ifndef _STLP_UINT32_T

#  define _STLP_UINT32_T unsigned long

#endif

#ifndef _STLP_ABORT

#  define _STLP_ABORT() abort()

#endif

#if !defined (_STLP_HAS_NO_NAMESPACES)

#  if defined _STLP_NO_NAMESPACES

#    undef _STLP_USE_NAMESPACES

#  else

/* assume it as the default, turn it off later if NO_NAMESPACES selected */

#    undef _STLP_USE_NAMESPACES

#    define _STLP_USE_NAMESPACES 1

#  endif

#endif

#if defined (_STLP_NO_IOSTREAMS)

#  define _STLP_USE_NO_IOSTREAMS

#endif

/* Operating system recognition (basic) */

#if defined (__unix) || defined (__linux__) || defined (__QNX__) || defined (_AIX)  || defined (__NetBSD__) || defined(__OpenBSD__) || defined (__Lynx__)

#  define _STLP_UNIX 1

#elif defined(macintosh) || defined (_MAC)

#  define _STLP_MAC  1

#elif defined (_WIN32) || defined (__WIN32) || defined (WIN32) || defined (__WIN32__)

#  define _STLP_WIN32 1

#elif defined (__WIN16) || defined (WIN16) || defined (_WIN16)

#  define _STLP_WIN16

#endif /* __unix */

#if defined (_STLP_WIN16)

#  define _STLP_LDOUBLE_80

#elif defined(_STLP_WIN32)

#  if defined (_STLP_MSVC) || defined (__ICL) || defined (__BORLANDC__) || defined (__CYGWIN__)

#    define _STLP_LDOUBLE_64

#  else

#    define _STLP_LDOUBLE_96

#  endif

#elif defined (_STLP_UNIX)

#  if defined (__CYGWIN__)

#    define _STLP_LDOUBLE_96

#  endif

#endif

#if !defined (_STLP_LDOUBLE_64) && !defined (_STLP_LDOUBLE_80) && !defined (_STLP_LDOUBLE_96) && !defined (_STLP_LDOUBLE_128)

#  define _STLP_LDOUBLE_128

#endif

#if !defined (_STLP_NO_LONG_DOUBLE)

#  define _STLP_LONGEST_FLOAT_TYPE long double

#else

#  define _STLP_LONGEST_FLOAT_TYPE double

#endif

/* Native headers access macros */

#include <stl/config/_native_headers.h>

/*  shared library tune-up */

#if defined (__BUILDING_STLPORT)

/*  if we are rebuilding right now, place everything here */

#  undef  _STLP_DESIGNATED_DLL

#  define _STLP_DESIGNATED_DLL 1

#endif

/* Use own namespace always if possible and not explicitly instructed otherwise */

#if defined (_STLP_USE_NAMESPACES) && !defined (_STLP_BROKEN_USING_DIRECTIVE) && \

   !defined (_STLP_NO_OWN_NAMESPACE)

#  undef  _STLP_USE_OWN_NAMESPACE

#  define _STLP_USE_OWN_NAMESPACE  1

#else

#  undef _STLP_WHOLE_NATIVE_STD

#endif

#if !defined (_NOTHREADS) && !defined (_STLP_THREADS_DEFINED)

#  if defined (_PTHREADS)

#    define _STLP_PTHREADS

#    define _STLP_THREADS

#  endif

#  if defined (_UITHREADS)

#    define _STLP_UITHREADS

#    define _STLP_THREADS

#  endif

#  if defined (__sgi) && !defined (__KCC) && !defined (__GNUC__)

#    define _STLP_SGI_THREADS

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

#    define _STLP_DEC_THREADS

#  elif defined (_STLP_WIN32) && !defined (_STLP_PTHREADS)

#    define _STLP_WIN32THREADS 1

#  elif ((defined (__sun) && !defined (__linux__)) || defined (_UITHREADS) ) && \

        !defined(_STLP_PTHREADS)

#    define _STLP_UITHREADS

#  elif defined (__OS2__)

#    define _STLP_OS2THREADS

#  elif defined (__BEOS__)

#    define _STLP_BETHREADS

#  elif defined (__MWERKS__) && defined (N_PLAT_NLM) /* (__dest_os == __netware_os) */

#    define _STLP_NWTHREADS

#  else

#    define _STLP_PTHREADS

#  endif /* __sgi */

#  define _STLP_THREADS_DEFINED

#endif

#if (defined (_REENTRANT) || defined (_THREAD_SAFE) || \

    (defined (_POSIX_THREADS) && defined (__OpenBSD__))) && \

    !defined (_STLP_THREADS)

#  define _STLP_THREADS

#endif /* _REENTRANT */

#if defined (__linux__) && defined (_STLP_PTHREADS)

/* #  include <features.h> */

#  if defined (__USE_XOPEN2K) && !defined (_STLP_DONT_USE_PTHREAD_SPINLOCK)

#    define _STLP_USE_PTHREAD_SPINLOCK

#    define _STLP_STATIC_MUTEX _STLP_mutex

#  endif /* __USE_XOPEN2K */

#endif /* __linux__ && _STLP_PTHREADS */

#if defined (__OpenBSD__) && defined (_POSIX_THREADS) && !defined (_STLP_DONT_USE_PTHREAD_SPINLOCK)

#  define _STLP_USE_PTHREAD_SPINLOCK

#  define _STLP_STATIC_MUTEX _STLP_mutex

#endif

#ifndef _STLP_STATIC_MUTEX

#  define _STLP_STATIC_MUTEX _STLP_mutex_base

#endif

#if (defined (_MFC_VER) || defined (_AFXDLL)) && !defined (_STLP_USE_MFC)

#  define _STLP_USE_MFC 1

#endif

#if defined (_STLP_THREADS)

#  define _STLP_VOLATILE volatile

/* windows.h _MUST be included before bool definition ;( */

#  if defined (_STLP_WIN32THREADS) && defined (_STLP_NO_BOOL)

#    undef  NOMINMAX

#    define NOMINMAX

#    ifdef _STLP_USE_MFC

#      include <afx.h>

#    else

#      include <windows.h>

#    endif

#    define _STLP_WINDOWS_H_INCLUDED

#  endif

#else

#  define _STLP_VOLATILE

#endif

#if !defined (_STLP_USE_NEW_C_HEADERS) && !defined (_STLP_HAS_NO_NEW_C_HEADERS)

#  define _STLP_USE_NEW_C_HEADERS

#endif

/* disable new-style headers if requested */

#if defined (_STLP_NO_NEW_C_HEADERS)

#  undef _STLP_USE_NEW_C_HEADERS

#endif

#if !defined (_STLP_STATIC_TEMPLATE_DATA)

#  define _STLP_STATIC_TEMPLATE_DATA 1

#endif

#if defined (_STLP_BASE_TYPEDEF_BUG)

#  undef  _STLP_BASE_TYPEDEF_OUTSIDE_BUG

#  define _STLP_BASE_TYPEDEF_OUTSIDE_BUG 1

#endif

#if defined (_STLP_NESTED_TYPE_PARAM_BUG) || (defined (_STLP_MSVC) && (_STLP_MSVC < 1100))

#  define _STLP_GLOBAL_NESTED_RETURN_TYPE_PARAM_BUG

#endif

/* SUNpro 4.2 inline string literal bug */

#ifdef _STLP_INLINE_STRING_LITERAL_BUG

#  define _STLP_FIX_LITERAL_BUG(__x) __x = __x;

#else

#  define _STLP_FIX_LITERAL_BUG(__x)

#endif

#if defined (_STLP_NON_TYPE_TMPL_PARAM_BUG)

#  undef  _STLP_NO_DEFAULT_NON_TYPE_PARAM

#  define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1

#endif

#define _STLP_NEW new

#define _STLP_PLACEMENT_NEW new

#ifdef _STLP_DEBUG

#  define _STLP_ASSERTIONS 1

#endif

#if !defined (_STLP_STATIC_ASSERT)

/* Some compiler support 0 size array so we use negative size array to generate

 * a compilation time error.

 */

#  define _STLP_STATIC_ASSERT(expr) typedef char __static_assert[expr ? 1 : -1];

#endif

/* apple mpw exception handling bug */

#ifndef _STLP_MPWFIX_TRY

#  define _STLP_MPWFIX_TRY

#endif

#ifndef _STLP_MPWFIX_CATCH

#  define _STLP_MPWFIX_CATCH

#endif

#ifndef _STLP_MPWFIX_CATCH_ACTION

#  define _STLP_MPWFIX_CATCH_ACTION(action)

#endif

/* if _STLP_DEBUG or _STLP_ASSERTIONS are set, stl/debug/_debug.h defines those */

#if !defined (_STLP_ASSERTIONS) && !defined (_STLP_DEBUG) && !defined (_STLP_DEBUG_ALLOC)

#  define _STLP_ASSERT(expr)

#endif

#if !defined (_STLP_DEBUG)

#  define _STLP_VERBOSE_ASSERT(expr,diagnostic)

#  define _STLP_DEBUG_CHECK(expr)

#  define _STLP_DEBUG_DO(expr)

#endif

#if !defined (_STLP_WEAK)

#  define _STLP_WEAK

#endif

/* default parameters as template types derived from arguments ( not always supported ) */

#if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)

#  define _STLP_DFL_TMPL_PARAM( classname, defval ) class classname

#else

#  if !defined (_STLP_DEFAULT_TYPE_PARAM)

#    define _STLP_DEFAULT_TYPE_PARAM 1

#  endif

#  define _STLP_DFL_TMPL_PARAM( classname, defval ) class classname = defval

#endif

/* default parameters as complete types */

#if defined (_STLP_DEFAULT_TYPE_PARAM)

#  define _STLP_DFL_TYPE_PARAM( classname, defval ) class classname = defval

#  define _STLP_DFL_NON_TYPE_PARAM(type,name,val) type name = val

#else

#  define _STLP_DFL_TYPE_PARAM( classname, defval ) class classname

#  define _STLP_DFL_NON_TYPE_PARAM(type,name,val) type name

#endif

/* SGI compatibility */

#ifdef _STLP_NO_WCHAR_T

#  ifndef _STLP_NO_NATIVE_WIDE_STREAMS

#    define  _STLP_NO_NATIVE_WIDE_STREAMS 1

#  endif

#else

#  define _STLP_HAS_WCHAR_T 1

#endif

#if !defined (_STLP_NO_AT_MEMBER_FUNCTION)

#  define _STLP_CAN_THROW_RANGE_ERRORS 1

#endif

#if !defined (_STLP_USE_RAW_SGI_ALLOCATORS)

#  define _STLP_DEFAULT_ALLOCATOR(_Tp) allocator< _Tp >

#  define _STLP_DEFAULT_ALLOCATOR_SELECT( _Tp ) _STLP_DFL_TMPL_PARAM(_Alloc, allocator< _Tp >)

#  define _STLP_DEFAULT_PAIR_ALLOCATOR(_Key, _Tp) allocator< pair < _Key, _Tp > >

#  if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)

#    define _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_Key, _Tp ) class _Alloc

#    define _STLP_USE_WRAPPER_FOR_ALLOC_PARAM 1

#  else

#    define _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_Key, _Tp ) \

            class _Alloc = allocator< pair < _Key, _Tp > >

#  endif

#else

#  define _STLP_DEFAULT_ALLOCATOR( _Tp ) __sgi_alloc

#  define _STLP_DEFAULT_ALLOCATOR_SELECT( _Tp ) _STLP_DFL_TYPE_PARAM(_Alloc,__sgi_alloc)

#  define _STLP_DEFAULT_PAIR_ALLOCATOR( _Key, _Tp ) __sgi_alloc

#  define _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_Key, _Tp ) _STLP_DFL_TYPE_PARAM(_Alloc,__sgi_alloc)

#  if defined (_STLP_LIMITED_DEFAULT_TEMPLATES) && !defined (_STLP_DEFAULT_TYPE_PARAM)

#    define _STLP_USE_WRAPPER_FOR_ALLOC_PARAM 1

#  endif

#endif

/* debug mode tool */

#if defined (_STLP_DEBUG)

#  define _STLP_NON_DBG_NAME(X) _NonDbg_##X

#endif

/* pointer specialization tool */

#if defined (_STLP_USE_PTR_SPECIALIZATIONS)

#  define _STLP_PTR_IMPL_NAME(X) _Impl_##X

#endif

#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)

#  define _STLP_NO_MEM_T_NAME(X) _NoMemT_##X

#  if defined (_STLP_DEBUG)

#    define _STLP_NON_DBG_NO_MEM_T_NAME(X) _NonDbg_NoMemT_##X

#  endif

#endif

/* this always mean the C library is in global namespace */

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

#  define _STLP_VENDOR_GLOBAL_CSTD 1

#endif

/* Depending of whether compiler supports namespaces,

 * tune the parameters for vendor-supplied libraries.

 * This section is guarded by _STLP_HAS_NO_NAMESPACES, not by _STLP_USE_NAMESPACES,

 * since it depends only on the native features, not on user's preference whether

 * to use namespace for STLport or not.

 */

#if !defined (_STLP_HAS_NO_NAMESPACES)

/* Import some vendor's headers into corresponding STLport ones if they might be needed

 * (if we wrap native iostreams and use namepace other than std::) */

#  if defined (_STLP_WHOLE_NATIVE_STD)

#    define  _STLP_IMPORT_VENDOR_STD 1

#    undef   _STLP_MINIMUM_IMPORT_STD

#  endif

/* if using stlport:: namespace or if C library stuff is not in vendor's std::,

 * try importing 'em.

 * MSVC has ambiguity problem when we try to import C-style std:: stuff back into global namespace */

#  if defined (_STLP_USE_NAMESPACES) && (defined(_STLP_USE_OWN_NAMESPACE) || defined (_STLP_VENDOR_GLOBAL_CSTD))

#    define  _STLP_IMPORT_VENDOR_CSTD 1

#  endif

#  if defined (_STLP_NO_USING_FOR_GLOBAL_FUNCTIONS) && !defined (_STLP_DO_IMPORT_CSTD_FUNCTIONS)

#    define _STLP_NO_CSTD_FUNCTION_IMPORTS

#  endif

#  define _STLP_USING_NAMESPACE(x) using namespace x ;

namespace std { }

namespace __std_alias = std;

/* assume std:: namespace for C++ std library if not being told otherwise */

#  if defined (_STLP_VENDOR_GLOBAL_STD)

#    define _STLP_VENDOR_STD

#  else

#    define _STLP_VENDOR_STD __std_alias

#  endif

/* tune things that come from C library */

#  if  defined (_STLP_VENDOR_GLOBAL_CSTD) || !defined(_STLP_USE_NEW_C_HEADERS)

/*  in old-style headers, C functions go to global scope. */

#    define _STLP_VENDOR_CSTD

#    define _STLP_USING_VENDOR_CSTD

#  else

#    define _STLP_VENDOR_CSTD  _STLP_VENDOR_STD

#    define _STLP_USING_VENDOR_CSTD _STLP_USING_NAMESPACE(_STLP_VENDOR_CSTD)

#  endif /* _STLP_VENDOR_CSTD */

/* exception, typeinfo, new - always come from the vendor */

#  if !defined (_STLP_VENDOR_EXCEPT_STD)

#    if defined (_STLP_VENDOR_GLOBAL_EXCEPT_STD)

#      define _STLP_VENDOR_EXCEPT_STD

#    else

#      define _STLP_VENDOR_EXCEPT_STD _STLP_VENDOR_STD

#    endif

#  endif

#  define _STLP_OLD_IO_NAMESPACE

#  if !defined (_STLP_VENDOR_MB_NAMESPACE)

#    define _STLP_VENDOR_MB_NAMESPACE _STLP_VENDOR_CSTD

#  endif

#else

/* compiler has no namespace support */

#  define _STLP_VENDOR_STD

#  define _STLP_VENDOR_CSTD

#  define _STLP_USING_NAMESPACE(x)

#  define _STLP_USING_VENDOR_CSTD

#  define _STLP_VENDOR_EXCEPT_STD

#endif

#if defined (_STLP_USE_NAMESPACES)

#  if defined (_STLP_USE_OWN_NAMESPACE)

#    if !defined (_STLP_STD_NAME)

#      if !defined (_STLP_DEBUG)

#        if !defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB)

#          ifndef _STLP_THREADS

#            define _STLP_STD_NAME  stlpmtx_std

#          else

#            define _STLP_STD_NAME  stlp_std

#          endif

#        else

#          ifndef _STLP_THREADS

#            define _STLP_STD_NAME  stlpxmtx_std

#          else

#            define _STLP_STD_NAME  stlpx_std

#          endif

#        endif

#      else

/*

 * The STLport debug mode is binary incompatible with the other modes,

 * lets make it clear on the STLport namespace to generate link errors rather

 * than runtime.

 */

#        if !defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB)

#          ifndef _STLP_THREADS

#            define _STLP_STD_NAME  stlpdmtx_std

#          else

#            define _STLP_STD_NAME  stlpd_std

#          endif

#        else

#          ifndef _STLP_THREADS

#            define _STLP_STD_NAME  stlpdxmtx_std

#          else

#            define _STLP_STD_NAME  stlpdx_std

#          endif

#        endif

#      endif

#    endif

namespace _STLP_STD_NAME { }

#  else

#    if defined (_STLP_DEBUG)

namespace stdD = std;

#    endif

#    define _STLP_STD_NAME std

#  endif /* _STLP_USE_OWN_NAMESPACE */

#  if !defined (_STLP_USING_NAMESPACE_BUG)

#    define _STLP_PRIV_NAME stlp_priv

namespace _STLP_PRIV_NAME {

  using namespace _STLP_STD_NAME;

}

#  else

#    define _STLP_PRIV_NAME priv

#  endif

#  define _STLP_BEGIN_NAMESPACE namespace _STLP_STD_NAME {

#  define _STLP_END_NAMESPACE }

#  if !defined (_STLP_DONT_USE_PRIV_NAMESPACE)

#    if !defined (_STLP_USING_NAMESPACE_BUG)

/* We prefer to make private namespace a totaly seperated namespace...

 */

#      define _STLP_PRIV ::_STLP_PRIV_NAME::

#      define _STLP_MOVE_TO_PRIV_NAMESPACE } namespace _STLP_PRIV_NAME {

#      define _STLP_MOVE_TO_STD_NAMESPACE } namespace _STLP_STD_NAME {

#    else

/* but sometimes we can't:

 */

#      define _STLP_PRIV _STLP_PRIV_NAME::

#      define _STLP_MOVE_TO_PRIV_NAMESPACE namespace _STLP_PRIV_NAME {

#      define _STLP_MOVE_TO_STD_NAMESPACE }

#    endif

#  else

#    define _STLP_PRIV

#    define _STLP_MOVE_TO_PRIV_NAMESPACE

#    define _STLP_MOVE_TO_STD_NAMESPACE

#  endif

/* decide whether or not we use separate namespace for rel ops */

#  if defined (_STLP_NO_RELOPS_NAMESPACE)

#    define _STLP_BEGIN_RELOPS_NAMESPACE _STLP_BEGIN_NAMESPACE namespace rel_ops {}

#    define _STLP_END_RELOPS_NAMESPACE }

#  else

/* Use std::rel_ops namespace */

#    define _STLP_BEGIN_RELOPS_NAMESPACE _STLP_BEGIN_NAMESPACE namespace rel_ops {

#    define _STLP_END_RELOPS_NAMESPACE } }

#    define _STLP_USE_SEPARATE_RELOPS_NAMESPACE

#  endif /* Use std::rel_ops namespace */

#  define _STLP_STD ::_STLP_STD_NAME

/* Official STLport namespace when std is not redefined.

 * Here we don't use a macro as stlport is used as file name by boost

 * and folder name under beos:

 */

namespace stlport = _STLP_STD_NAME;

/* Backward compatibility:

 */

namespace _STL = _STLP_STD_NAME;

#undef __STLPORT_NAMESPACE

#define __STLPORT_NAMESPACE _STLP_STD_NAME

#else /* _STLP_USE_NAMESPACES */

/* STLport is being put into global namespace */

#  define _STLP_STD

#  define _STLP_PRIV

#  define _STLP_BEGIN_NAMESPACE

#  define _STLP_END_NAMESPACE

#  define _STLP_MOVE_TO_PRIV_NAMESPACE

#  define _STLP_MOVE_TO_STD_NAMESPACE

/* boris : it was found out that _STLP_USE_SEPARATE_RELOPS_NAMESPACE

   causes less problems than having relational operator templates in global namespace

   Please define _STLP_NO_RELOPS_NAMESPACE in stl_user_config.h if your code rely on them. */

#  if !defined (_STLP_NO_RELOPS_NAMESPACE)

#    define _STLP_USE_SEPARATE_RELOPS_NAMESPACE

#  endif

#  define _STLP_BEGIN_RELOPS_NAMESPACE

#  define _STLP_END_RELOPS_NAMESPACE

#  undef  _STLP_USE_OWN_NAMESPACE

#endif  /* _STLP_USE_NAMESPACES */

#define STLPORT_CSTD _STLP_VENDOR_CSTD

#define STLPORT      _STLP_STD_NAME

#if defined(_STLP_BOGUS_TEMPLATE_TYPE_MATCHING_BUG)

#  define _STLP_SIMPLE_TYPE(T) _stl_trivial_proxy<T>

#else

#  define _STLP_SIMPLE_TYPE(T) T

#endif

#ifndef _STLP_RAND48

#  define _STLP_NO_DRAND48

#endif

/* advanced keywords usage */

#define __C_CAST(__x, __y) ((__x)(__y))

#ifndef  _STLP_NO_NEW_STYLE_CASTS

#  define __CONST_CAST(__x,__y) const_cast<__x>(__y)

#  define __STATIC_CAST(__x,__y) static_cast<__x>(__y)

#  define __REINTERPRET_CAST(__x,__y) reinterpret_cast<__x>(__y)

#  define __DYNAMIC_CAST(__x,__y) dynamic_cast<__x>(__y)

#else

#  define __STATIC_CAST(__x,__y) __C_CAST(__x, __y)

#  define __CONST_CAST(__x,__y) __C_CAST(__x, __y)

#  define __REINTERPRET_CAST(__x,__y) __C_CAST(__x, __y)

#  define __DYNAMIC_CAST(__x,__y) __C_CAST(__x, __y)

#endif

#if defined (_STLP_NEED_TYPENAME) && ! defined (typename)

#  define typename

#endif

#if defined (_STLP_NEED_TYPENAME) || defined (_STLP_NO_TYPENAME_ON_RETURN_TYPE )

#  define _STLP_TYPENAME_ON_RETURN_TYPE

#else

#  define _STLP_TYPENAME_ON_RETURN_TYPE typename

#endif

#ifdef _STLP_NO_TYPENAME_IN_TEMPLATE_HEADER

#  define _STLP_HEADER_TYPENAME

#else

#  define _STLP_HEADER_TYPENAME typename

#endif

#ifndef _STLP_NO_MEMBER_TEMPLATE_KEYWORD

#  define _STLP_TEMPLATE template

#else

#  define _STLP_TEMPLATE

#endif

#if defined (_STLP_USE_CONTAINERS_EXTENSION)

#  define _STLP_KEY_TYPE_FOR_CONT_EXT(type)

#  define _STLP_TEMPLATE_FOR_CONT_EXT template <class _KT>

#else

#  define _STLP_KEY_TYPE_FOR_CONT_EXT(type) typedef type _KT;

#  define _STLP_TEMPLATE_FOR_CONT_EXT

#endif

#if defined (_STLP_NEED_EXPLICIT) && !defined (explicit)

#  define explicit

#endif

#if !defined (_STLP_NEED_MUTABLE)

#  define _STLP_ASSIGN_MUTABLE(type,x,y) x = y

#else

#  define _STLP_ASSIGN_MUTABLE(type,x,y) __CONST_CAST(type,x)=y

#  define mutable

#endif

#if defined (_STLP_NO_SIGNED_BUILTINS)

/* old HP-UX doesn't understand "signed" keyword */

#  define signed

#endif

#if defined (_STLP_LOOP_INLINE_PROBLEMS)

#  define _STLP_INLINE_LOOP

#else

#  define _STLP_INLINE_LOOP inline

#endif

#define _STLP_PRIVATE public

#ifndef _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX

#  define _STLP_TEMPLATE_NULL template<>

#else

#  define _STLP_TEMPLATE_NULL

#endif

#ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER

#  define _STLP_OPERATOR_TEMPLATE

#else

#  define _STLP_OPERATOR_TEMPLATE _STLP_TEMPLATE_NULL

#endif

#ifndef _STLP_CLASS_PARTIAL_SPECIALIZATION

/* unless we have other compiler problem, try simulating partial spec here */

#  if !defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)

#    define _STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS

#  endif

/* For your own iterators, please use inheritance from iterator<> instead of these obsolete queries. */

#  if  (defined (_STLP_NESTED_TYPE_PARAM_BUG) || !defined (_STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS))

#    if ! defined ( _STLP_USE_OLD_HP_ITERATOR_QUERIES )

#      define _STLP_USE_OLD_HP_ITERATOR_QUERIES

#    endif

#  elif defined ( _STLP_NO_ANACHRONISMS )

#    undef _STLP_USE_OLD_HP_ITERATOR_QUERIES

#  endif

#endif

#ifndef _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS

#  define _STLP_NULL_TMPL_ARGS <>

# else

#  define _STLP_NULL_TMPL_ARGS

#endif

#if !defined (_STLP_ALLOCATOR_TYPE_DFL)

#  if defined (_STLP_DONT_SUP_DFLT_PARAM)

#    define _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS

#  endif

#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)

#    define _STLP_ALLOCATOR_TYPE_DFL

#  else

#    define _STLP_ALLOCATOR_TYPE_DFL = allocator_type()

#  endif

#endif

/* When the compiler do not correctly initialized the basic types value in default parameters we prefer

 * to avoid them to be able to correct this bug.

 */

#if defined (_STLP_DEF_CONST_DEF_PARAM_BUG)

#  define _STLP_DONT_SUP_DFLT_PARAM 1

#endif

#if defined (__SGI_STL_NO_ARROW_OPERATOR) && ! defined (_STLP_NO_ARROW_OPERATOR)

#  define _STLP_NO_ARROW_OPERATOR

#endif

#if !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)

#  if !(defined (_STLP_NO_ARROW_OPERATOR)) && \

       !defined (_STLP_NO_MSVC50_COMPATIBILITY) && !defined (_STLP_MSVC50_COMPATIBILITY)

/* this one is needed for proper reverse_iterator<> operator ->() handling */

#    define _STLP_MSVC50_COMPATIBILITY 1

#  endif

#endif

#if defined ( _STLP_CLASS_PARTIAL_SPECIALIZATION )

#  if (defined(__IBMCPP__) && (500 <= __IBMCPP__) && (__IBMCPP__ < 600) )

#    define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \

   typedef typename _STLP_STD :: reverse_iterator<const_iterator> const_reverse_iterator; \

   typedef typename _STLP_STD :: reverse_iterator<iterator> reverse_iterator

#  elif (defined (__sgi) && ! defined (__GNUC__)) || defined (__SUNPRO_CC) || defined (__xlC__)

#    define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \

   typedef _STLP_STD:: _STLP_TEMPLATE reverse_iterator<const_iterator> const_reverse_iterator; \

   typedef _STLP_STD:: _STLP_TEMPLATE reverse_iterator<iterator> reverse_iterator

#  else

#    define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \

   typedef _STLP_STD::reverse_iterator<const_iterator> const_reverse_iterator; \

   typedef _STLP_STD::reverse_iterator<iterator> reverse_iterator

#  endif

#else /* _STLP_CLASS_PARTIAL_SPECIALIZATION */

#  if defined (_STLP_MSVC50_COMPATIBILITY)

#    define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \

  typedef _STLP_STD::__reverse_iterator<const_iterator, value_type, const_reference, \

    const_pointer, difference_type>  const_reverse_iterator; \

  typedef _STLP_STD::__reverse_iterator<iterator, value_type, reference, pointer, difference_type> \

    reverse_iterator

#  else

#    define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \

  typedef _STLP_STD::__reverse_iterator<const_iterator, value_type, const_reference, \

    difference_type>  const_reverse_iterator; \

  typedef _STLP_STD::__reverse_iterator<iterator, value_type, \

    reference, difference_type> \

    reverse_iterator

#  endif

#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */

#define _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS \

        _STLP_DECLARE_REVERSE_ITERATORS(reverse_bidirectional_iterator)

#define _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS \

        _STLP_DECLARE_REVERSE_ITERATORS(reverse_iterator)

#define __IMPORT_CONTAINER_TYPEDEFS(_Super)                              \

    typedef typename _Super::value_type value_type;                      \

    typedef typename _Super::size_type size_type;                        \

    typedef typename _Super::difference_type difference_type;            \

    typedef typename _Super::reference reference;                        \

    typedef typename _Super::const_reference const_reference;            \

    typedef typename _Super::pointer pointer;                            \

    typedef typename _Super::const_pointer const_pointer;                \

    typedef typename _Super::allocator_type allocator_type;

#define __IMPORT_ITERATORS(_Super)                                       \

    typedef typename _Super::iterator iterator;                          \

    typedef typename _Super::const_iterator const_iterator;

#define __IMPORT_REVERSE_ITERATORS(_Super)                                   \

    typedef typename _Super::const_reverse_iterator  const_reverse_iterator; \

    typedef typename _Super::reverse_iterator reverse_iterator;

#define  __IMPORT_SUPER_COPY_ASSIGNMENT(__derived_name, _Self, _SUPER)       \

    __derived_name(const _Super& __x) : _SUPER(__x) {}                       \

    _Self& operator=(const _Super& __x) {                                    \

        *(_Super*)this = __x;                                                \

        return *this;                                                        \

    }                                                                        \

    __derived_name(const _Self& __x) : _SUPER(__x) {}                        \

    _Self& operator=(const _Self& __x) {                                     \

        *(_Super*)this = __x;                                                \

        return *this;                                                        \

    }

#define __IMPORT_WITH_ITERATORS(_Super) \

  __IMPORT_CONTAINER_TYPEDEFS(_Super) __IMPORT_ITERATORS(_Super)

#define __IMPORT_WITH_REVERSE_ITERATORS(_Super) \

  __IMPORT_WITH_ITERATORS(_Super) __IMPORT_REVERSE_ITERATORS(_Super)

#if defined (_STLP_TRIVIAL_CONSTRUCTOR_BUG)

#  define __TRIVIAL_CONSTRUCTOR(__type) __type() {}

#else

#  define __TRIVIAL_CONSTRUCTOR(__type)

#endif

#if defined (_STLP_TRIVIAL_DESTRUCTOR_BUG)

#  define __TRIVIAL_DESTRUCTOR(__type) ~__type() {}

#else

#  define __TRIVIAL_DESTRUCTOR(__type)

#endif

#define __TRIVIAL_STUFF(__type)  \

  __TRIVIAL_CONSTRUCTOR(__type) __TRIVIAL_DESTRUCTOR(__type)

#if defined (_STLP_HAS_NO_EXCEPTIONS)

#  define _STLP_NO_EXCEPTIONS

#endif

#if !defined (_STLP_DONT_USE_EXCEPTIONS) && !defined (_STLP_NO_EXCEPTIONS) && !defined (_STLP_USE_EXCEPTIONS)

#  define _STLP_USE_EXCEPTIONS

#endif

#if defined (_STLP_USE_EXCEPTIONS)

#  define _STLP_TRY try

#  define _STLP_CATCH_ALL catch(...)

#  ifndef _STLP_THROW

#    define _STLP_THROW(x) throw x

#  endif

#  define _STLP_RETHROW throw

#  define _STLP_UNWIND(action) catch(...) { action; throw; }

#  ifdef _STLP_THROW_RETURN_BUG

#    define _STLP_RET_AFTER_THROW(data) return data;

#  else

#    define _STLP_RET_AFTER_THROW(data)

#  endif

/* We do not use exception throw specifications unless we are forced to */

#  if !defined (_STLP_THROWS)

#    define _STLP_THROWS(x)

#  endif

#  if !defined (_STLP_NOTHROW)

#    define _STLP_NOTHROW

#  endif

#else

#  define _STLP_TRY

#  define _STLP_CATCH_ALL if (false)

#  ifndef _STLP_THROW

#    define _STLP_THROW(x)

#  endif

#  define _STLP_RETHROW {}

#  define _STLP_UNWIND(action)

#  define _STLP_THROWS(x)

#  define _STLP_NOTHROW

#  define _STLP_RET_AFTER_THROW(data)

#endif

/*

 * Here we check _STLP_NO_EXCEPTIONS which means that the compiler has no

 * exception support but not the _STLP_USE_EXCEPTIONS which simply means

 * that the user do not want to use them.

 */

#if !defined (_STLP_NO_EXCEPTIONS) && !defined (_STLP_NO_EXCEPTION_SPEC)

#  define _STLP_THROWS_INHERENTLY(x) throw x

#  define _STLP_NOTHROW_INHERENTLY throw()

#else

#  define _STLP_THROWS_INHERENTLY(x)

#  define _STLP_NOTHROW_INHERENTLY

#endif

/* STLport function not returning are functions that throw so we translate

 * the noreturn functions in throwing functions taking also into account

 * exception support activation.

 */

#if defined (_STLP_NORETURN_FUNCTION) && !defined (_STLP_NO_EXCEPTIONS) && \

   !defined (_STLP_FUNCTION_THROWS)

#  define _STLP_FUNCTION_THROWS _STLP_NORETURN_FUNCTION

#else

#  define _STLP_FUNCTION_THROWS

#endif

#if defined(_STLP_NO_BOOL)

#  if (defined (__IBMCPP__) && (__IBMCPP__ < 400)) && ! defined (_AIX)