test: epoc32/include/stdapis/stlport/stl/

     1  /*

     2  * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.

     3  *

     4  * Copyright (c) 1994

     5  * Hewlett-Packard Company

     6  *

     7  * Copyright (c) 1996,1997

     8  * Silicon Graphics Computer Systems, Inc.

     9  *

    10  * Copyright (c) 1997

    11  * Moscow Center for SPARC Technology

    12  *

    13  * Copyright (c) 1999

    14  * Boris Fomitchev

    15  *

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

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

    18  *

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

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

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

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

    23  * modified is included with the above copyright notice.

    24  *

    25  */

    27 #ifndef _STLP_CONFIG_H

    28 # define _STLP_CONFIG_H

    30 /*

    31  * Purpose of this file :

    32  *

    33  * Defines all STLport settings.

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

    35  * settings from <config/stlcomp.h>

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

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

    38  * of those macros

    39  *

    40  */

    42 /* Other macros defined by this file:

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

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

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

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

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

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

    50    whether or not _STLP_ASSERTIONS is defined.

    51 */

    53 /* The last SGI STL release we merged with */

    54 #   define __SGI_STL                                      0x330

    56 /* STLport version */

    57 #   define _STLPORT_VERSION                               0x463

    59 /* Placeholder for user to override settings.

    60  * It could be also used to mask settings from

    61  * different directories.

    62  */

    63 # include <stl_user_config.h>

    65 /* ========================================================= */

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

    67    switches */

    68 #  include <stl/_config_compat.h>

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

    72 # include <stl/_site_config.h>

    74 /* Use per-version compiler recognition */

    75 #  include <config/stlcomp.h>

    77 /* ========================================================= */

    79 /* some fixes to configuration. This also includes modifications

    80  * of STLport switches depending on compiler flags,

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

    82  * to all who use EDG front-end.

    83  */

    84 # include <config/stl_confix.h>

    87 /*

    88  * Performs integrity check on user-specified parameters

    89  * and site-specific settings.

    90  */

    91 // # include <stl/_check_config.h>

    93 /* SGI terms */

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

    96 #  define _STLP_MEMBER_TEMPLATES 1

    97 # endif

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

   100 #  define _STLP_FRIEND_TEMPLATES 1

   101 # endif

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

   104 #  define _STLP_MEMBER_TEMPLATE_CLASSES 1

   105 # endif

   107 # if !defined (_STLP_NO_MEMBER_TEMPLATE_CLASSES) && !defined (_STLP_DONT_USE_NESTED_TCLASS_THROUGHT_TPARAM) && !defined (_STLP_USE_NESTED_TCLASS_THROUGHT_TPARAM)

   108 #  define _STLP_USE_NESTED_TCLASS_THROUGHT_TPARAM 1

   109 # endif

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

   112 #  define _STLP_CLASS_PARTIAL_SPECIALIZATION 1

   113 #endif

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

   116 #  define _STLP_FUNCTION_TMPL_PARTIAL_ORDER 1

   117 #endif

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

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

   121       defined (_AIX) || defined (__hpux) || defined(macintosh) || defined (_MAC)

   122 #   define _STLP_BIG_ENDIAN 1

   123 #  elif defined(__i386) || defined(_M_IX86)

   124 #   define _STLP_LITTLE_ENDIAN 1

   125 #  else

   126 #   define _STLP_UNKNOWN_ENDIAN 1

   127 #  endif

   128 # endif /* _STLP_BIG_ENDIAN */

   130 /* ==========================================================

   131  * final workaround tuning based on given flags

   132  * ========================================================== */

   134 #ifndef _STLP_UINT32_T

   135 # define _STLP_UINT32_T unsigned long

   136 #endif

   137 #ifndef _STLP_ABORT

   138 # define _STLP_ABORT() abort()

   139 #endif

   141 # if !defined (_STLP_HAS_NO_NAMESPACES)

   142 # if defined _STLP_NO_NAMESPACES

   143 #  undef _STLP_USE_NAMESPACES

   144 # else

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

   146 #  undef _STLP_USE_NAMESPACES

   147 #  define _STLP_USE_NAMESPACES 1

   148 # endif

   149 # endif

   150 /*

   151 # if defined (_STLP_NO_IOSTREAMS)

   152 #  define _STLP_USE_NO_IOSTREAMS

   153 # endif

   155 # if defined (_STLP_USE_NO_IOSTREAMS)

   156 #  undef _STLP_USE_NEW_IOSTREAMS

   157 # endif

   159 # if ( defined (_STLP_OWN_IOSTREAMS) || ! defined (_STLP_HAS_NO_NEW_IOSTREAMS)) \

   160    && ! defined (_STLP_USE_NO_IOSTREAMS) && !defined (_STLP_USE_NEW_IOSTREAMS)

   161 #  define _STLP_USE_NEW_IOSTREAMS

   162 # endif

   164 # if defined (_STLP_NO_NEW_IOSTREAMS)

   165 #  undef _STLP_USE_NEW_IOSTREAMS

   166 #  undef _STLP_OWN_IOSTREAMS

   167 # endif

   168 */

   169 /* Operating system recognition (basic) */

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

   171 #  define _STLP_UNIX 1

   172 #  if defined (__linux__) && ! defined (_STLP_USE_GLIBC)

   173 #   define _STLP_USE_GLIBC 1

   174 #  endif

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

   176 #  define _STLP_MAC  1

   177 # elif defined (_WIN32) || defined (__WIN32) || defined (WIN32) || defined (__WIN32__) && !defined (__SYMBIAN32__)

   178 #  define _STLP_WIN32 1

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

   180 #  define _STLP_WIN16

   181 # endif /* __unix */

   183 # if !defined(_STLP_MAKE_HEADER)

   184 #  define _STLP_MAKE_HEADER(path, header) <path/header>

   185 # endif

   186 #if !defined (_STLP_NATIVE_HEADER)

   187 # if !defined (_STLP_NATIVE_INCLUDE_PATH)

   188 #ifdef __SYMBIAN32__

   189 #  define _STLP_NATIVE_INCLUDE_PATH .

   190 #else

   191 #  define _STLP_NATIVE_INCLUDE_PATH ../include

   192 #endif

   193 # endif

   194 # define _STLP_NATIVE_HEADER(header) _STLP_MAKE_HEADER(_STLP_NATIVE_INCLUDE_PATH,header)

   195 #endif

   196 /* For some compilers, C headers like <stdio.h> are located in separate directory */

   197 #if !defined (_STLP_NATIVE_C_HEADER)

   198 # if !defined (_STLP_NATIVE_C_INCLUDE_PATH)

   199 #  define _STLP_NATIVE_C_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH

   200 # endif

   201 # define _STLP_NATIVE_C_HEADER(header)  _STLP_MAKE_HEADER(_STLP_NATIVE_C_INCLUDE_PATH,header)

   202 #endif

   204 /* For some compilers, C-library headers like <cstdio> are located in separate directory */

   205 #if !defined (_STLP_NATIVE_CPP_C_HEADER)

   206 # if !defined (_STLP_NATIVE_CPP_C_INCLUDE_PATH)

   207 #  define _STLP_NATIVE_CPP_C_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH

   208 # endif

   209 # define _STLP_NATIVE_CPP_C_HEADER(header)  _STLP_MAKE_HEADER(_STLP_NATIVE_CPP_C_INCLUDE_PATH,header)

   210 #endif

   212 /* Some compilers have weird placement of old-style iostream headers */

   213 #if !defined ( _STLP_NATIVE_OLD_STREAMS_HEADER )

   214 # if !defined (_STLP_NATIVE_OLD_STREAMS_INCLUDE_PATH)

   215 #  define _STLP_NATIVE_OLD_STREAMS_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH

   216 # endif

   217 # define _STLP_NATIVE_OLD_STREAMS_HEADER(header)  _STLP_MAKE_HEADER(_STLP_NATIVE_OLD_STREAMS_INCLUDE_PATH,header)

   218 #endif

   220 /* Some compilers locate basic C++ runtime support headers (<new>, <typeinfo>, <exception>) in separate directory */

   221 #if !defined ( _STLP_NATIVE_CPP_RUNTIME_HEADER )

   222 # if !defined (_STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH)

   223 #  define _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH

   224 # endif

   225 # define _STLP_NATIVE_CPP_RUNTIME_HEADER(header)  _STLP_MAKE_HEADER(_STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH,header)

   226 #endif

   228 /*  shared library tune-up */

   230 #if defined (__BUILDING_STLPORT)

   231 /*  if we are rebuilding right now as a DLL, place everything here */

   232 #  undef  _STLP_DESIGNATED_DLL

   233 #  define _STLP_DESIGNATED_DLL 1

   234 #endif

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

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

   238      /* !defined (_STLP_OWN_IOSTREAMS) && */ !defined(_STLP_NO_OWN_NAMESPACE)

   239 #  undef  _STLP_USE_OWN_NAMESPACE

   240 #  define _STLP_USE_OWN_NAMESPACE  1

   241 # else

   242 #  undef _STLP_WHOLE_NATIVE_STD

   243 # endif

   245 #  undef _STLP_NAMESPACE

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

   249 #  ifndef _REENTRANT

   250 #     define _REENTRANT

   251 #  endif

   253 #  if defined(_PTHREADS)

   254 #     define _STLP_PTHREADS

   255 #     define _STLP_THREADS

   256 #  endif

   257 #  if defined(_UITHREADS)

   258 #     define _STLP_UITHREADS

   259 #     define _STLP_THREADS

   260 #  endif

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

   263 #    define _STLP_SGI_THREADS

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

   265 #    define _STLP_DEC_THREADS

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

   267 #    define _STLP_WIN32THREADS 1

   268 #   elif ((defined (__sun) && !defined (__linux__)) \

   269      || defined(_UITHREADS) ) && !defined(_STLP_PTHREADS)

   270 #     define _STLP_UITHREADS

   271 #   elif defined (__OS2__)

   272 #     define _STLP_OS2THREADS

   273 #   elif defined(__BEOS__)

   274 #     define _STLP_BETHREADS

   275 #   else

   276 #     define _STLP_PTHREADS

   277 #   endif /* __sgi */

   278 #   define _STLP_THREADS_DEFINED

   279 # endif

   281 #  if defined (_REENTRANT) && ! defined (_STLP_THREADS)

   282 #   define _STLP_THREADS

   283 #  endif /* _REENTRANT */

   285 // warning : pthread_spinlock code was reported not to work on RedHat 3

   286 # if defined(__linux__) && defined(_STLP_USE_PTHREAD_SPINLOCK)

   287 #  include <features.h>

   288 #  ifndef __USE_XOPEN2K

   289 #   undef _STLP_USE_PTHREAD_SPINLOCK

   290 #  endif /* __USE_XOPEN2K */

   291 # endif /* __linux__ && _STLP_PTHREADS */

   293 # ifndef _STLP_STATIC_MUTEX

   294 #  define _STLP_STATIC_MUTEX _STLP_mutex_base

   295 # endif

   298 # if defined (_MFC_VER) && !defined (_STLP_USE_MFC)

   299 #  define _STLP_USE_MFC 1

   300 # endif

   302 #if defined (_STLP_THREADS)

   303 #   define _STLP_VOLATILE volatile

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

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

   306 #   undef  NOMINMAX

   307 #   define NOMINMAX

   308 #   ifdef _STLP_USE_MFC

   309 #    include <afx.h>

   310 #   else

   311 #    include <windows.h>

   312 #   endif

   313 #   define _STLP_WINDOWS_H_INCLUDED

   314 # endif

   315 #else

   316 #   define _STLP_VOLATILE

   317 #endif

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

   320 #  define _STLP_USE_NEW_C_HEADERS

   321 # endif

   322 /* disable new-style headers if requested */

   323 # if defined ( _STLP_NO_NEW_C_HEADERS )

   324 #  undef _STLP_USE_NEW_C_HEADERS

   325 # endif

   327 # if !defined ( _STLP_STATIC_TEMPLATE_DATA )

   328 # define _STLP_STATIC_TEMPLATE_DATA 1

   329 # endif

   331 # if defined (_STLP_BASE_TYPEDEF_BUG)

   332 #  undef  _STLP_BASE_TYPEDEF_OUTSIDE_BUG

   333 #  define _STLP_BASE_TYPEDEF_OUTSIDE_BUG 1

   334 # endif

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

   337 #  define _STLP_GLOBAL_NESTED_RETURN_TYPE_PARAM_BUG

   338 # endif

   340 /* SUNpro 4.2 inline string literal bug */

   341 #ifdef _STLP_INLINE_STRING_LITERAL_BUG

   342 # define _STLP_FIX_LITERAL_BUG(__x) __x=__x;

   343 #else

   344 # define _STLP_FIX_LITERAL_BUG(__x)

   345 #endif

   347 # if defined (_STLP_NON_TYPE_TMPL_PARAM_BUG)

   348 #  undef  _STLP_NO_DEFAULT_NON_TYPE_PARAM

   349 #  define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1

   350 # endif

   352 # ifdef _STLP_DEBUG

   353 #  define _STLP_ASSERTIONS 1

   354 # endif

   356 /* apple mpw exception handling bug */

   357 #ifndef _STLP_MPWFIX_TRY

   358 # define _STLP_MPWFIX_TRY

   359 #endif

   360 #ifndef _STLP_MPWFIX_CATCH

   361 # define _STLP_MPWFIX_CATCH

   362 #endif

   363 #ifndef _STLP_MPWFIX_CATCH_ACTION

   364 # define _STLP_MPWFIX_CATCH_ACTION(action)

   365 #endif

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

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

   370 #  define _STLP_ASSERT(expr)

   371 # endif

   373 # ifndef _STLP_DEBUG

   374 #  define _STLP_VERBOSE_ASSERT(expr,diagnostic)

   375 #  define _STLP_DEBUG_CHECK(expr)

   376 #  define _STLP_DEBUG_DO(expr)

   377 # endif

   379 #  if !defined (_STLP_WEAK)

   380 #   define _STLP_WEAK

   381 #  endif

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

   384 #  if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)

   385 #   define __DFL_TMPL_PARAM( classname, defval ) class classname

   386 #   define __DFL_TMPL_ARG(classname) , classname

   387 #  else

   388 #   define _STLP_DEFAULT_TYPE_PARAM 1

   389 #   define __DFL_TMPL_PARAM( classname, defval ) class classname = defval

   390 #   define __DFL_TMPL_ARG(classname)

   391 #  endif

   393 /* default parameters as complete types */

   394 # if defined ( _STLP_DEFAULT_TYPE_PARAM )

   395 #   define __DFL_TYPE_PARAM( classname, defval ) class classname = defval

   396 #   define __DFL_NON_TYPE_PARAM(type,name,val) type name = val

   397 #   define __DFL_TYPE_ARG(classname)

   398 # else

   399 #   define __DFL_TYPE_PARAM( classname, defval ) class classname

   400 #   define __DFL_NON_TYPE_PARAM(type,name,val) type name

   401 #   define __DFL_TYPE_ARG(classname) , classname

   402 # endif

   404 /* SGI compatibility */

   406 #ifdef _STLP_NO_WCHAR_T

   407 # ifndef _STLP_NO_NATIVE_WIDE_STREAMS

   408 #  define  _STLP_NO_NATIVE_WIDE_STREAMS 1

   409 # endif

   410 #else

   411 # define _STLP_HAS_WCHAR_T 1

   412 #endif

   414 #if !defined (_STLP_NO_AT_MEMBER_FUNCTION)

   415 # define _STLP_CAN_THROW_RANGE_ERRORS 1

   416 #endif

   418 # if !defined (_STLP_USE_RAW_SGI_ALLOCATORS)

   419 #   define _STLP_DEFAULT_ALLOCATOR(_Tp) allocator< _Tp >

   420 #   define _STLP_DEFAULT_ALLOCATOR_SELECT( _Tp ) __DFL_TMPL_PARAM(_Alloc, allocator< _Tp >)

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

   422 #   if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)

   423 #     define _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_Key, _Tp ) class _Alloc

   424 #     define _STLP_USE_WRAPPER_FOR_ALLOC_PARAM 1

   425 #   else

   426 #     define _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_Key, _Tp ) \

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

   428 #   endif

   429 # else

   430 #   define _STLP_DEFAULT_ALLOCATOR( _Tp ) __sgi_alloc

   431 #   define _STLP_DEFAULT_ALLOCATOR_SELECT( _Tp ) __DFL_TYPE_PARAM(_Alloc,__sgi_alloc)

   432 #   define _STLP_DEFAULT_PAIR_ALLOCATOR( _Key, _Tp ) __sgi_alloc

   433 #   define _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_Key, _Tp ) __DFL_TYPE_PARAM(_Alloc,__sgi_alloc)

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

   435 #    define _STLP_USE_WRAPPER_FOR_ALLOC_PARAM 1

   436 #   endif

   437 # endif

   439 /* default parameters workaround tuning */

   440 #  if defined ( _STLP_USE_WRAPPER_FOR_ALLOC_PARAM )

   441 #    define __WORKAROUND_RENAME(X) __##X

   442 #  else

   443 #    define __WORKAROUND_RENAME(X) X

   444 #  endif

   445 #  if defined ( _STLP_DEBUG )

   446 #    define __WORKAROUND_DBG_RENAME(X) __##X

   447 #  else

   448 #    define __WORKAROUND_DBG_RENAME(X) __WORKAROUND_RENAME(X)

   449 #  endif

   450 #  define __FULL_NAME(X) __WORKAROUND_RENAME(X)

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

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

   454 #  define _STLP_VENDOR_GLOBAL_CSTD 1

   455 # endif

   457 /* Depending of whether compiler supports namespaces,

   458  * tune the parameters for vendor-supplied libraries.

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

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

   461  * to use namespace for STLport or not.

   462  */

   463 # if !defined (_STLP_HAS_NO_NAMESPACES)

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

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

   466 #  if defined (_STLP_WHOLE_NATIVE_STD)

   467 #    define  _STLP_IMPORT_VENDOR_STD 1

   468 #    undef   _STLP_MINIMUM_IMPORT_STD

   469 #  elif (defined (_STLP_USE_OWN_NAMESPACE) || ( defined (_STLP_DEBUG) && defined (_STLP_USE_NAMESPACES))) \

   470        && defined (_STLP_USE_NEW_IOSTREAMS) && ! defined (_STLP_OWN_IOSTREAMS)

   471 #    define  _STLP_IMPORT_VENDOR_STD 1

   472 #  endif

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

   475  * try importing 'em.

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

   477 #  if defined (_STLP_USE_NAMESPACES) && /* ! defined (_STLP_OWN_IOSTREAMS) && */ \

   478    ( defined(_STLP_USE_OWN_NAMESPACE) || defined (_STLP_VENDOR_GLOBAL_CSTD))

   479 #    define  _STLP_IMPORT_VENDOR_CSTD 1

   480 #  endif

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

   483 #  define _STLP_NO_CSTD_FUNCTION_IMPORTS

   484 # endif

   486 #  define  _STLP_USING_NAMESPACE(x) using namespace x ;

   488 namespace std { }

   489 namespace __std_alias = std;

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

   492 #  ifdef _STLP_VENDOR_GLOBAL_STD

   493 #   define _STLP_VENDOR_STD

   494 #   define _STLP_USING_VENDOR_STD

   495 #  else

   496 #   define _STLP_VENDOR_STD __std_alias

   497 #   define _STLP_USING_VENDOR_STD _STLP_USING_NAMESPACE(_STLP_VENDOR_STD)

   498 // #   define _STLP_USING_VENDOR_STD

   499 #  endif

   501 /* tune things that come from C library */

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

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

   504 #   define _STLP_VENDOR_CSTD

   505 #   define _STLP_USING_VENDOR_CSTD

   506 #  else

   507 #   define _STLP_VENDOR_CSTD  _STLP_VENDOR_STD

   508 #   define _STLP_USING_VENDOR_CSTD _STLP_USING_NAMESPACE(_STLP_VENDOR_CSTD)

   509 #  endif /* _STLP_VENDOR_CSTD */

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

   511 #  ifndef _STLP_VENDOR_EXCEPT_STD

   512 #   ifdef _STLP_VENDOR_GLOBAL_EXCEPT_STD

   513 #    define _STLP_VENDOR_EXCEPT_STD

   514 #   else

   515 #    define _STLP_VENDOR_EXCEPT_STD _STLP_VENDOR_STD

   516 #   endif

   517 #  endif

   518 # define _STLP_OLD_IO_NAMESPACE

   519 # ifndef _STLP_VENDOR_MB_NAMESPACE

   520 #  define _STLP_VENDOR_MB_NAMESPACE _STLP_VENDOR_CSTD

   521 # endif

   522 # else

   523 /* compiler has no namespace support */

   524 #  define _STLP_VENDOR_STD

   525 #  define _STLP_VENDOR_CSTD

   526 #  define _STLP_USING_NAMESPACE(x)

   527 #  define _STLP_USING_VENDOR_CSTD

   528 #  define _STLP_USING_VENDOR_STD

   529 #  define _STLP_VENDOR_EXCEPT_STD

   530 # endif

   532 # if defined (_STLP_USE_NAMESPACES)

   534 #  if defined (_STLP_USE_OWN_NAMESPACE)

   535 #   define _STLP_STD      _STL

   536 #  else

   537 #   ifdef _STLP_DEBUG

   538 namespace stdD = std;

   539 #   endif

   540 #   define _STLP_STD      std

   541 #  endif /* _STLP_USE_OWN_NAMESPACE */

   543 #  define _STLP_BEGIN_NAMESPACE namespace _STLP_STD {

   544 #  define _STLP_END_NAMESPACE }

   546 _STLP_BEGIN_NAMESPACE _STLP_END_NAMESPACE

   548 namespace stlport = _STLP_STD;

   549 // backward compatibility

   550 # undef __STLPORT_NAMESPACE

   551 # define __STLPORT_NAMESPACE _STLP_STD

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

   554 #   if defined(_STLP_NO_RELOPS_NAMESPACE)

   555 #     define _STLP_BEGIN_RELOPS_NAMESPACE _STLP_BEGIN_NAMESPACE namespace rel_ops {}

   556 #     define _STLP_END_RELOPS_NAMESPACE }

   557 #   else

   558 /* Use std::rel_ops namespace */

   559 #     define _STLP_BEGIN_RELOPS_NAMESPACE _STLP_BEGIN_NAMESPACE namespace rel_ops {

   560 #     define _STLP_END_RELOPS_NAMESPACE } }

   561 #     define _STLP_USE_SEPARATE_RELOPS_NAMESPACE

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

   564 # else /* _STLP_USE_NAMESPACES */

   565 /* STLport is being put into global namespace */

   566 #  define _STLP_STD

   567 #  define _STLP_BEGIN_NAMESPACE

   568 #  define _STLP_END_NAMESPACE

   570 /* boris : it was found out that _STLP_USE_SEPARATE_RELOPS_NAMESPACE

   571    causes less problems than having relational operator templates in global namespace

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

   573 #  ifndef _STLP_NO_RELOPS_NAMESPACE

   574 #   define _STLP_USE_SEPARATE_RELOPS_NAMESPACE

   575 #  endif

   576 #  define _STLP_BEGIN_RELOPS_NAMESPACE

   577 #  define _STLP_END_RELOPS_NAMESPACE

   578 #  undef  _STLP_USE_OWN_NAMESPACE

   579 # endif  /* _STLP_USE_NAMESPACES */

   581 # define STLPORT_CSTD _STLP_VENDOR_CSTD

   582 # define STLPORT      _STLP_STD

   584 #if defined(_STLP_BOGUS_TEMPLATE_TYPE_MATCHING_BUG)

   585 #  define _STLP_SIMPLE_TYPE(T) _stl_trivial_proxy<T>

   586 #else

   587 #  define _STLP_SIMPLE_TYPE(T) T

   588 #endif

   590 /* if we are going to use native new iostreams, use native <string> and <stdexcept> */

   591 #  if defined (_STLP_USE_NEW_IOSTREAMS) && !defined (_STLP_OWN_IOSTREAMS)

   592 #ifndef __SYMBIAN32__

   593 #   define _STLP_USE_NATIVE_STRING      1

   594 #   define _STLP_USE_NATIVE_STDEXCEPT   1

   595 #endif

   596 # endif

   598 # ifndef _STLP_RAND48

   599 # define _STLP_NO_DRAND48

   600 # endif

   602 /* backwards compatibility */

   603 # define __STL_NAMESPACE _STLP_STD

   604 # define __STL_NAME(name) _STLP_STD::name

   606 /* advanced keywords usage */

   607 #  ifndef  _STLP_NO_NEW_STYLE_CASTS

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

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

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

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

   612 #  else

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

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

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

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

   617 #  endif

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

   619 #   define typename

   620 #  endif

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

   622 #    define _STLP_TYPENAME_ON_RETURN_TYPE

   623 #  else

   624 #    define _STLP_TYPENAME_ON_RETURN_TYPE typename

   625 #  endif

   626 # ifdef _STLP_NO_TYPENAME_IN_TEMPLATE_HEADER

   627 #  define _STLP_HEADER_TYPENAME

   628 # else

   629 #  define _STLP_HEADER_TYPENAME typename

   630 # endif

   631 # ifndef _STLP_NO_MEMBER_TEMPLATE_KEYWORD

   632 #   define _STLP_TEMPLATE template

   633 # else

   634 #   define _STLP_TEMPLATE

   635 # endif

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

   637 #   define explicit

   638 #  endif

   639 #  ifndef _STLP_NEED_MUTABLE

   640 #   define __ASSIGN_MUTABLE(type,x,y) x=y

   641 #  else

   642 #   define __ASSIGN_MUTABLE(type,x,y) __CONST_CAST(type,x)=y

   643 #   define mutable

   644 #  endif

   645 # if defined (_STLP_NO_SIGNED_BUILTINS)

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

   647 #  define signed

   648 # endif

   650 #  if defined (_STLP_LOOP_INLINE_PROBLEMS)

   651 #   define _STLP_INLINE_LOOP

   652 #  else

   653 #   define _STLP_INLINE_LOOP inline

   654 #  endif

   656 #  define _STLP_PRIVATE public

   657 #  define _STLP_PROTECTED public

   659 #  ifndef _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX

   660 #   define _STLP_TEMPLATE_NULL template<>

   661 #  else

   662 #   define _STLP_TEMPLATE_NULL

   663 #  endif

   665 #ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER

   666 #  define _STLP_OPERATOR_TEMPLATE

   667 # else

   668 #  define _STLP_OPERATOR_TEMPLATE _STLP_TEMPLATE_NULL

   669 #endif

   671 # ifndef _STLP_CLASS_PARTIAL_SPECIALIZATION

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

   673 # if ! defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)

   674 #  define  _STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS

   675 # endif

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

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

   678 #   if ! defined ( _STLP_USE_OLD_HP_ITERATOR_QUERIES )

   679 #    define _STLP_USE_OLD_HP_ITERATOR_QUERIES

   680 #   endif

   681 #  elif defined ( _STLP_NO_ANACHRONISMS )

   682 #   undef _STLP_USE_OLD_HP_ITERATOR_QUERIES

   683 #  endif

   684 # endif

   686 # ifndef _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS

   687 #   define _STLP_NULL_TMPL_ARGS <>

   688 # else

   689 #   define _STLP_NULL_TMPL_ARGS

   690 # endif

   692 # ifndef _STLP_ALLOCATOR_TYPE_DFL

   693 #  ifdef _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS

   694 #   define _STLP_ALLOCATOR_TYPE_DFL

   695 #  else

   696 #   define _STLP_ALLOCATOR_TYPE_DFL = allocator_type()

   697 #  endif

   698 # endif

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

   701 //to avoid them to be able to correct this bug.

   702 # if defined (_STLP_DEF_CONST_DEF_PARAM_BUG)

   703 #  define _STLP_DONT_SUP_DFLT_PARAM 1

   704 # endif

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

   707 # define _STLP_NO_ARROW_OPERATOR

   708 # endif

   710 # if !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)

   711 #  if !( defined (_STLP_NO_ARROW_OPERATOR)) \

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

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

   714 #   define _STLP_MSVC50_COMPATIBILITY 1

   715 #  endif

   716 # endif

   718 #if defined ( _STLP_CLASS_PARTIAL_SPECIALIZATION )

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

   720 # define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \

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

   722    typedef typename _STLP_STD :: reverse_iterator<iterator> reverse_iterator

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

   724 #  define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \

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

   726    typedef _STLP_STD:: _STLP_TEMPLATE reverse_iterator<iterator> reverse_iterator

   727 # else

   728 #  define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \

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

   730    typedef _STLP_STD::reverse_iterator<iterator> reverse_iterator

   731 # endif

   732 #else /* _STLP_CLASS_PARTIAL_SPECIALIZATION */

   733 # if defined (_STLP_MSVC50_COMPATIBILITY)

   734 # define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \

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

   736     const_pointer, difference_type>  const_reverse_iterator; \

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

   738     reverse_iterator

   739 # else

   740 # define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \

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

   742     difference_type>  const_reverse_iterator; \

   743   typedef _STLP_STD::__reverse_iterator<iterator, value_type, \

   744     reference, difference_type> \

   745     reverse_iterator

   746 # endif

   747 #endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */

   749 # define _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS \

   750          _STLP_DECLARE_REVERSE_ITERATORS(reverse_bidirectional_iterator)

   751 # define _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS \

   752          _STLP_DECLARE_REVERSE_ITERATORS(reverse_iterator)

   754 #  define __IMPORT_CONTAINER_TYPEDEFS(_Super)                            \

   755     typedef typename _Super::value_type value_type;                      \

   756     typedef typename _Super::size_type size_type;                        \

   757     typedef typename _Super::difference_type difference_type;            \

   758     typedef typename _Super::reference reference;                        \

   759     typedef typename _Super::const_reference const_reference;            \

   760     typedef typename _Super::pointer pointer;                            \

   761     typedef typename _Super::const_pointer const_pointer;                \

   762     typedef typename _Super::allocator_type allocator_type;

   765 #  define __IMPORT_ITERATORS(_Super)                                     \

   766     typedef typename _Super::iterator iterator;                                   \

   767     typedef typename _Super::const_iterator const_iterator;

   769 #  define __IMPORT_REVERSE_ITERATORS(_Super)                             \

   770     typedef typename _Super::const_reverse_iterator  const_reverse_iterator;      \

   771     typedef typename _Super::reverse_iterator reverse_iterator;

   773 #  define  __IMPORT_SUPER_COPY_ASSIGNMENT(__derived_name, _Self, _SUPER)         \

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

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

   776         *(_Super*)this = __x;                                   \

   777         return *this;                                           \

   778     }  \

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

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

   781         *(_Super*)this = __x;                                   \

   782         return *this;                                           \

   783     }

   785 # define __IMPORT_WITH_ITERATORS(_Super) \

   786 __IMPORT_CONTAINER_TYPEDEFS(_Super) __IMPORT_ITERATORS(_Super)

   788 # define __IMPORT_WITH_REVERSE_ITERATORS(_Super) \

   789 __IMPORT_WITH_ITERATORS(_Super) __IMPORT_REVERSE_ITERATORS(_Super)

   791 # if defined (_STLP_TRIVIAL_CONSTRUCTOR_BUG)

   792 #  define __TRIVIAL_CONSTRUCTOR(__type) __type() {}

   793 # else

   794 #  define __TRIVIAL_CONSTRUCTOR(__type)

   795 # endif

   796 # if defined (_STLP_TRIVIAL_DESTRUCTOR_BUG)

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

   798 # else

   799 #  define __TRIVIAL_DESTRUCTOR(__type)

   800 # endif

   802 #  define __TRIVIAL_STUFF(__type)  \

   803   __TRIVIAL_CONSTRUCTOR(__type) __TRIVIAL_DESTRUCTOR(__type)

   805 # if ! (defined ( _STLP_NO_EXCEPTIONS ) || defined (_STLP_HAS_NO_EXCEPTIONS) \

   806 	|| defined ( _STLP_USE_EXCEPTIONS ))

   807 #  define _STLP_USE_EXCEPTIONS

   808 # endif

   810 #define _STLP_NOPUSH

   812 # ifdef _STLP_USE_EXCEPTIONS

   813 #   define _STLP_LEAVE_VOLATILE

   814 #   define _STLP_TRY try

   815 #   define _STLP_CATCH_ALL catch(...)

   816 #   ifndef _STLP_THROW

   817 #    define _STLP_THROW(x) throw x

   818 #   endif

   819 #   define _STLP_RETHROW throw

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

   821 #   define _STLP_UNWIND_BEGIN(action) catch(...)

   823 #   ifdef _STLP_THROW_RETURN_BUG

   824 #     define _STLP_RET_AFTER_THROW(data) return data

   825 #   else

   826 #     define _STLP_RET_AFTER_THROW(data)

   827 #   endif

   829 #   if !defined ( _STLP_NO_EXCEPTION_SPEC )

   830 #    define _STLP_THROWS_INHERENTLY(x) throw x

   831 #    define _STLP_NOTHROW_INHERENTLY throw()

   832 #   else

   833 #    define _STLP_THROWS_INHERENTLY(x)

   834 #    define _STLP_NOTHROW_INHERENTLY

   835 #   endif

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

   837 #   define _STLP_THROWS(x)

   838 #   define _STLP_NOTHROW

   840 # elif defined _STLP_USE_TRAP_LEAVE

   842 #include <bldvariant.hrh>

   844 #ifdef __SERIES60_30__

   845 #include <e32cmn.h>

   846 #else

   847 #include <e32base.h>

   848 #endif  // __SERIES60_30__

   851 class _TStUntrap {

   852 public:

   853     ~_TStUntrap() {

   854       TTrap::UnTrap(); }

   855 };

   857 // this does not work for MSVC 6.0

   858 # if defined (_MSC_VER) && (_MSC_VER <= 1200)

   859 # define _STLP_LEAVE_VOLATILE

   860 # else

   861 # define _STLP_LEAVE_VOLATILE volatile

   862 # endif

   864 template<class T> inline void _STLP_no_unused_variable_warning(const T &) {}

   866 #   define _STLP_TRY TInt _STL_TrapExitCode; { TTrap _STL_Trap;	\

   867   if (_STL_Trap.Trap(_STL_TrapExitCode)==0) { \

   868     _TStUntrap _STL_Untrap;	\

   869     _STLP_no_unused_variable_warning( _STL_Untrap );

   871 #   define _STLP_CATCH_ALL \

   872    } } if (_STL_TrapExitCode)

   874 # define _STLP_TRY_C

   875 # define _STLP_UNWIND_C(x)

   876 # define _STLP_CATCH_ALL_C

   878 #   ifndef _STLP_THROW

   879 #    define _STLP_THROW(x)

   880 #   endif

   882 #   define _STLP_RETHROW User::Leave(_STL_TrapExitCode)

   883 #   define _STLP_UNWIND(__action) _STLP_CATCH_ALL { __action; _STLP_RETHROW; }

   885 #   define __THROW_BAD_ALLOC User::Leave(STDEX_bad_alloc);

   887 #   ifdef _STLP_THROW_RETURN_BUG

   888 #     define _STLP_RET_AFTER_THROW(data) return data

   889 #   else

   890 #     define _STLP_RET_AFTER_THROW(data)

   891 #   endif

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

   893 #   define _STLP_THROWS(x)

   894 #   define _STLP_NOTHROW

   895 #   define _STLP_THROWS_INHERENTLY(x)

   896 #   define _STLP_NOTHROW_INHERENTLY

   898 # else

   899 #   define _STLP_LEAVE_VOLATILE

   900 #   define _STLP_TRY

   901 #   define _STLP_CATCH_ALL if (false)

   902 #   ifndef _STLP_THROW

   903 #    define _STLP_THROW(x)

   904 #   endif

   905 #   define _STLP_RETHROW {}

   906 #   define _STLP_UNWIND(action)

   907 #   define _STLP_THROWS(x)

   908 #   define _STLP_NOTHROW

   909 #   define _STLP_RET_AFTER_THROW(data)

   910 #   define _STLP_THROWS_INHERENTLY(x)

   911 #   define _STLP_NOTHROW_INHERENTLY

   912 # endif

   914 #if defined(_STLP_NO_BOOL)

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

   916 #  include <isynonym.hpp>

   917 #  if defined (__OS400__)

   918     typedef int bool;

   919 #  elif !( defined (__xlC__) || defined (_AIX))

   920     typedef Boolean bool;

   921 #  endif

   922 # else

   923 #  if defined(_STLP_YVALS_H)

   924 #   include <yvals.h>

   925 #  else

   926 #    if defined (_STLP_DONT_USE_BOOL_TYPEDEF)

   927 #     define bool int

   928 #    else

   929       typedef int bool;

   930 #    endif

   931 #    define true 1

   932 #    define false 0

   933 #  endif

   934 # endif /* __IBMCPP__ */

   935 #else

   936 #    define _STLP_BOOL_KEYWORD 1

   937 #endif /* _STLP_NO_BOOL */

   939 # ifndef _STLP_MPW_EXTRA_CONST

   940 #  define _STLP_MPW_EXTRA_CONST

   941 # endif

   943 # ifndef _STLP_DEFAULTCHAR

   944 #  define _STLP_DEFAULTCHAR char

   945 # endif

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

   948 #  define _STLP_ASSERTIONS 1

   949 # endif

   951 /* uninitialized value filler */

   952 # ifndef _STLP_SHRED_BYTE

   953 /* This value is designed to cause problems if an error occurs */

   954 #   define _STLP_SHRED_BYTE 0xA3

   955 # endif /* _STLP_SHRED_BYTE */

   957 /* shared library tune-up */

   958 # ifndef _STLP_IMPORT_DECLSPEC

   959 //#  define _STLP_IMPORT_DECLSPEC

   960 # endif

   961 /* a keyword used to instantiate export template */

   962 #  ifndef _STLP_EXPORT_TEMPLATE_KEYWORD

   963 #   define _STLP_EXPORT_TEMPLATE_KEYWORD EXPORT_C

   964 #  endif

   965 # ifndef _STLP_IMPORT_TEMPLATE_KEYWORD

   966 #  define _STLP_IMPORT_TEMPLATE_KEYWORD IMPORT_C

   967 # endif

   970 # if  defined (_STLP_DLLEXPORT_NEEDS_PREDECLARATION) && defined (_STLP_USE_DECLSPEC)

   971 #  if ! defined (_STLP_USE_TEMPLATE_EXPORT)

   972 /* this setting turns on "extern template" extension use */

   973 #   define _STLP_USE_TEMPLATE_EXPORT

   974 #  endif

   975 #  if defined (_STLP_DESIGNATED_DLL) && ! defined (_STLP_NO_FORCE_INSTANTIATE)

   976 #   define _STLP_NO_FORCE_INSTANTIATE

   977 #  endif

   978 # endif

   980 #   if defined (_STLP_DESIGNATED_DLL) /* This is a lib which will contain STLport exports */

   981 #    define  _STLP_EXPORT          _STLP_EXPORT_TEMPLATE_KEYWORD

   982 #   else

   983 #    define  _STLP_EXPORT          _STLP_IMPORT_TEMPLATE_KEYWORD

   984 #  endif

   986 # ifndef _STLP_EXPORT_TEMPLATE

   987 #  define  _STLP_EXPORT_TEMPLATE _STLP_EXPORT template

   988 # endif

   990 # if defined (_STLP_USE_DECLSPEC) /* using export/import technique */

   992 #  ifndef _STLP_EXPORT_DECLSPEC

   993 #ifdef __SYMBIAN32__

   994 #   define _STLP_EXPORT_DECLSPEC EXPORT_C

   995 #else

   996 #   define _STLP_EXPORT_DECLSPEC

   997 #endif

   998 #  endif

   999 #  ifndef _STLP_IMPORT_DECLSPEC

  1000 #ifdef __SYMBIAN32__

  1001 #   define _STLP_IMPORT_DECLSPEC IMPORT_C

  1002 #else

  1003 #   define _STLP_IMPORT_DECLSPEC

  1004 #endif

  1005 #  endif

  1006 #  ifndef _STLP_CLASS_EXPORT_DECLSPEC

  1007 #   define _STLP_CLASS_EXPORT_DECLSPEC

  1008 #  endif

  1009 #  ifndef _STLP_CLASS_IMPORT_DECLSPEC

  1010 #   define _STLP_CLASS_IMPORT_DECLSPEC

  1011 #  endif

  1012 #  if defined (_STLP_DESIGNATED_DLL) /* This is a lib which will contain STLport exports */

  1013 #   define  _STLP_DECLSPEC        _STLP_IMPORT_DECLSPEC

  1014 #   define  _STLP_EXP_DECLSPEC    _STLP_EXPORT_DECLSPEC

  1015 #   define  _STLP_CLASS_DECLSPEC  _STLP_CLASS_EXPORT_DECLSPEC

  1016 #  else

  1017 #   define  _STLP_DECLSPEC        //_STLP_IMPORT_DECLSPEC   /* Other modules, importing STLport exports */

  1018 #   define  _STLP_EXP_DECLSPEC    //_STLP_EXPORT_DECLSPEC

  1019 #   define  _STLP_CLASS_DECLSPEC  _STLP_CLASS_IMPORT_DECLSPEC

  1020 #   undef _STLP_USE_NAMESPACES

  1021 #   define _STLP_USE_NAMESPACES

  1022 #  endif

  1024 #  ifndef _STLP_STATIC_CONST_INIT_BUG

  1025 // constant data members cannot be exported; using workaround here

  1026 #   define _STLP_STATIC_CONST_INIT_BUG

  1027 #  endif

  1028 # else /* Not using DLL export/import specifications */

  1030 #  define _STLP_DECLSPEC

  1031 #  define _STLP_CLASS_DECLSPEC

  1033 # endif

  1035 #  define _STLP_EXPORT_TEMPLATE_CLASS _STLP_EXPORT template class _STLP_CLASS_DECLSPEC

  1037 #ifndef _STLP_EXPORT_METHOD

  1038 # define _STLP_EXPORT_METHOD

  1039 #endif

  1041 #  if defined (_STLP_MSVC) || defined (__ICL)

  1042 #   define _STLP_STATIC_MEMBER_DECLSPEC

  1043 #   define _STLP_STATIC_MEMBER_EXP_DECLSPEC

  1044 #  else

  1045 #   define _STLP_STATIC_MEMBER_DECLSPEC _STLP_DECLSPEC

  1046 #   define _STLP_STATIC_MEMBER_EXP_DECLSPEC _STLP_EXPORT_DECLSPEC

  1047 #  endif

  1049 # if !defined (_STLP_CALL)

  1050 #   define _STLP_CALL

  1051 # endif

  1053 #ifdef _STLP_OWN_IOSTREAMS

  1055 #  if defined (__DECCXX) && ! defined (__USE_STD_IOSTREAM)

  1056 #   define __USE_STD_IOSTREAM

  1057 #  endif

  1059 /* We only need to expose details of streams implementation

  1060    if we use non-standard i/o or are building STLport*/

  1061 # if defined (__BUILDING_STLPORT) ||  defined (_STLP_NO_FORCE_INSTANTIATE) || !defined(_STLP_NO_CUSTOM_IO) || defined (__SYMBIAN32__)

  1062 #  define _STLP_EXPOSE_STREAM_IMPLEMENTATION 1

  1063 # endif

  1065 /* We only need to expose details of global implementation if we are building STLport

  1066    or have not instantiated everything in the lib */

  1068 //# if defined (__BUILDING_STLPORT) || defined (_STLP_NO_FORCE_INSTANTIATE)

  1069 #   undef  _STLP_EXPOSE_GLOBALS_IMPLEMENTATION

  1070 #   define _STLP_EXPOSE_GLOBALS_IMPLEMENTATION 1

  1071 //# endif

  1073 #else

  1074 /* when we are not using SGI iostreams, we must expose globals, but not streams implementation */

  1075 #  define _STLP_EXPOSE_GLOBALS_IMPLEMENTATION

  1076 #endif

  1078 # ifdef _STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS

  1079 #  define _STLP_PSPEC2(t1,t2) < t1,t2 >

  1080 #  define _STLP_PSPEC3(t1,t2,t3) < t1,t2,t3 >

  1081 # else

  1082 #  define _STLP_PSPEC2(t1,t2)	/* nothing */

  1083 #  define _STLP_PSPEC3(t1,t2,t3)	/* nothing */

  1084 # endif

  1086 # ifdef _STLP_OPERATOR_SPEC_NEEDS_TEMPLATE_ARGS

  1087 #  define _STLP_OPSPEC2(t1,t2) < t1,t2 >

  1088 # else

  1089 #  define _STLP_OPSPEC2(t1,t2)	/* nothing */

  1090 # endif

  1092 //Activation of the partial template workaround:

  1093 # if !defined(_STLP_DONT_USE_PARTIAL_SPEC_WRKD) \

  1094     && (!defined(_STLP_CLASS_PARTIAL_SPECIALIZATION) || !defined(_STLP_FUNCTION_TMPL_PARTIAL_ORDER))

  1095 #  define _STLP_USE_PARTIAL_SPEC_WORKAROUND

  1096 # endif

  1098 # if defined (_STLP_OWN_IOSTREAMS)

  1099 #  define _STLP_NEW_IO_NAMESPACE _STLP_STD

  1100 #  define _STLP_NO_WIDE_STREAMS  _STLP_NO_WCHAR_T

  1101 # else

  1102 #  ifdef _STLP_USE_NEW_IOSTREAMS

  1103 #   define _STLP_NEW_IO_NAMESPACE _STLP_VENDOR_STD

  1104 #   ifdef _STLP_NO_NATIVE_WIDE_STREAMS

  1105 #    define _STLP_NO_WIDE_STREAMS _STLP_NO_NATIVE_WIDE_STREAMS

  1106 #   endif /* _STLP_NO_NATIVE_WIDE_STREAMS */

  1107 #  else

  1108 #   define _STLP_NO_WIDE_STREAMS

  1109 #   define _STLP_NEW_IO_NAMESPACE

  1110 #  endif

  1111 # endif

  1113 #ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE

  1114 # define _STLP_RELOPS_OPERATORS(_TMPL, _TP) \

  1115 _TMPL inline bool _STLP_CALL operator!=(const _TP& __x, const _TP& __y) {return !(__x == __y);}\

  1116 _TMPL inline bool _STLP_CALL operator>(const _TP& __x, const _TP& __y)  {return __y < __x;}\

  1117 _TMPL inline bool _STLP_CALL operator<=(const _TP& __x, const _TP& __y) { return !(__y < __x);}\

  1118 _TMPL inline bool _STLP_CALL operator>=(const _TP& __x, const _TP& __y) { return !(__x < __y);}

  1119 # else

  1120 #  define _STLP_RELOPS_OPERATORS(_TMPL, _TP)

  1121 # endif

  1123 # if defined (_STLP_FULL_ADL_IMPLEMENTED) && defined (_STLP_NO_OWN_IOSTREAMS)

  1124 #  error "Invalid configuration, STLport wrapper iostream mode can't be used with compiler"\

  1125          "implementing full Argument Dependent Lookup. Please remove _STLP_NO_OWN_IOSTREAMS switch"\

  1126          "and build STLport library."

  1127 # endif /* _STLP_FULL_ADL_IMPLEMENTED && _STLP_NO_OWN_IOSTREAMS */

  1129 # if defined ( _STLP_USE_ABBREVS )

  1130 #  include <stl/_abbrevs.h>

  1131 # endif

  1133 /* some cleanup */

  1134 # undef _STLP_DONT_USE_BOOL_TYPEDEF

  1135 # undef _STLP_YVALS_H

  1136 # undef _STLP_LOOP_INLINE_PROBLEMS

  1137 # undef _STLP_NEED_EXPLICIT

  1138 # undef _STLP_NEED_TYPENAME

  1139 # undef _STLP_NO_NEW_STYLE_CASTS

  1140 # undef __AUTO_CONFIGURED

  1142 #   define _STLP_EXPORT_METHOD

  1143 #   define _STLP_EXPORT_CONCRETE_METHOD

  1144 #   define _STLP_EXPORT_METHOD

  1145 #   define _STLP_EXPORT_CONCRETE_METHOD

  1146 #   define _STLP_IMPORT_METHOD

  1148 #ifdef __SYMBIAN32__

  1149 #define __STLP_NO_WRITE_SIDE_BUFFERING__

  1150 #endif

  1151 #endif /* _STLP_CONFIG_H */

  1153 /*

  1154  Local Variables:

  1155  mode:C++

  1156  End:

  1157 */

author	William Roberts <williamr@symbian.org>
	Wed, 31 Mar 2010 12:33:34 +0100
branch	Symbian3
changeset 4	837f303aceeb
parent 0	061f57f2323e
permissions	-rw-r--r--