1 /* 2 * 3 * Copyright (c) 1994 4 * Hewlett-Packard Company 5 * 6 * Copyright (c) 1996,1997 7 * Silicon Graphics Computer Systems, Inc. 8 * 9 * Copyright (c) 1997 10 * Moscow Center for SPARC Technology 11 * 12 * Copyright (c) 1999 13 * Boris Fomitchev 14 * 15 * This material is provided "as is", with absolutely no warranty expressed 16 * or implied. Any use is at your own risk. 17 * 18 * Permission to use or copy this software for any purpose is hereby granted 19 * without fee, provided the above notices are retained on all copies. 20 * Permission to modify the code and to distribute modified code is granted, 21 * provided the above notices are retained, and a notice that the code was 22 * modified is included with the above copyright notice. 23 * 24 */ 25 26 #ifndef _STLP_FEATURES_H 27 #define _STLP_FEATURES_H 28 29 #ifndef RC_INVOKED 30 31 /* 32 * Purpose of this file: 33 * 34 * Defines all STLport settings. 35 * This file is actually a wrapper : it includes compiler-specific 36 * settings from <config/stlcomp.h> 37 * and user-defined settings from <config/user_config.h>. 38 * See <config/stl_mycomp.h> and <config/user_config.h> for the description 39 * of those macros 40 * 41 */ 42 43 /* Definition of the STLport version informations */ 44 #include <stl/_stlport_version.h> 45 46 /* Other macros defined by this file: 47 48 * bool, true, and false, if _STLP_NO_BOOL is defined. 49 * typename, as a null macro if it's not already a keyword. 50 * explicit, as a null macro if it's not already a keyword. 51 * namespace-related macros (_STLP_STD, _STLP_BEGIN_NAMESPACE, etc.) 52 * exception-related macros (_STLP_TRY, _STLP_UNWIND, etc.) 53 * _STLP_ASSERT, either as a test or as a null macro, depending on 54 whether or not _STLP_ASSERTIONS is defined. 55 */ 56 57 /* Definition of the 2 STLport debug levels */ 58 #define _STLP_STLPORT_DBG_LEVEL 1 59 #define _STLP_STANDARD_DBG_LEVEL 2 60 61 /* Placeholder for user to override settings. 62 * It could be also used to mask settings from 63 * different directories. 64 */ 65 #include <stl/config/user_config.h> 66 67 #if defined (_STLP_DEBUG) && !defined (_STLP_DEBUG_LEVEL) 68 # define _STLP_DEBUG_LEVEL _STLP_STLPORT_DBG_LEVEL 69 #endif 70 71 #if defined (__BUILDING_STLPORT) 72 /* For the STLport implementation we can use everything: 73 */ 74 # if defined (_STLP_NO_ANACHRONISMS) 75 # undef _STLP_NO_ANACHRONISMS 76 # endif 77 # if defined (_STLP_NO_EXTENSIONS) 78 # undef _STLP_NO_EXTENSIONS 79 # endif 80 /* Moreover there are things that have no sens: 81 */ 82 # if defined (_STLP_NO_IOSTREAMS) 83 # error If you do not use iostreams you do not need to build the STLport library. 84 # endif 85 #endif 86 87 /* ========================================================= */ 88 /* This file is used for compatibility; it accepts old-style config 89 switches */ 90 #include <stl/config/compat.h> 91 92 /* Common configuration file for this particular installation. */ 93 #include <stl/config/host.h> 94 95 /* Operational Environment specific */ 96 #include <stl/config/_system.h> 97 98 /* ========================================================= */ 99 100 /* some fixes to configuration. This also includes modifications 101 * of STLport switches depending on compiler flags, 102 * or settings applicable to a group of compilers, such as 103 * to all who use EDG front-end. 104 */ 105 #include <stl/config/stl_confix.h> 106 107 #if !defined (_STLP_NO_MEMBER_TEMPLATES) && !defined (_STLP_MEMBER_TEMPLATES) 108 # define _STLP_MEMBER_TEMPLATES 1 109 #endif 110 111 #if !defined (_STLP_NO_MEMBER_TEMPLATE_CLASSES) && !defined (_STLP_MEMBER_TEMPLATE_CLASSES) 112 # define _STLP_MEMBER_TEMPLATE_CLASSES 1 113 #endif 114 115 #if defined (_STLP_NO_MEMBER_TEMPLATE_CLASSES) && !defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE) 116 # define _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE 1 117 #endif 118 119 #if !defined (_STLP_NO_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) 120 # define _STLP_CLASS_PARTIAL_SPECIALIZATION 1 121 #endif 122 123 #if !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) && !defined (_STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER) 124 # define _STLP_FUNCTION_TMPL_PARTIAL_ORDER 1 125 #endif 126 127 #if !defined (_STLP_DONT_USE_SHORT_STRING_OPTIM) && !defined (_STLP_USE_SHORT_STRING_OPTIM) 128 # define _STLP_USE_SHORT_STRING_OPTIM 1 129 #endif 130 131 #if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_NO_EXTENSIONS) && \ 132 !defined (_STLP_NO_CONTAINERS_EXTENSION) && !defined (_STLP_USE_CONTAINERS_EXTENSION) 133 # define _STLP_USE_CONTAINERS_EXTENSION 134 #endif 135 136 #if defined (_STLP_USE_CONTAINERS_EXTENSION) 137 # define _STLP_TEMPLATE_FOR_CONT_EXT template <class _KT> 138 #else 139 # define _STLP_TEMPLATE_FOR_CONT_EXT 140 #endif 141 142 #if defined (_STLP_USE_PTR_SPECIALIZATIONS) && \ 143 (defined (_STLP_NO_CLASS_PARTIAL_SPECIALIZATION) && defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)) 144 # error Sorry but according the STLport settings your compiler can not support the pointer specialization feature. 145 #endif 146 147 #if defined (_STLP_WHOLE_NATIVE_STD) && defined (_STLP_NO_OWN_NAMESPACE) 148 # error Sorry but asking for both STLport to be in the real std namespace and also having STLport import all native std stuff \ 149 is invalid, chose one or none. 150 #endif 151 152 #if defined (_STLP_VERBOSE) && !defined (_STLP_VERBOSE_MODE_SUPPORTED) 153 # error Sorry but the verbose mode is not implemented for your compiler. 154 #endif 155 156 #if defined (_STLP_NO_IOSTREAMS) && \ 157 !defined (_STLP_USE_NEWALLOC) && !defined (_STLP_USE_MALLOC) 158 # define _STLP_USE_NEWALLOC 159 #endif 160 161 #if !defined (_STLP_BIG_ENDIAN) && !defined (_STLP_LITTLE_ENDIAN) 162 # if defined (_MIPSEB) || defined (__sparc) || defined (_AIX) || \ 163 defined (__hpux) || defined (macintosh) || defined (_MAC) 164 # define _STLP_BIG_ENDIAN 1 165 # elif defined (__i386) || defined (_M_IX86) || defined (_M_ARM) || defined (_M_ARM64) || \ 166 defined (__amd64__) || defined (_M_AMD64) || defined (__x86_64__) || \ 167 defined (__alpha__) 168 # define _STLP_LITTLE_ENDIAN 1 169 # elif defined (__ia64__) 170 /* itanium allows both settings (for instance via gcc -mbig-endian) - hence a seperate check is required */ 171 # if defined (__BIG_ENDIAN__) 172 # define _STLP_BIG_ENDIAN 1 173 # else 174 # define _STLP_LITTLE_ENDIAN 1 175 # endif 176 # else 177 # error "can't determine endianess" 178 # endif 179 #endif /* _STLP_BIG_ENDIAN */ 180 181 /* ========================================================== 182 * final workaround tuning based on given flags 183 * ========================================================== */ 184 185 #ifndef _STLP_UINT32_T 186 # define _STLP_UINT32_T unsigned long 187 #endif 188 #ifndef _STLP_ABORT 189 # define _STLP_ABORT() abort() 190 #endif 191 192 #if !defined (_STLP_HAS_NO_NAMESPACES) 193 # if defined _STLP_NO_NAMESPACES 194 # undef _STLP_USE_NAMESPACES 195 # else 196 /* assume it as the default, turn it off later if NO_NAMESPACES selected */ 197 # undef _STLP_USE_NAMESPACES 198 # define _STLP_USE_NAMESPACES 1 199 # endif 200 #endif 201 202 #if defined (_STLP_NO_IOSTREAMS) 203 # define _STLP_USE_NO_IOSTREAMS 204 #endif 205 206 /* Operating system recognition (basic) */ 207 #if (defined(__unix) || defined(__linux__) || defined(__QNX__) || defined(_AIX) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__Lynx__) || defined(__hpux) || defined(__sgi)) && \ 208 !defined (_STLP_UNIX) 209 # define _STLP_UNIX 1 210 #endif /* __unix */ 211 212 #if !defined (_STLP_NO_LONG_DOUBLE) 213 # define _STLP_LONGEST_FLOAT_TYPE long double 214 #else 215 # define _STLP_LONGEST_FLOAT_TYPE double 216 #endif 217 218 /* Native headers access macros */ 219 #if !defined (_STLP_HAS_INCLUDE_NEXT) 220 # include <stl/config/_native_headers.h> 221 #endif 222 223 /* shared library tune-up */ 224 225 #if defined (__BUILDING_STLPORT) 226 /* if we are rebuilding right now, place everything here */ 227 # undef _STLP_DESIGNATED_DLL 228 # define _STLP_DESIGNATED_DLL 1 229 #endif 230 231 /* Use own namespace always if possible and not explicitly instructed otherwise */ 232 #if defined (_STLP_USE_NAMESPACES) && !defined (_STLP_BROKEN_USING_DIRECTIVE) && \ 233 !defined (_STLP_NO_OWN_NAMESPACE) 234 # undef _STLP_USE_OWN_NAMESPACE 235 # define _STLP_USE_OWN_NAMESPACE 1 236 #else 237 # undef _STLP_WHOLE_NATIVE_STD 238 #endif 239 240 #if !defined (_NOTHREADS) && !defined (_STLP_THREADS_DEFINED) 241 242 # if defined (_PTHREADS) 243 # define _STLP_PTHREADS 244 # define _STLP_THREADS 245 # endif 246 # if defined (_UITHREADS) 247 # define _STLP_UITHREADS 248 # define _STLP_THREADS 249 # endif 250 251 # if defined (_STLP_WIN32) && !defined (_STLP_PTHREADS) 252 # define _STLP_WIN32THREADS 1 253 # elif ((defined (__sun) && !defined (__linux__)) || defined (_UITHREADS) ) && \ 254 !defined(_STLP_PTHREADS) 255 # define _STLP_UITHREADS 256 # else 257 # define _STLP_PTHREADS 258 # endif /* __sgi */ 259 # define _STLP_THREADS_DEFINED 260 #endif 261 262 #if (defined (_REENTRANT) || defined (_THREAD_SAFE)) && !defined (_STLP_THREADS) 263 # define _STLP_THREADS 264 #endif 265 266 #ifndef _STLP_STATIC_MUTEX 267 # define _STLP_STATIC_MUTEX _STLP_mutex_base 268 #endif 269 270 #if (defined (_MFC_VER) || defined (_AFXDLL)) && !defined (_STLP_USE_MFC) 271 # define _STLP_USE_MFC 1 272 #endif 273 274 #if defined (_STLP_THREADS) 275 # define _STLP_VOLATILE volatile 276 #else 277 # define _STLP_VOLATILE 278 #endif 279 280 #if !defined (_STLP_USE_NEW_C_HEADERS) && !defined (_STLP_HAS_NO_NEW_C_HEADERS) 281 # define _STLP_USE_NEW_C_HEADERS 282 #endif 283 /* disable new-style headers if requested */ 284 #if defined (_STLP_NO_NEW_C_HEADERS) 285 # undef _STLP_USE_NEW_C_HEADERS 286 #endif 287 288 #if defined (_STLP_BASE_TYPEDEF_BUG) 289 # undef _STLP_BASE_TYPEDEF_OUTSIDE_BUG 290 # define _STLP_BASE_TYPEDEF_OUTSIDE_BUG 1 291 #endif 292 293 #if defined (_STLP_NESTED_TYPE_PARAM_BUG) 294 # define _STLP_GLOBAL_NESTED_RETURN_TYPE_PARAM_BUG 295 #endif 296 297 /* SUNpro 4.2 inline string literal bug */ 298 #ifdef _STLP_INLINE_STRING_LITERAL_BUG 299 # define _STLP_FIX_LITERAL_BUG(__x) __x = __x; 300 #else 301 # define _STLP_FIX_LITERAL_BUG(__x) 302 #endif 303 304 #if defined (_STLP_NON_TYPE_TMPL_PARAM_BUG) 305 # undef _STLP_NO_DEFAULT_NON_TYPE_PARAM 306 # define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1 307 #endif 308 309 #if !defined (_STLP_STATIC_ASSERT) 310 /* Some compiler support 0 size array so we use negative size array to generate 311 * a compilation time error. 312 */ 313 # define _STLP_STATIC_ASSERT(expr) typedef char __static_assert[expr ? 1 : -1]; 314 #endif 315 316 /* apple mpw exception handling bug */ 317 #ifndef _STLP_MPWFIX_TRY 318 # define _STLP_MPWFIX_TRY 319 #endif 320 #ifndef _STLP_MPWFIX_CATCH 321 # define _STLP_MPWFIX_CATCH 322 #endif 323 #ifndef _STLP_MPWFIX_CATCH_ACTION 324 # define _STLP_MPWFIX_CATCH_ACTION(action) 325 #endif 326 327 #if !defined (_STLP_WEAK) 328 # define _STLP_WEAK 329 #endif 330 331 /* default parameters as template types derived from arguments ( not always supported ) */ 332 #if defined (_STLP_LIMITED_DEFAULT_TEMPLATES) 333 # define _STLP_DFL_TMPL_PARAM( classname, defval ) class classname 334 #else 335 # if !defined (_STLP_DEFAULT_TYPE_PARAM) 336 # define _STLP_DEFAULT_TYPE_PARAM 1 337 # endif 338 # define _STLP_DFL_TMPL_PARAM( classname, defval ) class classname = defval 339 #endif 340 341 #if defined (_STLP_LIMITED_DEFAULT_TEMPLATES) 342 # define _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_Key, _Tp ) class _Alloc 343 #else 344 # define _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_Key, _Tp ) \ 345 class _Alloc = allocator< pair < _Key, _Tp > > 346 #endif 347 348 /* default parameters as complete types */ 349 #if defined (_STLP_DEFAULT_TYPE_PARAM) 350 # define _STLP_DFL_TYPE_PARAM( classname, defval ) class classname = defval 351 # define _STLP_DFL_NON_TYPE_PARAM(type,name,val) type name = val 352 #else 353 # define _STLP_DFL_TYPE_PARAM( classname, defval ) class classname 354 # define _STLP_DFL_NON_TYPE_PARAM(type,name,val) type name 355 #endif 356 357 /* SGI compatibility */ 358 359 #ifdef _STLP_NO_WCHAR_T 360 # ifndef _STLP_NO_NATIVE_WIDE_STREAMS 361 # define _STLP_NO_NATIVE_WIDE_STREAMS 1 362 # endif 363 #else 364 # define _STLP_HAS_WCHAR_T 1 365 #endif 366 367 #if !defined (_STLP_NO_AT_MEMBER_FUNCTION) 368 # define _STLP_CAN_THROW_RANGE_ERRORS 1 369 #endif 370 371 /* debug mode tool */ 372 #if defined (_STLP_DEBUG) 373 # define _STLP_NON_DBG_NAME(X) _NonDbg_##X 374 #endif 375 376 /* pointer specialization tool */ 377 #if defined (_STLP_USE_PTR_SPECIALIZATIONS) 378 # define _STLP_PTR_IMPL_NAME(X) _Impl_##X 379 #endif 380 381 #if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) || \ 382 defined (_STLP_SIGNAL_RUNTIME_COMPATIBILITY) || defined (_STLP_CHECK_RUNTIME_COMPATIBILITY) 383 # define _STLP_NO_MEM_T_NAME(X) _NoMemT_##X 384 #endif 385 386 /* this always mean the C library is in global namespace */ 387 #if defined (_STLP_HAS_NO_NEW_C_HEADERS) && !defined (_STLP_VENDOR_GLOBAL_CSTD) 388 # define _STLP_VENDOR_GLOBAL_CSTD 1 389 #endif 390 391 /* Depending of whether compiler supports namespaces, 392 * tune the parameters for vendor-supplied libraries. 393 * This section is guarded by _STLP_HAS_NO_NAMESPACES, not by _STLP_USE_NAMESPACES, 394 * since it depends only on the native features, not on user's preference whether 395 * to use namespace for STLport or not. 396 */ 397 #if !defined (_STLP_HAS_NO_NAMESPACES) 398 /* Import some vendor's headers into corresponding STLport ones if they might be needed 399 * (if we wrap native iostreams and use namepace other than std::) */ 400 # if defined (_STLP_WHOLE_NATIVE_STD) 401 # define _STLP_IMPORT_VENDOR_STD 1 402 # endif 403 404 /* if using stlport:: namespace or if C library stuff is not in vendor's std::, 405 * try importing 'em. 406 * MSVC has ambiguity problem when we try to import C-style std:: stuff back into global namespace */ 407 # if defined (_STLP_USE_NAMESPACES) && (defined(_STLP_USE_OWN_NAMESPACE) || defined (_STLP_VENDOR_GLOBAL_CSTD)) 408 # define _STLP_IMPORT_VENDOR_CSTD 1 409 # endif 410 411 # if defined (_STLP_NO_USING_FOR_GLOBAL_FUNCTIONS) && !defined (_STLP_DO_IMPORT_CSTD_FUNCTIONS) 412 # define _STLP_NO_CSTD_FUNCTION_IMPORTS 413 # endif 414 415 # define _STLP_USING_NAMESPACE(x) using namespace x ; 416 417 namespace std { } 418 namespace __std_alias = std; 419 420 /* assume std:: namespace for C++ std library if not being told otherwise */ 421 # if defined (_STLP_VENDOR_GLOBAL_STD) 422 # define _STLP_VENDOR_STD 423 # else 424 # define _STLP_VENDOR_STD std 425 # endif 426 427 /* tune things that come from C library */ 428 # if defined (_STLP_VENDOR_GLOBAL_CSTD) || !defined(_STLP_USE_NEW_C_HEADERS) 429 /* in old-style headers, C functions go to global scope. */ 430 # define _STLP_VENDOR_CSTD 431 # define _STLP_USING_VENDOR_CSTD 432 # else 433 # define _STLP_VENDOR_CSTD _STLP_VENDOR_STD 434 # define _STLP_USING_VENDOR_CSTD _STLP_USING_NAMESPACE(_STLP_VENDOR_CSTD) 435 # endif /* _STLP_VENDOR_CSTD */ 436 /* exception, typeinfo, new - always come from the vendor */ 437 # if !defined (_STLP_VENDOR_EXCEPT_STD) 438 # if defined (_STLP_VENDOR_GLOBAL_EXCEPT_STD) 439 # define _STLP_VENDOR_EXCEPT_STD 440 # else 441 # define _STLP_VENDOR_EXCEPT_STD _STLP_VENDOR_STD 442 # endif 443 # endif 444 # define _STLP_OLD_IO_NAMESPACE 445 # if !defined (_STLP_VENDOR_MB_NAMESPACE) 446 # define _STLP_VENDOR_MB_NAMESPACE _STLP_VENDOR_CSTD 447 # endif 448 #else 449 /* compiler has no namespace support */ 450 # define _STLP_VENDOR_STD 451 # define _STLP_VENDOR_CSTD 452 # define _STLP_USING_NAMESPACE(x) 453 # define _STLP_USING_VENDOR_CSTD 454 # define _STLP_VENDOR_EXCEPT_STD 455 #endif 456 457 #if defined (_STLP_USE_NAMESPACES) 458 459 # if defined (_STLP_USE_OWN_NAMESPACE) 460 # if !defined (_STLP_STD_NAME) 461 # if !defined (_STLP_DEBUG) 462 # if !defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB) 463 # ifndef _STLP_THREADS 464 # define _STLP_STD_NAME stlpmtx_std 465 # else 466 # define _STLP_STD_NAME stlp_std 467 # endif 468 # else 469 # ifndef _STLP_THREADS 470 # define _STLP_STD_NAME stlpxmtx_std 471 # else 472 # define _STLP_STD_NAME stlpx_std 473 # endif 474 # endif 475 # else 476 /* 477 * The STLport debug mode is binary incompatible with the other modes, 478 * lets make it clear on the STLport namespace to generate link errors rather 479 * than runtime ones. 480 */ 481 # if !defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB) 482 # ifndef _STLP_THREADS 483 # define _STLP_STD_NAME stlpdmtx_std 484 # else 485 # define _STLP_STD_NAME stlpd_std 486 # endif 487 # else 488 # ifndef _STLP_THREADS 489 # define _STLP_STD_NAME stlpdxmtx_std 490 # else 491 # define _STLP_STD_NAME stlpdx_std 492 # endif 493 # endif 494 # endif 495 # endif 496 namespace _STLP_STD_NAME { } 497 # else 498 # define _STLP_STD_NAME std 499 # endif /* _STLP_USE_OWN_NAMESPACE */ 500 501 # define _STLP_BEGIN_NAMESPACE namespace _STLP_STD_NAME { 502 # define _STLP_BEGIN_TR1_NAMESPACE namespace tr1 { 503 # define _STLP_END_NAMESPACE } 504 505 /* decide whether or not we use separate namespace for rel ops */ 506 # if defined (_STLP_NO_RELOPS_NAMESPACE) 507 # define _STLP_BEGIN_RELOPS_NAMESPACE _STLP_BEGIN_NAMESPACE namespace rel_ops {} 508 # define _STLP_END_RELOPS_NAMESPACE } 509 # else 510 /* Use std::rel_ops namespace */ 511 # define _STLP_BEGIN_RELOPS_NAMESPACE _STLP_BEGIN_NAMESPACE namespace rel_ops { 512 # define _STLP_END_RELOPS_NAMESPACE } } 513 # define _STLP_USE_SEPARATE_RELOPS_NAMESPACE 514 # endif /* Use std::rel_ops namespace */ 515 516 # define _STLP_STD ::_STLP_STD_NAME 517 # if !defined (_STLP_TR1) 518 # define _STLP_TR1 _STLP_STD::tr1:: 519 # endif 520 521 # if !defined (_STLP_DONT_USE_PRIV_NAMESPACE) 522 # define _STLP_PRIV_NAME priv 523 # define _STLP_PRIV _STLP_STD::_STLP_PRIV_NAME:: 524 # define _STLP_MOVE_TO_PRIV_NAMESPACE namespace _STLP_PRIV_NAME { 525 # define _STLP_MOVE_TO_STD_NAMESPACE } 526 # else 527 # if !defined (_STLP_PRIV) 528 # define _STLP_PRIV _STLP_STD:: 529 # endif 530 # define _STLP_MOVE_TO_PRIV_NAMESPACE 531 # define _STLP_MOVE_TO_STD_NAMESPACE 532 # endif 533 534 /* Official STLport namespace when std is not redefined. 535 * Here we don't use a macro because we do not need it and because 536 * stlport is used as file name by boost and folder name under beos: 537 */ 538 namespace stlport = _STLP_STD_NAME; 539 540 /* Backward compatibility: 541 */ 542 namespace _STL = _STLP_STD_NAME; 543 #undef __STLPORT_NAMESPACE 544 #define __STLPORT_NAMESPACE _STLP_STD_NAME 545 546 #else /* _STLP_USE_NAMESPACES */ 547 /* STLport is being put into global namespace */ 548 # define _STLP_STD 549 # define _STLP_PRIV 550 # define _STLP_TR1 551 # define _STLP_BEGIN_NAMESPACE 552 # define _STLP_BEGIN_TR1_NAMESPACE 553 # define _STLP_END_NAMESPACE 554 # define _STLP_MOVE_TO_PRIV_NAMESPACE 555 # define _STLP_MOVE_TO_STD_NAMESPACE 556 557 /* boris : it was found out that _STLP_USE_SEPARATE_RELOPS_NAMESPACE 558 causes less problems than having relational operator templates in global namespace 559 Please define _STLP_NO_RELOPS_NAMESPACE in config/user_config.h if your code rely on them. */ 560 # if !defined (_STLP_NO_RELOPS_NAMESPACE) 561 # define _STLP_USE_SEPARATE_RELOPS_NAMESPACE 562 # endif 563 # define _STLP_BEGIN_RELOPS_NAMESPACE 564 # define _STLP_END_RELOPS_NAMESPACE 565 # undef _STLP_USE_OWN_NAMESPACE 566 #endif /* _STLP_USE_NAMESPACES */ 567 568 #define STLPORT_CSTD _STLP_VENDOR_CSTD 569 #define STLPORT _STLP_STD_NAME 570 571 #if defined(_STLP_BOGUS_TEMPLATE_TYPE_MATCHING_BUG) 572 # define _STLP_SIMPLE_TYPE(T) _stl_trivial_proxy<T> 573 #else 574 # define _STLP_SIMPLE_TYPE(T) T 575 #endif 576 577 #ifndef _STLP_RAND48 578 # define _STLP_NO_DRAND48 579 #endif 580 581 /* advanced keywords usage */ 582 #define __C_CAST(__x, __y) ((__x)(__y)) 583 #ifndef _STLP_NO_NEW_STYLE_CASTS 584 # define __CONST_CAST(__x,__y) const_cast<__x>(__y) 585 # define __STATIC_CAST(__x,__y) static_cast<__x>(__y) 586 # define __REINTERPRET_CAST(__x,__y) reinterpret_cast<__x>(__y) 587 #else 588 # define __STATIC_CAST(__x,__y) __C_CAST(__x, __y) 589 # define __CONST_CAST(__x,__y) __C_CAST(__x, __y) 590 # define __REINTERPRET_CAST(__x,__y) __C_CAST(__x, __y) 591 #endif 592 593 #if defined (_STLP_NEED_TYPENAME) && ! defined (typename) 594 # define typename 595 #endif 596 597 #if defined (_STLP_NEED_TYPENAME) || defined (_STLP_NO_TYPENAME_ON_RETURN_TYPE ) 598 # define _STLP_TYPENAME_ON_RETURN_TYPE 599 #else 600 # define _STLP_TYPENAME_ON_RETURN_TYPE typename 601 #endif 602 603 #ifdef _STLP_NO_TYPENAME_IN_TEMPLATE_HEADER 604 # define _STLP_HEADER_TYPENAME 605 #else 606 # define _STLP_HEADER_TYPENAME typename 607 #endif 608 609 #ifdef _STLP_NO_TYPENAME_BEFORE_NAMESPACE 610 # define _STLP_TYPENAME 611 #else 612 # define _STLP_TYPENAME typename 613 #endif 614 615 #ifndef _STLP_NO_MEMBER_TEMPLATE_KEYWORD 616 # define _STLP_TEMPLATE template 617 #else 618 # define _STLP_TEMPLATE 619 #endif 620 621 #if defined (_STLP_USE_CONTAINERS_EXTENSION) 622 # define _STLP_KEY_TYPE_FOR_CONT_EXT(type) 623 # define _STLP_TEMPLATE_FOR_CONT_EXT template <class _KT> 624 #else 625 # define _STLP_KEY_TYPE_FOR_CONT_EXT(type) typedef type _KT; 626 # define _STLP_TEMPLATE_FOR_CONT_EXT 627 #endif 628 629 #if defined (_STLP_NEED_EXPLICIT) && !defined (explicit) 630 # define explicit 631 #endif 632 633 #if !defined (_STLP_NEED_MUTABLE) 634 # define _STLP_MUTABLE(type, x) x 635 #else 636 # define _STLP_MUTABLE(type, x) __CONST_CAST(type*, this)->x 637 # define mutable 638 #endif 639 640 #if defined (_STLP_NO_SIGNED_BUILTINS) 641 /* old HP-UX doesn't understand "signed" keyword */ 642 # define signed 643 #endif 644 645 #if defined (_STLP_LOOP_INLINE_PROBLEMS) 646 # define _STLP_INLINE_LOOP 647 #else 648 # define _STLP_INLINE_LOOP inline 649 #endif 650 651 #ifndef _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 652 # define _STLP_TEMPLATE_NULL template<> 653 #else 654 # define _STLP_TEMPLATE_NULL 655 #endif 656 657 #ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER 658 # define _STLP_OPERATOR_TEMPLATE 659 #else 660 # define _STLP_OPERATOR_TEMPLATE _STLP_TEMPLATE_NULL 661 #endif 662 663 #ifndef _STLP_CLASS_PARTIAL_SPECIALIZATION 664 /* unless we have other compiler problem, try simulating partial spec here */ 665 # if !defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS) 666 # define _STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS 667 # endif 668 /* For your own iterators, please use inheritance from iterator<> instead of these obsolete queries. */ 669 # if (defined (_STLP_NESTED_TYPE_PARAM_BUG) || !defined (_STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)) 670 # if ! defined ( _STLP_USE_OLD_HP_ITERATOR_QUERIES ) 671 # define _STLP_USE_OLD_HP_ITERATOR_QUERIES 672 # endif 673 # elif defined ( _STLP_NO_ANACHRONISMS ) 674 # undef _STLP_USE_OLD_HP_ITERATOR_QUERIES 675 # endif 676 #endif 677 678 #ifndef _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 679 # define _STLP_NULL_TMPL_ARGS <> 680 # else 681 # define _STLP_NULL_TMPL_ARGS 682 #endif 683 684 #if !defined (_STLP_ALLOCATOR_TYPE_DFL) 685 # if defined (_STLP_DONT_SUP_DFLT_PARAM) 686 # define _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS 687 # endif 688 # if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS) 689 # define _STLP_ALLOCATOR_TYPE_DFL 690 # else 691 # define _STLP_ALLOCATOR_TYPE_DFL = allocator_type() 692 # endif 693 #endif 694 695 /* When the compiler do not correctly initialized the basic types value in default parameters we prefer 696 * to avoid them to be able to correct this bug. 697 */ 698 #if defined (_STLP_DEF_CONST_DEF_PARAM_BUG) 699 # define _STLP_DONT_SUP_DFLT_PARAM 1 700 #endif 701 702 #if defined (__SGI_STL_NO_ARROW_OPERATOR) && ! defined (_STLP_NO_ARROW_OPERATOR) 703 # define _STLP_NO_ARROW_OPERATOR 704 #endif 705 706 #if !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) 707 # if !(defined (_STLP_NO_ARROW_OPERATOR)) && \ 708 !defined (_STLP_NO_MSVC50_COMPATIBILITY) && !defined (_STLP_MSVC50_COMPATIBILITY) 709 /* this one is needed for proper reverse_iterator<> operator ->() handling */ 710 # define _STLP_MSVC50_COMPATIBILITY 1 711 # endif 712 #endif 713 714 #if defined ( _STLP_CLASS_PARTIAL_SPECIALIZATION ) 715 # if (defined(__IBMCPP__) && (500 <= __IBMCPP__) && (__IBMCPP__ < 600) ) 716 # define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \ 717 typedef typename _STLP_STD :: reverse_iterator<const_iterator> const_reverse_iterator; \ 718 typedef typename _STLP_STD :: reverse_iterator<iterator> reverse_iterator 719 # elif (defined (__sgi) && ! defined (__GNUC__)) || defined (__SUNPRO_CC) || defined (__xlC__) 720 # define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \ 721 typedef _STLP_STD:: _STLP_TEMPLATE reverse_iterator<const_iterator> const_reverse_iterator; \ 722 typedef _STLP_STD:: _STLP_TEMPLATE reverse_iterator<iterator> reverse_iterator 723 # else 724 # define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \ 725 typedef _STLP_STD::reverse_iterator<const_iterator> const_reverse_iterator; \ 726 typedef _STLP_STD::reverse_iterator<iterator> reverse_iterator 727 # endif 728 #else /* _STLP_CLASS_PARTIAL_SPECIALIZATION */ 729 # if defined (_STLP_MSVC50_COMPATIBILITY) 730 # define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \ 731 typedef _STLP_STD::__reverse_iterator<const_iterator, value_type, const_reference, \ 732 const_pointer, difference_type> const_reverse_iterator; \ 733 typedef _STLP_STD::__reverse_iterator<iterator, value_type, reference, pointer, difference_type> \ 734 reverse_iterator 735 # else 736 # define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \ 737 typedef _STLP_STD::__reverse_iterator<const_iterator, value_type, const_reference, \ 738 difference_type> const_reverse_iterator; \ 739 typedef _STLP_STD::__reverse_iterator<iterator, value_type, \ 740 reference, difference_type> \ 741 reverse_iterator 742 # endif 743 #endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */ 744 745 #define _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS \ 746 _STLP_DECLARE_REVERSE_ITERATORS(reverse_bidirectional_iterator) 747 #define _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS \ 748 _STLP_DECLARE_REVERSE_ITERATORS(reverse_iterator) 749 750 #define __IMPORT_CONTAINER_TYPEDEFS(_Super) \ 751 typedef typename _Super::value_type value_type; \ 752 typedef typename _Super::size_type size_type; \ 753 typedef typename _Super::difference_type difference_type; \ 754 typedef typename _Super::reference reference; \ 755 typedef typename _Super::const_reference const_reference; \ 756 typedef typename _Super::pointer pointer; \ 757 typedef typename _Super::const_pointer const_pointer; \ 758 typedef typename _Super::allocator_type allocator_type; 759 760 761 #define __IMPORT_ITERATORS(_Super) \ 762 typedef typename _Super::iterator iterator; \ 763 typedef typename _Super::const_iterator const_iterator; 764 765 #define __IMPORT_REVERSE_ITERATORS(_Super) \ 766 typedef typename _Super::const_reverse_iterator const_reverse_iterator; \ 767 typedef typename _Super::reverse_iterator reverse_iterator; 768 769 #define __IMPORT_SUPER_COPY_ASSIGNMENT(__derived_name, _Self, _SUPER) \ 770 __derived_name(const _Super& __x) : _SUPER(__x) {} \ 771 _Self& operator=(const _Super& __x) { \ 772 *(_Super*)this = __x; \ 773 return *this; \ 774 } \ 775 __derived_name(const _Self& __x) : _SUPER(__x) {} \ 776 _Self& operator=(const _Self& __x) { \ 777 *(_Super*)this = __x; \ 778 return *this; \ 779 } 780 781 #define __IMPORT_WITH_ITERATORS(_Super) \ 782 __IMPORT_CONTAINER_TYPEDEFS(_Super) __IMPORT_ITERATORS(_Super) 783 784 #define __IMPORT_WITH_REVERSE_ITERATORS(_Super) \ 785 __IMPORT_WITH_ITERATORS(_Super) __IMPORT_REVERSE_ITERATORS(_Super) 786 787 #if defined (_STLP_TRIVIAL_CONSTRUCTOR_BUG) 788 # define __TRIVIAL_CONSTRUCTOR(__type) __type() {} 789 #else 790 # define __TRIVIAL_CONSTRUCTOR(__type) 791 #endif 792 793 #if defined (_STLP_TRIVIAL_DESTRUCTOR_BUG) 794 # define __TRIVIAL_DESTRUCTOR(__type) ~__type() {} 795 #else 796 # define __TRIVIAL_DESTRUCTOR(__type) 797 #endif 798 799 #define __TRIVIAL_STUFF(__type) \ 800 __TRIVIAL_CONSTRUCTOR(__type) __TRIVIAL_DESTRUCTOR(__type) 801 802 #if defined (_STLP_STATIC_CONST_INIT_BUG) 803 # define _STLP_STATIC_CONSTANT(__type, __assignment) enum { __assignment } 804 #else 805 # define _STLP_STATIC_CONSTANT(__type, __assignment) static const __type __assignment 806 #endif 807 808 #if defined (_STLP_HAS_NO_EXCEPTIONS) 809 # define _STLP_NO_EXCEPTIONS 810 #endif 811 812 #if !defined (_STLP_DONT_USE_EXCEPTIONS) && !defined (_STLP_NO_EXCEPTIONS) && !defined (_STLP_USE_EXCEPTIONS) 813 # define _STLP_USE_EXCEPTIONS 814 #endif 815 816 #if defined (_STLP_USE_EXCEPTIONS) 817 # define _STLP_TRY try 818 # define _STLP_CATCH_ALL catch(...) 819 # ifndef _STLP_THROW 820 # define _STLP_THROW(x) throw x 821 # endif 822 # define _STLP_RETHROW throw 823 824 # define _STLP_UNWIND(action) catch(...) { action; throw; } 825 826 # ifdef _STLP_THROW_RETURN_BUG 827 # define _STLP_RET_AFTER_THROW(data) return data; 828 # else 829 # define _STLP_RET_AFTER_THROW(data) 830 # endif 831 832 # if !defined (_STLP_THROWS) 833 # define _STLP_THROWS(x) throw(x) 834 # endif 835 # if !defined (_STLP_NOTHROW) 836 # define _STLP_NOTHROW throw() 837 # endif 838 #else 839 # define _STLP_TRY 840 # define _STLP_CATCH_ALL if (false) 841 # ifndef _STLP_THROW 842 # define _STLP_THROW(x) 843 # endif 844 # define _STLP_RETHROW {} 845 # define _STLP_UNWIND(action) 846 # define _STLP_THROWS(x) 847 # define _STLP_NOTHROW 848 # define _STLP_RET_AFTER_THROW(data) 849 #endif 850 851 /* 852 * Here we check _STLP_NO_EXCEPTIONS which means that the compiler has no 853 * exception support but not the _STLP_USE_EXCEPTIONS which simply means 854 * that the user do not want to use them. 855 */ 856 #if !defined (_STLP_NO_EXCEPTIONS) && !defined (_STLP_NO_EXCEPTION_SPEC) 857 # define _STLP_THROWS_INHERENTLY(x) throw x 858 # define _STLP_NOTHROW_INHERENTLY throw() 859 #else 860 # define _STLP_THROWS_INHERENTLY(x) 861 # define _STLP_NOTHROW_INHERENTLY 862 #endif 863 864 /* STLport function not returning are functions that throw so we translate 865 * the noreturn functions in throwing functions taking also into account 866 * exception support activation. 867 */ 868 #if defined (_STLP_NORETURN_FUNCTION) && !defined (_STLP_NO_EXCEPTIONS) && \ 869 !defined (_STLP_FUNCTION_THROWS) 870 # define _STLP_FUNCTION_THROWS _STLP_NORETURN_FUNCTION 871 #else 872 # define _STLP_FUNCTION_THROWS 873 #endif 874 875 #if defined(_STLP_NO_BOOL) 876 # if (defined (__IBMCPP__) && (__IBMCPP__ < 400)) && ! defined (_AIX) 877 # include <isynonym.hpp> 878 # if defined (__OS400__) 879 typedef int bool; 880 # elif !( defined (__xlC__) || defined (_AIX)) 881 typedef Boolean bool; 882 # endif 883 # else 884 # if defined(_STLP_YVALS_H) 885 # include <yvals.h> 886 # else 887 # if defined (_STLP_DONT_USE_BOOL_TYPEDEF) 888 # define bool int 889 # else 890 typedef int bool; 891 # endif 892 # define true 1 893 # define false 0 894 # endif 895 # endif /* __IBMCPP__ */ 896 #else 897 # define _STLP_BOOL_KEYWORD 1 898 #endif /* _STLP_NO_BOOL */ 899 900 /* uninitialized value filler */ 901 #ifndef _STLP_SHRED_BYTE 902 /* This value is designed to cause problems if an error occurs */ 903 # define _STLP_SHRED_BYTE 0xA3 904 #endif /* _STLP_SHRED_BYTE */ 905 906 /* shared library tune-up */ 907 #ifndef _STLP_IMPORT_DECLSPEC 908 # define _STLP_IMPORT_DECLSPEC 909 #endif 910 911 /* a keyword used to instantiate export template */ 912 #ifndef _STLP_EXPORT_TEMPLATE_KEYWORD 913 # define _STLP_EXPORT_TEMPLATE_KEYWORD 914 #endif 915 #ifndef _STLP_IMPORT_TEMPLATE_KEYWORD 916 # define _STLP_IMPORT_TEMPLATE_KEYWORD 917 #endif 918 919 #if !defined (_STLP_NO_CONST_IN_PAIR) 920 # define _STLP_CONST const 921 #else 922 # define _STLP_CONST 923 #endif 924 925 #ifdef _STLP_USE_NO_IOSTREAMS 926 /* 927 * If we do not use iostreams we do not use the export/import 928 * techniques to avoid build of the STLport library. 929 */ 930 # undef _STLP_USE_DECLSPEC 931 /* We also undef USE_DYNAMIC_LIB macro as this macro add some code 932 * to use the dynamic (shared) STLport library for some platform/compiler 933 * configuration leading to problem when not linking to the STLport lib. 934 */ 935 # undef _STLP_USE_DYNAMIC_LIB 936 #endif 937 938 #if defined (_STLP_DLLEXPORT_NEEDS_PREDECLARATION) && defined (_STLP_USE_DECLSPEC) 939 # if ! defined (_STLP_USE_TEMPLATE_EXPORT) 940 /* this setting turns on "extern template" extension use */ 941 # define _STLP_USE_TEMPLATE_EXPORT 942 # endif 943 # if defined (_STLP_DESIGNATED_DLL) && ! defined (_STLP_NO_FORCE_INSTANTIATE) 944 # define _STLP_NO_FORCE_INSTANTIATE 945 # endif 946 #endif 947 948 #if defined (_STLP_DESIGNATED_DLL) /* This is a lib which will contain STLport exports */ 949 # define _STLP_EXPORT _STLP_EXPORT_TEMPLATE_KEYWORD 950 #else 951 # define _STLP_EXPORT _STLP_IMPORT_TEMPLATE_KEYWORD 952 #endif 953 954 #ifndef _STLP_EXPORT_TEMPLATE 955 # define _STLP_EXPORT_TEMPLATE _STLP_EXPORT template 956 #endif 957 958 #if defined (_STLP_USE_DECLSPEC) /* using export/import technique */ 959 960 # ifndef _STLP_EXPORT_DECLSPEC 961 # define _STLP_EXPORT_DECLSPEC 962 # endif 963 # ifndef _STLP_IMPORT_DECLSPEC 964 # define _STLP_IMPORT_DECLSPEC 965 # endif 966 # ifndef _STLP_CLASS_EXPORT_DECLSPEC 967 # define _STLP_CLASS_EXPORT_DECLSPEC 968 # endif 969 # ifndef _STLP_CLASS_IMPORT_DECLSPEC 970 # define _STLP_CLASS_IMPORT_DECLSPEC 971 # endif 972 # if defined (_STLP_DESIGNATED_DLL) /* This is a lib which will contain STLport exports */ 973 # define _STLP_DECLSPEC _STLP_EXPORT_DECLSPEC 974 # define _STLP_CLASS_DECLSPEC _STLP_CLASS_EXPORT_DECLSPEC 975 # else 976 # define _STLP_DECLSPEC _STLP_IMPORT_DECLSPEC /* Other modules, importing STLport exports */ 977 # define _STLP_CLASS_DECLSPEC _STLP_CLASS_IMPORT_DECLSPEC 978 # endif 979 980 #else /* Not using DLL export/import specifications */ 981 982 # define _STLP_DECLSPEC 983 # define _STLP_CLASS_DECLSPEC 984 985 #endif 986 987 #define _STLP_EXPORT_TEMPLATE_CLASS _STLP_EXPORT template class _STLP_CLASS_DECLSPEC 988 989 #if defined (_STLP_NEED_ADDITIONAL_STATIC_DECLSPEC) 990 # define _STLP_STATIC_DECLSPEC _STLP_DECLSPEC 991 #else 992 # define _STLP_STATIC_DECLSPEC 993 #endif 994 995 #if !defined (_STLP_CALL) 996 # define _STLP_CALL 997 #endif 998 999 #ifndef _STLP_USE_NO_IOSTREAMS 1000 1001 # if defined (__DECCXX) && ! defined (__USE_STD_IOSTREAM) 1002 # define __USE_STD_IOSTREAM 1003 # endif 1004 1005 /* We only need to expose details of streams implementation 1006 if we use non-standard i/o or are building STLport*/ 1007 # if defined (__BUILDING_STLPORT) || defined (_STLP_NO_FORCE_INSTANTIATE) || !defined(_STLP_NO_CUSTOM_IO) 1008 # define _STLP_EXPOSE_STREAM_IMPLEMENTATION 1 1009 # endif 1010 1011 /* We only need to expose details of global implementation if we are building STLport 1012 or have not instantiated everything in the lib */ 1013 # if defined (__BUILDING_STLPORT) || defined (_STLP_NO_FORCE_INSTANTIATE) 1014 # undef _STLP_EXPOSE_GLOBALS_IMPLEMENTATION 1015 # define _STLP_EXPOSE_GLOBALS_IMPLEMENTATION 1 1016 # endif 1017 1018 #else /* _STLP_USE_NO_IOSTREAMS */ 1019 /* when we are not using SGI iostreams, we must expose globals, but not streams implementation */ 1020 # define _STLP_EXPOSE_GLOBALS_IMPLEMENTATION 1021 #endif /* _STLP_USE_NO_IOSTREAMS */ 1022 1023 #ifdef _STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS 1024 # define _STLP_PSPEC2(t1,t2) < t1,t2 > 1025 # define _STLP_PSPEC3(t1,t2,t3) < t1,t2,t3 > 1026 #else 1027 # define _STLP_PSPEC2(t1,t2) /* nothing */ 1028 # define _STLP_PSPEC3(t1,t2,t3) /* nothing */ 1029 #endif 1030 1031 /* Activation of the partial template workaround: 1032 */ 1033 #if !defined(_STLP_DONT_USE_PARTIAL_SPEC_WRKD) &&\ 1034 (!defined(_STLP_CLASS_PARTIAL_SPECIALIZATION) || !defined(_STLP_FUNCTION_TMPL_PARTIAL_ORDER)) 1035 # define _STLP_USE_PARTIAL_SPEC_WORKAROUND 1036 #endif 1037 1038 #ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE 1039 # define _STLP_RELOPS_OPERATORS(_TMPL, _TP) \ 1040 _TMPL inline bool _STLP_CALL operator!=(const _TP& __x, const _TP& __y) {return !(__x == __y);}\ 1041 _TMPL inline bool _STLP_CALL operator>(const _TP& __x, const _TP& __y) {return __y < __x;}\ 1042 _TMPL inline bool _STLP_CALL operator<=(const _TP& __x, const _TP& __y) { return !(__y < __x);}\ 1043 _TMPL inline bool _STLP_CALL operator>=(const _TP& __x, const _TP& __y) { return !(__x < __y);} 1044 #else 1045 # define _STLP_RELOPS_OPERATORS(_TMPL, _TP) 1046 #endif 1047 1048 #if defined ( _STLP_USE_ABBREVS ) 1049 # include <stl/_abbrevs.h> 1050 #endif 1051 1052 /* Some really useful macro */ 1053 #define _STLP_ARRAY_SIZE(A) sizeof(A) / sizeof(A[0]) 1054 #define _STLP_ARRAY_AND_SIZE(A) A, sizeof(A) / sizeof(A[0]) 1055 1056 #if !defined (_STLP_MARK_PARAMETER_AS_UNUSED) 1057 # define _STLP_MARK_PARAMETER_AS_UNUSED(X) (void*)X; 1058 #endif 1059 1060 #if defined (_STLP_CHECK_RUNTIME_COMPATIBILITY) 1061 # if defined (_STLP_USE_NO_IOSTREAMS) 1062 # undef _STLP_CHECK_RUNTIME_COMPATIBILITY 1063 # else 1064 /* The extern "C" simply makes the symbol simpler. */ 1065 #if defined (__cplusplus) 1066 extern "C" 1067 #endif 1068 void _STLP_DECLSPEC _STLP_CALL _STLP_CHECK_RUNTIME_COMPATIBILITY(); 1069 # endif 1070 #endif 1071 1072 /* some cleanup */ 1073 #undef _STLP_DONT_USE_BOOL_TYPEDEF 1074 #undef _STLP_YVALS_H 1075 #undef _STLP_LOOP_INLINE_PROBLEMS 1076 #undef _STLP_NEED_EXPLICIT 1077 #undef _STLP_NEED_TYPENAME 1078 #undef _STLP_NO_NEW_STYLE_CASTS 1079 #undef __AUTO_CONFIGURED 1080 1081 #endif /* RC_INVOKED */ 1082 1083 #endif /* _STLP_FEATURES_H */ 1084