1// Boost config.hpp configuration header file ------------------------------// 2 3// Copyright (c) 2001-2003 John Maddock 4// Copyright (c) 2001 Darin Adler 5// Copyright (c) 2001 Peter Dimov 6// Copyright (c) 2002 Bill Kempf 7// Copyright (c) 2002 Jens Maurer 8// Copyright (c) 2002-2003 David Abrahams 9// Copyright (c) 2003 Gennaro Prota 10// Copyright (c) 2003 Eric Friedman 11// Copyright (c) 2010 Eric Jourdanneau, Joel Falcou 12// Distributed under the Boost Software License, Version 1.0. (See 13// accompanying file LICENSE_1_0.txt or copy at 14// http://www.boost.org/LICENSE_1_0.txt) 15 16// See http://www.boost.org/ for most recent version. 17 18// Boost config.hpp policy and rationale documentation has been moved to 19// http://www.boost.org/libs/config/ 20// 21// This file is intended to be stable, and relatively unchanging. 22// It should contain boilerplate code only - no compiler specific 23// code unless it is unavoidable - no changes unless unavoidable. 24 25#ifndef BOOST_CONFIG_SUFFIX_HPP 26#define BOOST_CONFIG_SUFFIX_HPP 27 28#if defined(__GNUC__) && (__GNUC__ >= 4) 29// 30// Some GCC-4.x versions issue warnings even when __extension__ is used, 31// so use this as a workaround: 32// 33#pragma GCC system_header 34#endif 35 36// 37// ensure that visibility macros are always defined, thus symplifying use 38// 39#ifndef BOOST_SYMBOL_EXPORT 40# define BOOST_SYMBOL_EXPORT 41#endif 42#ifndef BOOST_SYMBOL_IMPORT 43# define BOOST_SYMBOL_IMPORT 44#endif 45#ifndef BOOST_SYMBOL_VISIBLE 46# define BOOST_SYMBOL_VISIBLE 47#endif 48 49// 50// look for long long by looking for the appropriate macros in <limits.h>. 51// Note that we use limits.h rather than climits for maximal portability, 52// remember that since these just declare a bunch of macros, there should be 53// no namespace issues from this. 54// 55#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG) \ 56 && !defined(BOOST_MSVC) && !defined(__BORLANDC__) 57# include <limits.h> 58# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)) 59# define BOOST_HAS_LONG_LONG 60# else 61# define BOOST_NO_LONG_LONG 62# endif 63#endif 64 65// GCC 3.x will clean up all of those nasty macro definitions that 66// BOOST_NO_CTYPE_FUNCTIONS is intended to help work around, so undefine 67// it under GCC 3.x. 68#if defined(__GNUC__) && (__GNUC__ >= 3) && defined(BOOST_NO_CTYPE_FUNCTIONS) 69# undef BOOST_NO_CTYPE_FUNCTIONS 70#endif 71 72// 73// Assume any extensions are in namespace std:: unless stated otherwise: 74// 75# ifndef BOOST_STD_EXTENSION_NAMESPACE 76# define BOOST_STD_EXTENSION_NAMESPACE std 77# endif 78 79// 80// If cv-qualified specializations are not allowed, then neither are cv-void ones: 81// 82# if defined(BOOST_NO_CV_SPECIALIZATIONS) \ 83 && !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS) 84# define BOOST_NO_CV_VOID_SPECIALIZATIONS 85# endif 86 87// 88// If there is no numeric_limits template, then it can't have any compile time 89// constants either! 90// 91# if defined(BOOST_NO_LIMITS) \ 92 && !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) 93# define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS 94# define BOOST_NO_MS_INT64_NUMERIC_LIMITS 95# define BOOST_NO_LONG_LONG_NUMERIC_LIMITS 96# endif 97 98// 99// if there is no long long then there is no specialisation 100// for numeric_limits<long long> either: 101// 102#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS) 103# define BOOST_NO_LONG_LONG_NUMERIC_LIMITS 104#endif 105 106// 107// if there is no __int64 then there is no specialisation 108// for numeric_limits<__int64> either: 109// 110#if !defined(BOOST_HAS_MS_INT64) && !defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS) 111# define BOOST_NO_MS_INT64_NUMERIC_LIMITS 112#endif 113 114// 115// if member templates are supported then so is the 116// VC6 subset of member templates: 117// 118# if !defined(BOOST_NO_MEMBER_TEMPLATES) \ 119 && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) 120# define BOOST_MSVC6_MEMBER_TEMPLATES 121# endif 122 123// 124// Without partial specialization, can't test for partial specialisation bugs: 125// 126# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 127 && !defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) 128# define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG 129# endif 130 131// 132// Without partial specialization, we can't have array-type partial specialisations: 133// 134# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 135 && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) 136# define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS 137# endif 138 139// 140// Without partial specialization, std::iterator_traits can't work: 141// 142# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 143 && !defined(BOOST_NO_STD_ITERATOR_TRAITS) 144# define BOOST_NO_STD_ITERATOR_TRAITS 145# endif 146 147// 148// Without partial specialization, partial 149// specialization with default args won't work either: 150// 151# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 152 && !defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS) 153# define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS 154# endif 155 156// 157// Without member template support, we can't have template constructors 158// in the standard library either: 159// 160# if defined(BOOST_NO_MEMBER_TEMPLATES) \ 161 && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \ 162 && !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) 163# define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS 164# endif 165 166// 167// Without member template support, we can't have a conforming 168// std::allocator template either: 169// 170# if defined(BOOST_NO_MEMBER_TEMPLATES) \ 171 && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \ 172 && !defined(BOOST_NO_STD_ALLOCATOR) 173# define BOOST_NO_STD_ALLOCATOR 174# endif 175 176// 177// without ADL support then using declarations will break ADL as well: 178// 179#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL) 180# define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL 181#endif 182 183// 184// Without typeid support we have no dynamic RTTI either: 185// 186#if defined(BOOST_NO_TYPEID) && !defined(BOOST_NO_RTTI) 187# define BOOST_NO_RTTI 188#endif 189 190// 191// If we have a standard allocator, then we have a partial one as well: 192// 193#if !defined(BOOST_NO_STD_ALLOCATOR) 194# define BOOST_HAS_PARTIAL_STD_ALLOCATOR 195#endif 196 197// 198// We can't have a working std::use_facet if there is no std::locale: 199// 200# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_USE_FACET) 201# define BOOST_NO_STD_USE_FACET 202# endif 203 204// 205// We can't have a std::messages facet if there is no std::locale: 206// 207# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_MESSAGES) 208# define BOOST_NO_STD_MESSAGES 209# endif 210 211// 212// We can't have a working std::wstreambuf if there is no std::locale: 213// 214# if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_WSTREAMBUF) 215# define BOOST_NO_STD_WSTREAMBUF 216# endif 217 218// 219// We can't have a <cwctype> if there is no <cwchar>: 220// 221# if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_CWCTYPE) 222# define BOOST_NO_CWCTYPE 223# endif 224 225// 226// We can't have a swprintf if there is no <cwchar>: 227// 228# if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_SWPRINTF) 229# define BOOST_NO_SWPRINTF 230# endif 231 232// 233// If Win32 support is turned off, then we must turn off 234// threading support also, unless there is some other 235// thread API enabled: 236// 237#if defined(BOOST_DISABLE_WIN32) && defined(_WIN32) \ 238 && !defined(BOOST_DISABLE_THREADS) && !defined(BOOST_HAS_PTHREADS) 239# define BOOST_DISABLE_THREADS 240#endif 241 242// 243// Turn on threading support if the compiler thinks that it's in 244// multithreaded mode. We put this here because there are only a 245// limited number of macros that identify this (if there's any missing 246// from here then add to the appropriate compiler section): 247// 248#if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \ 249 || defined(_PTHREADS) || defined(__APPLE__) || defined(__DragonFly__)) \ 250 && !defined(BOOST_HAS_THREADS) 251# define BOOST_HAS_THREADS 252#endif 253 254// 255// Turn threading support off if BOOST_DISABLE_THREADS is defined: 256// 257#if defined(BOOST_DISABLE_THREADS) && defined(BOOST_HAS_THREADS) 258# undef BOOST_HAS_THREADS 259#endif 260 261// 262// Turn threading support off if we don't recognise the threading API: 263// 264#if defined(BOOST_HAS_THREADS) && !defined(BOOST_HAS_PTHREADS)\ 265 && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_BETHREADS)\ 266 && !defined(BOOST_HAS_MPTASKS) 267# undef BOOST_HAS_THREADS 268#endif 269 270// 271// Turn threading detail macros off if we don't (want to) use threading 272// 273#ifndef BOOST_HAS_THREADS 274# undef BOOST_HAS_PTHREADS 275# undef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 276# undef BOOST_HAS_PTHREAD_YIELD 277# undef BOOST_HAS_PTHREAD_DELAY_NP 278# undef BOOST_HAS_WINTHREADS 279# undef BOOST_HAS_BETHREADS 280# undef BOOST_HAS_MPTASKS 281#endif 282 283// 284// If the compiler claims to be C99 conformant, then it had better 285// have a <stdint.h>: 286// 287# if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901) 288# define BOOST_HAS_STDINT_H 289# ifndef BOOST_HAS_LOG1P 290# define BOOST_HAS_LOG1P 291# endif 292# ifndef BOOST_HAS_EXPM1 293# define BOOST_HAS_EXPM1 294# endif 295# endif 296 297// 298// Define BOOST_NO_SLIST and BOOST_NO_HASH if required. 299// Note that this is for backwards compatibility only. 300// 301# if !defined(BOOST_HAS_SLIST) && !defined(BOOST_NO_SLIST) 302# define BOOST_NO_SLIST 303# endif 304 305# if !defined(BOOST_HAS_HASH) && !defined(BOOST_NO_HASH) 306# define BOOST_NO_HASH 307# endif 308 309// 310// Set BOOST_SLIST_HEADER if not set already: 311// 312#if defined(BOOST_HAS_SLIST) && !defined(BOOST_SLIST_HEADER) 313# define BOOST_SLIST_HEADER <slist> 314#endif 315 316// 317// Set BOOST_HASH_SET_HEADER if not set already: 318// 319#if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_SET_HEADER) 320# define BOOST_HASH_SET_HEADER <hash_set> 321#endif 322 323// 324// Set BOOST_HASH_MAP_HEADER if not set already: 325// 326#if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_MAP_HEADER) 327# define BOOST_HASH_MAP_HEADER <hash_map> 328#endif 329 330// BOOST_HAS_ABI_HEADERS 331// This macro gets set if we have headers that fix the ABI, 332// and prevent ODR violations when linking to external libraries: 333#if defined(BOOST_ABI_PREFIX) && defined(BOOST_ABI_SUFFIX) && !defined(BOOST_HAS_ABI_HEADERS) 334# define BOOST_HAS_ABI_HEADERS 335#endif 336 337#if defined(BOOST_HAS_ABI_HEADERS) && defined(BOOST_DISABLE_ABI_HEADERS) 338# undef BOOST_HAS_ABI_HEADERS 339#endif 340 341// BOOST_NO_STDC_NAMESPACE workaround --------------------------------------// 342// Because std::size_t usage is so common, even in boost headers which do not 343// otherwise use the C library, the <cstddef> workaround is included here so 344// that ugly workaround code need not appear in many other boost headers. 345// NOTE WELL: This is a workaround for non-conforming compilers; <cstddef> 346// must still be #included in the usual places so that <cstddef> inclusion 347// works as expected with standard conforming compilers. The resulting 348// double inclusion of <cstddef> is harmless. 349 350# if defined(BOOST_NO_STDC_NAMESPACE) && defined(__cplusplus) 351# include <cstddef> 352 namespace std { using ::ptrdiff_t; using ::size_t; } 353# endif 354 355// Workaround for the unfortunate min/max macros defined by some platform headers 356 357#define BOOST_PREVENT_MACRO_SUBSTITUTION 358 359#ifndef BOOST_USING_STD_MIN 360# define BOOST_USING_STD_MIN() using std::min 361#endif 362 363#ifndef BOOST_USING_STD_MAX 364# define BOOST_USING_STD_MAX() using std::max 365#endif 366 367// BOOST_NO_STD_MIN_MAX workaround -----------------------------------------// 368 369# if defined(BOOST_NO_STD_MIN_MAX) && defined(__cplusplus) 370 371namespace std { 372 template <class _Tp> 373 inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) { 374 return __b < __a ? __b : __a; 375 } 376 template <class _Tp> 377 inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) { 378 return __a < __b ? __b : __a; 379 } 380} 381 382# endif 383 384// BOOST_STATIC_CONSTANT workaround --------------------------------------- // 385// On compilers which don't allow in-class initialization of static integral 386// constant members, we must use enums as a workaround if we want the constants 387// to be available at compile-time. This macro gives us a convenient way to 388// declare such constants. 389 390# ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION 391# define BOOST_STATIC_CONSTANT(type, assignment) enum { assignment } 392# else 393# define BOOST_STATIC_CONSTANT(type, assignment) static const type assignment 394# endif 395 396// BOOST_USE_FACET / HAS_FACET workaround ----------------------------------// 397// When the standard library does not have a conforming std::use_facet there 398// are various workarounds available, but they differ from library to library. 399// The same problem occurs with has_facet. 400// These macros provide a consistent way to access a locale's facets. 401// Usage: 402// replace 403// std::use_facet<Type>(loc); 404// with 405// BOOST_USE_FACET(Type, loc); 406// Note do not add a std:: prefix to the front of BOOST_USE_FACET! 407// Use for BOOST_HAS_FACET is analogous. 408 409#if defined(BOOST_NO_STD_USE_FACET) 410# ifdef BOOST_HAS_TWO_ARG_USE_FACET 411# define BOOST_USE_FACET(Type, loc) std::use_facet(loc, static_cast<Type*>(0)) 412# define BOOST_HAS_FACET(Type, loc) std::has_facet(loc, static_cast<Type*>(0)) 413# elif defined(BOOST_HAS_MACRO_USE_FACET) 414# define BOOST_USE_FACET(Type, loc) std::_USE(loc, Type) 415# define BOOST_HAS_FACET(Type, loc) std::_HAS(loc, Type) 416# elif defined(BOOST_HAS_STLP_USE_FACET) 417# define BOOST_USE_FACET(Type, loc) (*std::_Use_facet<Type >(loc)) 418# define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc) 419# endif 420#else 421# define BOOST_USE_FACET(Type, loc) std::use_facet< Type >(loc) 422# define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc) 423#endif 424 425// BOOST_NESTED_TEMPLATE workaround ------------------------------------------// 426// Member templates are supported by some compilers even though they can't use 427// the A::template member<U> syntax, as a workaround replace: 428// 429// typedef typename A::template rebind<U> binder; 430// 431// with: 432// 433// typedef typename A::BOOST_NESTED_TEMPLATE rebind<U> binder; 434 435#ifndef BOOST_NO_MEMBER_TEMPLATE_KEYWORD 436# define BOOST_NESTED_TEMPLATE template 437#else 438# define BOOST_NESTED_TEMPLATE 439#endif 440 441// BOOST_UNREACHABLE_RETURN(x) workaround -------------------------------------// 442// Normally evaluates to nothing, unless BOOST_NO_UNREACHABLE_RETURN_DETECTION 443// is defined, in which case it evaluates to return x; Use when you have a return 444// statement that can never be reached. 445 446#ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION 447# define BOOST_UNREACHABLE_RETURN(x) return x; 448#else 449# define BOOST_UNREACHABLE_RETURN(x) 450#endif 451 452// BOOST_DEDUCED_TYPENAME workaround ------------------------------------------// 453// 454// Some compilers don't support the use of `typename' for dependent 455// types in deduced contexts, e.g. 456// 457// template <class T> void f(T, typename T::type); 458// ^^^^^^^^ 459// Replace these declarations with: 460// 461// template <class T> void f(T, BOOST_DEDUCED_TYPENAME T::type); 462 463#ifndef BOOST_NO_DEDUCED_TYPENAME 464# define BOOST_DEDUCED_TYPENAME typename 465#else 466# define BOOST_DEDUCED_TYPENAME 467#endif 468 469#ifndef BOOST_NO_TYPENAME_WITH_CTOR 470# define BOOST_CTOR_TYPENAME typename 471#else 472# define BOOST_CTOR_TYPENAME 473#endif 474 475// long long workaround ------------------------------------------// 476// On gcc (and maybe other compilers?) long long is alway supported 477// but it's use may generate either warnings (with -ansi), or errors 478// (with -pedantic -ansi) unless it's use is prefixed by __extension__ 479// 480#if defined(BOOST_HAS_LONG_LONG) && defined(__cplusplus) 481namespace boost{ 482# ifdef __GNUC__ 483 __extension__ typedef long long long_long_type; 484 __extension__ typedef unsigned long long ulong_long_type; 485# else 486 typedef long long long_long_type; 487 typedef unsigned long long ulong_long_type; 488# endif 489} 490#endif 491 492// BOOST_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------// 493// 494// Some compilers have problems with function templates whose template 495// parameters don't appear in the function parameter list (basically 496// they just link one instantiation of the template in the final 497// executable). These macros provide a uniform way to cope with the 498// problem with no effects on the calling syntax. 499 500// Example: 501// 502// #include <iostream> 503// #include <ostream> 504// #include <typeinfo> 505// 506// template <int n> 507// void f() { std::cout << n << ' '; } 508// 509// template <typename T> 510// void g() { std::cout << typeid(T).name() << ' '; } 511// 512// int main() { 513// f<1>(); 514// f<2>(); 515// 516// g<int>(); 517// g<double>(); 518// } 519// 520// With VC++ 6.0 the output is: 521// 522// 2 2 double double 523// 524// To fix it, write 525// 526// template <int n> 527// void f(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, n)) { ... } 528// 529// template <typename T> 530// void g(BOOST_EXPLICIT_TEMPLATE_TYPE(T)) { ... } 531// 532 533 534#if defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS) && defined(__cplusplus) 535 536# include "boost/type.hpp" 537# include "boost/non_type.hpp" 538 539# define BOOST_EXPLICIT_TEMPLATE_TYPE(t) boost::type<t>* = 0 540# define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) boost::type<t>* 541# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) boost::non_type<t, v>* = 0 542# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) boost::non_type<t, v>* 543 544# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) \ 545 , BOOST_EXPLICIT_TEMPLATE_TYPE(t) 546# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) \ 547 , BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) 548# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) \ 549 , BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) 550# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) \ 551 , BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) 552 553#else 554 555// no workaround needed: expand to nothing 556 557# define BOOST_EXPLICIT_TEMPLATE_TYPE(t) 558# define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) 559# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) 560# define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) 561 562# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) 563# define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) 564# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) 565# define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) 566 567 568#endif // defined BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS 569 570// When BOOST_NO_STD_TYPEINFO is defined, we can just import 571// the global definition into std namespace: 572#if defined(BOOST_NO_STD_TYPEINFO) && defined(__cplusplus) 573#include <typeinfo> 574namespace std{ using ::type_info; } 575#endif 576 577// ---------------------------------------------------------------------------// 578 579// 580// Helper macro BOOST_STRINGIZE: 581// Converts the parameter X to a string after macro replacement 582// on X has been performed. 583// 584#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X) 585#define BOOST_DO_STRINGIZE(X) #X 586 587// 588// Helper macro BOOST_JOIN: 589// The following piece of macro magic joins the two 590// arguments together, even when one of the arguments is 591// itself a macro (see 16.3.1 in C++ standard). The key 592// is that macro expansion of macro arguments does not 593// occur in BOOST_DO_JOIN2 but does in BOOST_DO_JOIN. 594// 595#define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y ) 596#define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y) 597#define BOOST_DO_JOIN2( X, Y ) X##Y 598 599// 600// Set some default values for compiler/library/platform names. 601// These are for debugging config setup only: 602// 603# ifndef BOOST_COMPILER 604# define BOOST_COMPILER "Unknown ISO C++ Compiler" 605# endif 606# ifndef BOOST_STDLIB 607# define BOOST_STDLIB "Unknown ISO standard library" 608# endif 609# ifndef BOOST_PLATFORM 610# if defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) \ 611 || defined(_POSIX_SOURCE) 612# define BOOST_PLATFORM "Generic Unix" 613# else 614# define BOOST_PLATFORM "Unknown" 615# endif 616# endif 617 618// 619// Set some default values GPU support 620// 621# ifndef BOOST_GPU_ENABLED 622# define BOOST_GPU_ENABLED 623# endif 624 625// BOOST_FORCEINLINE ---------------------------------------------// 626// Macro to use in place of 'inline' to force a function to be inline 627#if !defined(BOOST_FORCEINLINE) 628# if defined(_MSC_VER) 629# define BOOST_FORCEINLINE __forceinline 630# elif defined(__GNUC__) && __GNUC__ > 3 631# define BOOST_FORCEINLINE inline __attribute__ ((always_inline)) 632# else 633# define BOOST_FORCEINLINE inline 634# endif 635#endif 636 637// 638// Set BOOST_NO_DECLTYPE_N3276 when BOOST_NO_DECLTYPE is defined 639// 640#if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276) 641#define BOOST_NO_CXX11_DECLTYPE_N3276 BOOST_NO_CXX11_DECLTYPE 642#endif 643 644// -------------------- Deprecated macros for 1.50 --------------------------- 645// These will go away in a future release 646 647// Use BOOST_NO_CXX11_HDR_UNORDERED_SET or BOOST_NO_CXX11_HDR_UNORDERED_MAP 648// instead of BOOST_NO_STD_UNORDERED 649#if defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP) || defined (BOOST_NO_CXX11_HDR_UNORDERED_SET) 650# ifndef BOOST_NO_STD_UNORDERED 651# define BOOST_NO_STD_UNORDERED 652# endif 653#endif 654 655// Use BOOST_NO_CXX11_HDR_INITIALIZER_LIST instead of BOOST_NO_INITIALIZER_LISTS 656#if defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) && !defined(BOOST_NO_INITIALIZER_LISTS) 657# define BOOST_NO_INITIALIZER_LISTS 658#endif 659 660// Use BOOST_NO_CXX11_HDR_ARRAY instead of BOOST_NO_0X_HDR_ARRAY 661#if defined(BOOST_NO_CXX11_HDR_ARRAY) && !defined(BOOST_NO_BOOST_NO_0X_HDR_ARRAY) 662# define BOOST_NO_0X_HDR_ARRAY 663#endif 664// Use BOOST_NO_CXX11_HDR_CHRONO instead of BOOST_NO_0X_HDR_CHRONO 665#if defined(BOOST_NO_CXX11_HDR_CHRONO) && !defined(BOOST_NO_0X_HDR_CHRONO) 666# define BOOST_NO_0X_HDR_CHRONO 667#endif 668// Use BOOST_NO_CXX11_HDR_CODECVT instead of BOOST_NO_0X_HDR_CODECVT 669#if defined(BOOST_NO_CXX11_HDR_CODECVT) && !defined(BOOST_NO_0X_HDR_CODECVT) 670# define BOOST_NO_0X_HDR_CODECVT 671#endif 672// Use BOOST_NO_CXX11_HDR_CONDITION_VARIABLE instead of BOOST_NO_0X_HDR_CONDITION_VARIABLE 673#if defined(BOOST_NO_CXX11_HDR_CONDITION_VARIABLE) && !defined(BOOST_NO_0X_HDR_CONDITION_VARIABLE) 674# define BOOST_NO_0X_HDR_CONDITION_VARIABLE 675#endif 676// Use BOOST_NO_CXX11_HDR_FORWARD_LIST instead of BOOST_NO_0X_HDR_FORWARD_LIST 677#if defined(BOOST_NO_CXX11_HDR_FORWARD_LIST) && !defined(BOOST_NO_0X_HDR_FORWARD_LIST) 678# define BOOST_NO_0X_HDR_FORWARD_LIST 679#endif 680// Use BOOST_NO_CXX11_HDR_FUTURE instead of BOOST_NO_0X_HDR_FUTURE 681#if defined(BOOST_NO_CXX11_HDR_FUTURE) && !defined(BOOST_NO_0X_HDR_FUTURE) 682# define BOOST_NO_0X_HDR_FUTURE 683#endif 684 685// Use BOOST_NO_CXX11_HDR_INITIALIZER_LIST 686// instead of BOOST_NO_0X_HDR_INITIALIZER_LIST or BOOST_NO_INITIALIZER_LISTS 687#ifdef BOOST_NO_CXX11_HDR_INITIALIZER_LIST 688# ifndef BOOST_NO_0X_HDR_INITIALIZER_LIST 689# define BOOST_NO_0X_HDR_INITIALIZER_LIST 690# endif 691# ifndef BOOST_NO_INITIALIZER_LISTS 692# define BOOST_NO_INITIALIZER_LISTS 693# endif 694#endif 695 696// Use BOOST_NO_CXX11_HDR_MUTEX instead of BOOST_NO_0X_HDR_MUTEX 697#if defined(BOOST_NO_CXX11_HDR_MUTEX) && !defined(BOOST_NO_0X_HDR_MUTEX) 698# define BOOST_NO_0X_HDR_MUTEX 699#endif 700// Use BOOST_NO_CXX11_HDR_RANDOM instead of BOOST_NO_0X_HDR_RANDOM 701#if defined(BOOST_NO_CXX11_HDR_RANDOM) && !defined(BOOST_NO_0X_HDR_RANDOM) 702# define BOOST_NO_0X_HDR_RANDOM 703#endif 704// Use BOOST_NO_CXX11_HDR_RATIO instead of BOOST_NO_0X_HDR_RATIO 705#if defined(BOOST_NO_CXX11_HDR_RATIO) && !defined(BOOST_NO_0X_HDR_RATIO) 706# define BOOST_NO_0X_HDR_RATIO 707#endif 708// Use BOOST_NO_CXX11_HDR_REGEX instead of BOOST_NO_0X_HDR_REGEX 709#if defined(BOOST_NO_CXX11_HDR_REGEX) && !defined(BOOST_NO_0X_HDR_REGEX) 710# define BOOST_NO_0X_HDR_REGEX 711#endif 712// Use BOOST_NO_CXX11_HDR_SYSTEM_ERROR instead of BOOST_NO_0X_HDR_SYSTEM_ERROR 713#if defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_0X_HDR_SYSTEM_ERROR) 714# define BOOST_NO_0X_HDR_SYSTEM_ERROR 715#endif 716// Use BOOST_NO_CXX11_HDR_THREAD instead of BOOST_NO_0X_HDR_THREAD 717#if defined(BOOST_NO_CXX11_HDR_THREAD) && !defined(BOOST_NO_0X_HDR_THREAD) 718# define BOOST_NO_0X_HDR_THREAD 719#endif 720// Use BOOST_NO_CXX11_HDR_TUPLE instead of BOOST_NO_0X_HDR_TUPLE 721#if defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_0X_HDR_TUPLE) 722# define BOOST_NO_0X_HDR_TUPLE 723#endif 724// Use BOOST_NO_CXX11_HDR_TYPE_TRAITS instead of BOOST_NO_0X_HDR_TYPE_TRAITS 725#if defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) && !defined(BOOST_NO_0X_HDR_TYPE_TRAITS) 726# define BOOST_NO_0X_HDR_TYPE_TRAITS 727#endif 728// Use BOOST_NO_CXX11_HDR_TYPEINDEX instead of BOOST_NO_0X_HDR_TYPEINDEX 729#if defined(BOOST_NO_CXX11_HDR_TYPEINDEX) && !defined(BOOST_NO_0X_HDR_TYPEINDEX) 730# define BOOST_NO_0X_HDR_TYPEINDEX 731#endif 732// Use BOOST_NO_CXX11_HDR_UNORDERED_MAP instead of BOOST_NO_0X_HDR_UNORDERED_MAP 733#if defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP) && !defined(BOOST_NO_0X_HDR_UNORDERED_MAP) 734# define BOOST_NO_0X_HDR_UNORDERED_MAP 735#endif 736// Use BOOST_NO_CXX11_HDR_UNORDERED_SET instead of BOOST_NO_0X_HDR_UNORDERED_SET 737#if defined(BOOST_NO_CXX11_HDR_UNORDERED_SET) && !defined(BOOST_NO_0X_HDR_UNORDERED_SET) 738# define BOOST_NO_0X_HDR_UNORDERED_SET 739#endif 740 741// ------------------ End of deprecated macros for 1.50 --------------------------- 742 743// -------------------- Deprecated macros for 1.51 --------------------------- 744// These will go away in a future release 745 746// Use BOOST_NO_CXX11_AUTO_DECLARATIONS instead of BOOST_NO_AUTO_DECLARATIONS 747#if defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && !defined(BOOST_NO_AUTO_DECLARATIONS) 748# define BOOST_NO_AUTO_DECLARATIONS 749#endif 750// Use BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS instead of BOOST_NO_AUTO_MULTIDECLARATIONS 751#if defined(BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS) && !defined(BOOST_NO_AUTO_MULTIDECLARATIONS) 752# define BOOST_NO_AUTO_MULTIDECLARATIONS 753#endif 754// Use BOOST_NO_CXX11_CHAR16_T instead of BOOST_NO_CHAR16_T 755#if defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CHAR16_T) 756# define BOOST_NO_CHAR16_T 757#endif 758// Use BOOST_NO_CXX11_CHAR32_T instead of BOOST_NO_CHAR32_T 759#if defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CHAR32_T) 760# define BOOST_NO_CHAR32_T 761#endif 762// Use BOOST_NO_CXX11_TEMPLATE_ALIASES instead of BOOST_NO_TEMPLATE_ALIASES 763#if defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !defined(BOOST_NO_TEMPLATE_ALIASES) 764# define BOOST_NO_TEMPLATE_ALIASES 765#endif 766// Use BOOST_NO_CXX11_CONSTEXPR instead of BOOST_NO_CONSTEXPR 767#if defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CONSTEXPR) 768# define BOOST_NO_CONSTEXPR 769#endif 770// Use BOOST_NO_CXX11_DECLTYPE_N3276 instead of BOOST_NO_DECLTYPE_N3276 771#if defined(BOOST_NO_CXX11_DECLTYPE_N3276) && !defined(BOOST_NO_DECLTYPE_N3276) 772# define BOOST_NO_DECLTYPE_N3276 773#endif 774// Use BOOST_NO_CXX11_DECLTYPE instead of BOOST_NO_DECLTYPE 775#if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_DECLTYPE) 776# define BOOST_NO_DECLTYPE 777#endif 778// Use BOOST_NO_CXX11_DEFAULTED_FUNCTIONS instead of BOOST_NO_DEFAULTED_FUNCTIONS 779#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_DEFAULTED_FUNCTIONS) 780# define BOOST_NO_DEFAULTED_FUNCTIONS 781#endif 782// Use BOOST_NO_CXX11_DELETED_FUNCTIONS instead of BOOST_NO_DELETED_FUNCTIONS 783#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_DELETED_FUNCTIONS) 784# define BOOST_NO_DELETED_FUNCTIONS 785#endif 786// Use BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS instead of BOOST_NO_EXPLICIT_CONVERSION_OPERATORS 787#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) && !defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS) 788# define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS 789#endif 790// Use BOOST_NO_CXX11_EXTERN_TEMPLATE instead of BOOST_NO_EXTERN_TEMPLATE 791#if defined(BOOST_NO_CXX11_EXTERN_TEMPLATE) && !defined(BOOST_NO_EXTERN_TEMPLATE) 792# define BOOST_NO_EXTERN_TEMPLATE 793#endif 794// Use BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS instead of BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS 795#if defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !defined(BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS) 796# define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS 797#endif 798// Use BOOST_NO_CXX11_LAMBDAS instead of BOOST_NO_LAMBDAS 799#if defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_LAMBDAS) 800# define BOOST_NO_LAMBDAS 801#endif 802// Use BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS instead of BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS 803#if defined(BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS) && !defined(BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS) 804# define BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS 805#endif 806// Use BOOST_NO_CXX11_NOEXCEPT instead of BOOST_NO_NOEXCEPT 807#if defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_NOEXCEPT) 808# define BOOST_NO_NOEXCEPT 809#endif 810// Use BOOST_NO_CXX11_NULLPTR instead of BOOST_NO_NULLPTR 811#if defined(BOOST_NO_CXX11_NULLPTR) && !defined(BOOST_NO_NULLPTR) 812# define BOOST_NO_NULLPTR 813#endif 814// Use BOOST_NO_CXX11_RAW_LITERALS instead of BOOST_NO_RAW_LITERALS 815#if defined(BOOST_NO_CXX11_RAW_LITERALS) && !defined(BOOST_NO_RAW_LITERALS) 816# define BOOST_NO_RAW_LITERALS 817#endif 818// Use BOOST_NO_CXX11_RVALUE_REFERENCES instead of BOOST_NO_RVALUE_REFERENCES 819#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_RVALUE_REFERENCES) 820# define BOOST_NO_RVALUE_REFERENCES 821#endif 822// Use BOOST_NO_CXX11_SCOPED_ENUMS instead of BOOST_NO_SCOPED_ENUMS 823#if defined(BOOST_NO_CXX11_SCOPED_ENUMS) && !defined(BOOST_NO_SCOPED_ENUMS) 824# define BOOST_NO_SCOPED_ENUMS 825#endif 826// Use BOOST_NO_CXX11_STATIC_ASSERT instead of BOOST_NO_STATIC_ASSERT 827#if defined(BOOST_NO_CXX11_STATIC_ASSERT) && !defined(BOOST_NO_STATIC_ASSERT) 828# define BOOST_NO_STATIC_ASSERT 829#endif 830// Use BOOST_NO_CXX11_STD_UNORDERD instead of BOOST_NO_STD_UNORDERD 831#if defined(BOOST_NO_CXX11_STD_UNORDERD) && !defined(BOOST_NO_STD_UNORDERD) 832# define BOOST_NO_STD_UNORDERD 833#endif 834// Use BOOST_NO_CXX11_UNICODE_LITERALS instead of BOOST_NO_UNICODE_LITERALS 835#if defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(BOOST_NO_UNICODE_LITERALS) 836# define BOOST_NO_UNICODE_LITERALS 837#endif 838// Use BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX instead of BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX 839#if defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !defined(BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX) 840# define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX 841#endif 842// Use BOOST_NO_CXX11_VARIADIC_TEMPLATES instead of BOOST_NO_VARIADIC_TEMPLATES 843#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_VARIADIC_TEMPLATES) 844# define BOOST_NO_VARIADIC_TEMPLATES 845#endif 846// Use BOOST_NO_CXX11_VARIADIC_MACROS instead of BOOST_NO_VARIADIC_MACROS 847#if defined(BOOST_NO_CXX11_VARIADIC_MACROS) && !defined(BOOST_NO_VARIADIC_MACROS) 848# define BOOST_NO_VARIADIC_MACROS 849#endif 850// Use BOOST_NO_CXX11_NUMERIC_LIMITS instead of BOOST_NO_NUMERIC_LIMITS_LOWEST 851#if defined(BOOST_NO_CXX11_NUMERIC_LIMITS) && !defined(BOOST_NO_NUMERIC_LIMITS_LOWEST) 852# define BOOST_NO_NUMERIC_LIMITS_LOWEST 853#endif 854// ------------------ End of deprecated macros for 1.51 --------------------------- 855 856 857 858// 859// Helper macros BOOST_NOEXCEPT, BOOST_NOEXCEPT_IF, BOOST_NOEXCEPT_EXPR 860// These aid the transition to C++11 while still supporting C++03 compilers 861// 862#ifdef BOOST_NO_NOEXCEPT 863# define BOOST_NOEXCEPT 864# define BOOST_NOEXCEPT_IF(Predicate) 865# define BOOST_NOEXCEPT_EXPR(Expression) false 866#else 867# define BOOST_NOEXCEPT noexcept 868# define BOOST_NOEXCEPT_IF(Predicate) noexcept((Predicate)) 869# define BOOST_NOEXCEPT_EXPR(Expression) noexcept((Expression)) 870#endif 871 872// 873// Normalize BOOST_NO_STATIC_ASSERT and (depricated) BOOST_HAS_STATIC_ASSERT: 874// 875#if !defined(BOOST_NO_STATIC_ASSERT) && !defined(BOOST_HAS_STATIC_ASSERT) 876# define BOOST_HAS_STATIC_ASSERT 877#endif 878 879// 880// constexpr workarounds 881// 882#if defined(BOOST_NO_CONSTEXPR) 883#define BOOST_CONSTEXPR 884#define BOOST_CONSTEXPR_OR_CONST const 885#else 886#define BOOST_CONSTEXPR constexpr 887#define BOOST_CONSTEXPR_OR_CONST constexpr 888#endif 889 890#define BOOST_STATIC_CONSTEXPR static BOOST_CONSTEXPR_OR_CONST 891 892// 893// Set BOOST_HAS_RVALUE_REFS when BOOST_NO_RVALUE_REFERENCES is not defined 894// 895#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_HAS_RVALUE_REFS) 896#define BOOST_HAS_RVALUE_REFS 897#endif 898 899// 900// Set BOOST_HAS_VARIADIC_TMPL when BOOST_NO_VARIADIC_TEMPLATES is not defined 901// 902#if !defined(BOOST_NO_VARIADIC_TEMPLATES) && !defined(BOOST_HAS_VARIADIC_TMPL) 903#define BOOST_HAS_VARIADIC_TMPL 904#endif 905 906 907#endif 908