1// Predefined symbols and macros -*- C++ -*- 2 3// Copyright (C) 1997-2017 Free Software Foundation, Inc. 4// 5// This file is part of the GNU ISO C++ Library. This library is free 6// software; you can redistribute it and/or modify it under the 7// terms of the GNU General Public License as published by the 8// Free Software Foundation; either version 3, or (at your option) 9// any later version. 10 11// This library is distributed in the hope that it will be useful, 12// but WITHOUT ANY WARRANTY; without even the implied warranty of 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14// GNU General Public License for more details. 15 16// Under Section 7 of GPL version 3, you are granted additional 17// permissions described in the GCC Runtime Library Exception, version 18// 3.1, as published by the Free Software Foundation. 19 20// You should have received a copy of the GNU General Public License and 21// a copy of the GCC Runtime Library Exception along with this program; 22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23// <http://www.gnu.org/licenses/>. 24 25/** @file bits/c++config.h 26 * This is an internal header file, included by other library headers. 27 * Do not attempt to use it directly. @headername{iosfwd} 28 */ 29 30#ifndef _GLIBCXX_CXX_CONFIG_H 31#define _GLIBCXX_CXX_CONFIG_H 1 32 33// The major release number for the GCC release the C++ library belongs to. 34#define _GLIBCXX_RELEASE 35 36// The datestamp of the C++ library in compressed ISO date format. 37#define __GLIBCXX__ 38 39// Macros for various attributes. 40// _GLIBCXX_PURE 41// _GLIBCXX_CONST 42// _GLIBCXX_NORETURN 43// _GLIBCXX_NOTHROW 44// _GLIBCXX_VISIBILITY 45#ifndef _GLIBCXX_PURE 46# define _GLIBCXX_PURE __attribute__ ((__pure__)) 47#endif 48 49#ifndef _GLIBCXX_CONST 50# define _GLIBCXX_CONST __attribute__ ((__const__)) 51#endif 52 53#ifndef _GLIBCXX_NORETURN 54# define _GLIBCXX_NORETURN __attribute__ ((__noreturn__)) 55#endif 56 57// See below for C++ 58#ifndef _GLIBCXX_NOTHROW 59# ifndef __cplusplus 60# define _GLIBCXX_NOTHROW __attribute__((__nothrow__)) 61# endif 62#endif 63 64// Macros for visibility attributes. 65// _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 66// _GLIBCXX_VISIBILITY 67#define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 68 69#if _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 70# define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V))) 71#else 72// If this is not supplied by the OS-specific or CPU-specific 73// headers included below, it will be defined to an empty default. 74# define _GLIBCXX_VISIBILITY(V) _GLIBCXX_PSEUDO_VISIBILITY(V) 75#endif 76 77// Macros for deprecated attributes. 78// _GLIBCXX_USE_DEPRECATED 79// _GLIBCXX_DEPRECATED 80#ifndef _GLIBCXX_USE_DEPRECATED 81# define _GLIBCXX_USE_DEPRECATED 1 82#endif 83 84#if defined(__DEPRECATED) && (__cplusplus >= 201103L) 85# define _GLIBCXX_DEPRECATED __attribute__ ((__deprecated__)) 86#else 87# define _GLIBCXX_DEPRECATED 88#endif 89 90// Macros for ABI tag attributes. 91#ifndef _GLIBCXX_ABI_TAG_CXX11 92# define _GLIBCXX_ABI_TAG_CXX11 __attribute ((__abi_tag__ ("cxx11"))) 93#endif 94 95 96#if __cplusplus 97 98// Macro for constexpr, to support in mixed 03/0x mode. 99#ifndef _GLIBCXX_CONSTEXPR 100# if __cplusplus >= 201103L 101# define _GLIBCXX_CONSTEXPR constexpr 102# define _GLIBCXX_USE_CONSTEXPR constexpr 103# else 104# define _GLIBCXX_CONSTEXPR 105# define _GLIBCXX_USE_CONSTEXPR const 106# endif 107#endif 108 109#ifndef _GLIBCXX14_CONSTEXPR 110# if __cplusplus >= 201402L 111# define _GLIBCXX14_CONSTEXPR constexpr 112# else 113# define _GLIBCXX14_CONSTEXPR 114# endif 115#endif 116 117#ifndef _GLIBCXX17_CONSTEXPR 118# if __cplusplus > 201402L 119# define _GLIBCXX17_CONSTEXPR constexpr 120# else 121# define _GLIBCXX17_CONSTEXPR 122# endif 123#endif 124 125#ifndef _GLIBCXX17_INLINE 126# if __cplusplus > 201402L 127# define _GLIBCXX17_INLINE inline 128# else 129# define _GLIBCXX17_INLINE 130# endif 131#endif 132 133// Macro for noexcept, to support in mixed 03/0x mode. 134#ifndef _GLIBCXX_NOEXCEPT 135# if __cplusplus >= 201103L 136# define _GLIBCXX_NOEXCEPT noexcept 137# define _GLIBCXX_NOEXCEPT_IF(_COND) noexcept(_COND) 138# define _GLIBCXX_USE_NOEXCEPT noexcept 139# define _GLIBCXX_THROW(_EXC) 140# else 141# define _GLIBCXX_NOEXCEPT 142# define _GLIBCXX_NOEXCEPT_IF(_COND) 143# define _GLIBCXX_USE_NOEXCEPT throw() 144# define _GLIBCXX_THROW(_EXC) throw(_EXC) 145# endif 146#endif 147 148#ifndef _GLIBCXX_NOTHROW 149# define _GLIBCXX_NOTHROW _GLIBCXX_USE_NOEXCEPT 150#endif 151 152#ifndef _GLIBCXX_THROW_OR_ABORT 153# if __cpp_exceptions 154# define _GLIBCXX_THROW_OR_ABORT(_EXC) (throw (_EXC)) 155# else 156# define _GLIBCXX_THROW_OR_ABORT(_EXC) (__builtin_abort()) 157# endif 158#endif 159 160#if __cpp_noexcept_function_type 161#define _GLIBCXX_NOEXCEPT_PARM , bool _NE 162#define _GLIBCXX_NOEXCEPT_QUAL noexcept (_NE) 163#else 164#define _GLIBCXX_NOEXCEPT_PARM 165#define _GLIBCXX_NOEXCEPT_QUAL 166#endif 167 168// Macro for extern template, ie controlling template linkage via use 169// of extern keyword on template declaration. As documented in the g++ 170// manual, it inhibits all implicit instantiations and is used 171// throughout the library to avoid multiple weak definitions for 172// required types that are already explicitly instantiated in the 173// library binary. This substantially reduces the binary size of 174// resulting executables. 175// Special case: _GLIBCXX_EXTERN_TEMPLATE == -1 disallows extern 176// templates only in basic_string, thus activating its debug-mode 177// checks even at -O0. 178#define _GLIBCXX_EXTERN_TEMPLATE 179 180/* 181 Outline of libstdc++ namespaces. 182 183 namespace std 184 { 185 namespace __debug { } 186 namespace __parallel { } 187 namespace __profile { } 188 namespace __cxx1998 { } 189 190 namespace __detail { 191 namespace __variant { } // C++17 192 } 193 194 namespace rel_ops { } 195 196 namespace tr1 197 { 198 namespace placeholders { } 199 namespace regex_constants { } 200 namespace __detail { } 201 } 202 203 namespace tr2 { } 204 205 namespace decimal { } 206 207 namespace chrono { } // C++11 208 namespace placeholders { } // C++11 209 namespace regex_constants { } // C++11 210 namespace this_thread { } // C++11 211 inline namespace literals { // C++14 212 inline namespace chrono_literals { } // C++14 213 inline namespace complex_literals { } // C++14 214 inline namespace string_literals { } // C++14 215 inline namespace string_view_literals { } // C++17 216 } 217 } 218 219 namespace abi { } 220 221 namespace __gnu_cxx 222 { 223 namespace __detail { } 224 } 225 226 For full details see: 227 http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/namespaces.html 228*/ 229namespace std 230{ 231 typedef __SIZE_TYPE__ size_t; 232 typedef __PTRDIFF_TYPE__ ptrdiff_t; 233 234#if __cplusplus >= 201103L 235 typedef decltype(nullptr) nullptr_t; 236#endif 237} 238 239#define _GLIBCXX_USE_DUAL_ABI 240 241#if ! _GLIBCXX_USE_DUAL_ABI 242// Ignore any pre-defined value of _GLIBCXX_USE_CXX11_ABI 243# undef _GLIBCXX_USE_CXX11_ABI 244#endif 245 246#ifndef _GLIBCXX_USE_CXX11_ABI 247#define _GLIBCXX_USE_CXX11_ABI 248#endif 249 250#if _GLIBCXX_USE_CXX11_ABI 251namespace std 252{ 253 inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } 254} 255namespace __gnu_cxx 256{ 257 inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } 258} 259# define _GLIBCXX_NAMESPACE_CXX11 __cxx11:: 260# define _GLIBCXX_BEGIN_NAMESPACE_CXX11 namespace __cxx11 { 261# define _GLIBCXX_END_NAMESPACE_CXX11 } 262# define _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_ABI_TAG_CXX11 263#else 264# define _GLIBCXX_NAMESPACE_CXX11 265# define _GLIBCXX_BEGIN_NAMESPACE_CXX11 266# define _GLIBCXX_END_NAMESPACE_CXX11 267# define _GLIBCXX_DEFAULT_ABI_TAG 268#endif 269 270 271// Defined if inline namespaces are used for versioning. 272#define _GLIBCXX_INLINE_VERSION 273 274// Inline namespace for symbol versioning. 275#if _GLIBCXX_INLINE_VERSION 276 277namespace std 278{ 279 inline namespace __7 { } 280 281 namespace rel_ops { inline namespace __7 { } } 282 283 namespace tr1 284 { 285 inline namespace __7 { } 286 namespace placeholders { inline namespace __7 { } } 287 namespace regex_constants { inline namespace __7 { } } 288 namespace __detail { inline namespace __7 { } } 289 } 290 291 namespace tr2 292 { inline namespace __7 { } } 293 294 namespace decimal { inline namespace __7 { } } 295 296#if __cplusplus >= 201103L 297 namespace chrono { inline namespace __7 { } } 298 namespace placeholders { inline namespace __7 { } } 299 namespace regex_constants { inline namespace __7 { } } 300 namespace this_thread { inline namespace __7 { } } 301 302#if __cplusplus >= 201402L 303 inline namespace literals { 304 inline namespace chrono_literals { inline namespace __7 { } } 305 inline namespace complex_literals { inline namespace __7 { } } 306 inline namespace string_literals { inline namespace __7 { } } 307#if __cplusplus > 201402L 308 inline namespace string_view_literals { inline namespace __7 { } } 309#endif // C++17 310 } 311#endif // C++14 312#endif // C++11 313 314 namespace __detail { 315 inline namespace __7 { } 316#if __cplusplus > 201402L 317 namespace __variant { inline namespace __7 { } } 318#endif 319 } 320} 321 322namespace __gnu_cxx 323{ 324 inline namespace __7 { } 325 namespace __detail { inline namespace __7 { } } 326} 327# define _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace __7 { 328# define _GLIBCXX_END_NAMESPACE_VERSION } 329#else 330# define _GLIBCXX_BEGIN_NAMESPACE_VERSION 331# define _GLIBCXX_END_NAMESPACE_VERSION 332#endif 333 334 335// Inline namespaces for special modes: debug, parallel, profile. 336#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL) \ 337 || defined(_GLIBCXX_PROFILE) 338namespace std 339{ 340 // Non-inline namespace for components replaced by alternates in active mode. 341 namespace __cxx1998 342 { 343# if _GLIBCXX_INLINE_VERSION 344 inline namespace __7 { } 345# endif 346 347# if _GLIBCXX_USE_CXX11_ABI 348 inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } 349# endif 350 } 351 352 // Inline namespace for debug mode. 353# ifdef _GLIBCXX_DEBUG 354 inline namespace __debug { } 355# endif 356 357 // Inline namespaces for parallel mode. 358# ifdef _GLIBCXX_PARALLEL 359 inline namespace __parallel { } 360# endif 361 362 // Inline namespaces for profile mode 363# ifdef _GLIBCXX_PROFILE 364 inline namespace __profile { } 365# endif 366} 367 368// Check for invalid usage and unsupported mixed-mode use. 369# if defined(_GLIBCXX_DEBUG) && defined(_GLIBCXX_PARALLEL) 370# error illegal use of multiple inlined namespaces 371# endif 372# if defined(_GLIBCXX_PROFILE) && defined(_GLIBCXX_DEBUG) 373# error illegal use of multiple inlined namespaces 374# endif 375# if defined(_GLIBCXX_PROFILE) && defined(_GLIBCXX_PARALLEL) 376# error illegal use of multiple inlined namespaces 377# endif 378 379// Check for invalid use due to lack for weak symbols. 380# if __NO_INLINE__ && !__GXX_WEAK__ 381# warning currently using inlined namespace mode which may fail \ 382 without inlining due to lack of weak symbols 383# endif 384#endif 385 386// Macros for namespace scope. Either namespace std:: or the name 387// of some nested namespace within it corresponding to the active mode. 388// _GLIBCXX_STD_A 389// _GLIBCXX_STD_C 390// 391// Macros for opening/closing conditional namespaces. 392// _GLIBCXX_BEGIN_NAMESPACE_ALGO 393// _GLIBCXX_END_NAMESPACE_ALGO 394// _GLIBCXX_BEGIN_NAMESPACE_CONTAINER 395// _GLIBCXX_END_NAMESPACE_CONTAINER 396#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PROFILE) 397# define _GLIBCXX_STD_C __cxx1998 398# define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER \ 399 namespace _GLIBCXX_STD_C { _GLIBCXX_BEGIN_NAMESPACE_VERSION 400# define _GLIBCXX_END_NAMESPACE_CONTAINER \ 401 _GLIBCXX_END_NAMESPACE_VERSION } 402#else 403# define _GLIBCXX_STD_C std 404# define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER _GLIBCXX_BEGIN_NAMESPACE_VERSION 405# define _GLIBCXX_END_NAMESPACE_CONTAINER _GLIBCXX_END_NAMESPACE_VERSION 406#endif 407 408#ifdef _GLIBCXX_PARALLEL 409# define _GLIBCXX_STD_A __cxx1998 410# define _GLIBCXX_BEGIN_NAMESPACE_ALGO \ 411 namespace _GLIBCXX_STD_A { _GLIBCXX_BEGIN_NAMESPACE_VERSION 412# define _GLIBCXX_END_NAMESPACE_ALGO \ 413 _GLIBCXX_END_NAMESPACE_VERSION } 414#else 415# define _GLIBCXX_STD_A std 416# define _GLIBCXX_BEGIN_NAMESPACE_ALGO _GLIBCXX_BEGIN_NAMESPACE_VERSION 417# define _GLIBCXX_END_NAMESPACE_ALGO _GLIBCXX_END_NAMESPACE_VERSION 418#endif 419 420// GLIBCXX_ABI Deprecated 421// Define if compatibility should be provided for -mlong-double-64. 422#undef _GLIBCXX_LONG_DOUBLE_COMPAT 423 424// Inline namespace for long double 128 mode. 425#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ 426namespace std 427{ 428 inline namespace __gnu_cxx_ldbl128 { } 429} 430# define _GLIBCXX_NAMESPACE_LDBL __gnu_cxx_ldbl128:: 431# define _GLIBCXX_BEGIN_NAMESPACE_LDBL namespace __gnu_cxx_ldbl128 { 432# define _GLIBCXX_END_NAMESPACE_LDBL } 433#else 434# define _GLIBCXX_NAMESPACE_LDBL 435# define _GLIBCXX_BEGIN_NAMESPACE_LDBL 436# define _GLIBCXX_END_NAMESPACE_LDBL 437#endif 438#if _GLIBCXX_USE_CXX11_ABI 439# define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_CXX11 440# define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_CXX11 441# define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_CXX11 442#else 443# define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_LDBL 444# define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_LDBL 445# define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_LDBL 446#endif 447 448// Debug Mode implies checking assertions. 449#if defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_ASSERTIONS) 450# define _GLIBCXX_ASSERTIONS 1 451#endif 452 453// Disable std::string explicit instantiation declarations in order to assert. 454#ifdef _GLIBCXX_ASSERTIONS 455# undef _GLIBCXX_EXTERN_TEMPLATE 456# define _GLIBCXX_EXTERN_TEMPLATE -1 457#endif 458 459// Assert. 460#if defined(_GLIBCXX_ASSERTIONS) \ 461 || defined(_GLIBCXX_PARALLEL) || defined(_GLIBCXX_PARALLEL_ASSERTIONS) 462namespace std 463{ 464 // Avoid the use of assert, because we're trying to keep the <cassert> 465 // include out of the mix. 466 inline void 467 __replacement_assert(const char* __file, int __line, 468 const char* __function, const char* __condition) 469 { 470 __builtin_printf("%s:%d: %s: Assertion '%s' failed.\n", __file, __line, 471 __function, __condition); 472 __builtin_abort(); 473 } 474} 475#define __glibcxx_assert_impl(_Condition) \ 476 do \ 477 { \ 478 if (! (_Condition)) \ 479 std::__replacement_assert(__FILE__, __LINE__, __PRETTY_FUNCTION__, \ 480 #_Condition); \ 481 } while (false) 482#endif 483 484#if defined(_GLIBCXX_ASSERTIONS) 485# define __glibcxx_assert(_Condition) __glibcxx_assert_impl(_Condition) 486#else 487# define __glibcxx_assert(_Condition) 488#endif 489 490// Macros for race detectors. 491// _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) and 492// _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) should be used to explain 493// atomic (lock-free) synchronization to race detectors: 494// the race detector will infer a happens-before arc from the former to the 495// latter when they share the same argument pointer. 496// 497// The most frequent use case for these macros (and the only case in the 498// current implementation of the library) is atomic reference counting: 499// void _M_remove_reference() 500// { 501// _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount); 502// if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <= 0) 503// { 504// _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount); 505// _M_destroy(__a); 506// } 507// } 508// The annotations in this example tell the race detector that all memory 509// accesses occurred when the refcount was positive do not race with 510// memory accesses which occurred after the refcount became zero. 511#ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE 512# define _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) 513#endif 514#ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER 515# define _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) 516#endif 517 518// Macros for C linkage: define extern "C" linkage only when using C++. 519# define _GLIBCXX_BEGIN_EXTERN_C extern "C" { 520# define _GLIBCXX_END_EXTERN_C } 521 522#define _GLIBCXX_USE_ALLOCATOR_NEW 523 524#else // !__cplusplus 525# define _GLIBCXX_BEGIN_EXTERN_C 526# define _GLIBCXX_END_EXTERN_C 527#endif 528 529 530// First includes. 531 532// Pick up any OS-specific definitions. 533#include <bits/os_defines.h> 534 535// Pick up any CPU-specific definitions. 536#include <bits/cpu_defines.h> 537 538// If platform uses neither visibility nor psuedo-visibility, 539// specify empty default for namespace annotation macros. 540#ifndef _GLIBCXX_PSEUDO_VISIBILITY 541# define _GLIBCXX_PSEUDO_VISIBILITY(V) 542#endif 543 544// Certain function definitions that are meant to be overridable from 545// user code are decorated with this macro. For some targets, this 546// macro causes these definitions to be weak. 547#ifndef _GLIBCXX_WEAK_DEFINITION 548# define _GLIBCXX_WEAK_DEFINITION 549#endif 550 551// By default, we assume that __GXX_WEAK__ also means that there is support 552// for declaring functions as weak while not defining such functions. This 553// allows for referring to functions provided by other libraries (e.g., 554// libitm) without depending on them if the respective features are not used. 555#ifndef _GLIBCXX_USE_WEAK_REF 556# define _GLIBCXX_USE_WEAK_REF __GXX_WEAK__ 557#endif 558 559// Conditionally enable annotations for the Transactional Memory TS on C++11. 560// Most of the following conditions are due to limitations in the current 561// implementation. 562#if __cplusplus >= 201103L && _GLIBCXX_USE_CXX11_ABI \ 563 && _GLIBCXX_USE_DUAL_ABI && __cpp_transactional_memory >= 201505L \ 564 && !_GLIBCXX_FULLY_DYNAMIC_STRING && _GLIBCXX_USE_WEAK_REF \ 565 && _GLIBCXX_USE_ALLOCATOR_NEW 566#define _GLIBCXX_TXN_SAFE transaction_safe 567#define _GLIBCXX_TXN_SAFE_DYN transaction_safe_dynamic 568#else 569#define _GLIBCXX_TXN_SAFE 570#define _GLIBCXX_TXN_SAFE_DYN 571#endif 572 573#if __cplusplus > 201402L 574// In C++17 mathematical special functions are in namespace std. 575# define _GLIBCXX_USE_STD_SPEC_FUNCS 1 576#elif __cplusplus >= 201103L && __STDCPP_WANT_MATH_SPEC_FUNCS__ != 0 577// For C++11 and C++14 they are in namespace std when requested. 578# define _GLIBCXX_USE_STD_SPEC_FUNCS 1 579#endif 580 581// The remainder of the prewritten config is automatic; all the 582// user hooks are listed above. 583 584// Create a boolean flag to be used to determine if --fast-math is set. 585#ifdef __FAST_MATH__ 586# define _GLIBCXX_FAST_MATH 1 587#else 588# define _GLIBCXX_FAST_MATH 0 589#endif 590 591// This marks string literals in header files to be extracted for eventual 592// translation. It is primarily used for messages in thrown exceptions; see 593// src/functexcept.cc. We use __N because the more traditional _N is used 594// for something else under certain OSes (see BADNAMES). 595#define __N(msgid) (msgid) 596 597// For example, <windows.h> is known to #define min and max as macros... 598#undef min 599#undef max 600 601// N.B. these _GLIBCXX_USE_C99_XXX macros are defined unconditionally 602// so they should be tested with #if not with #ifdef. 603#if __cplusplus >= 201103L 604# ifndef _GLIBCXX_USE_C99_MATH 605# define _GLIBCXX_USE_C99_MATH _GLIBCXX11_USE_C99_MATH 606# endif 607# ifndef _GLIBCXX_USE_C99_COMPLEX 608# define _GLIBCXX_USE_C99_COMPLEX _GLIBCXX11_USE_C99_COMPLEX 609# endif 610# ifndef _GLIBCXX_USE_C99_STDIO 611# define _GLIBCXX_USE_C99_STDIO _GLIBCXX11_USE_C99_STDIO 612# endif 613# ifndef _GLIBCXX_USE_C99_STDLIB 614# define _GLIBCXX_USE_C99_STDLIB _GLIBCXX11_USE_C99_STDLIB 615# endif 616# ifndef _GLIBCXX_USE_C99_WCHAR 617# define _GLIBCXX_USE_C99_WCHAR _GLIBCXX11_USE_C99_WCHAR 618# endif 619#else 620# ifndef _GLIBCXX_USE_C99_MATH 621# define _GLIBCXX_USE_C99_MATH _GLIBCXX98_USE_C99_MATH 622# endif 623# ifndef _GLIBCXX_USE_C99_COMPLEX 624# define _GLIBCXX_USE_C99_COMPLEX _GLIBCXX98_USE_C99_COMPLEX 625# endif 626# ifndef _GLIBCXX_USE_C99_STDIO 627# define _GLIBCXX_USE_C99_STDIO _GLIBCXX98_USE_C99_STDIO 628# endif 629# ifndef _GLIBCXX_USE_C99_STDLIB 630# define _GLIBCXX_USE_C99_STDLIB _GLIBCXX98_USE_C99_STDLIB 631# endif 632# ifndef _GLIBCXX_USE_C99_WCHAR 633# define _GLIBCXX_USE_C99_WCHAR _GLIBCXX98_USE_C99_WCHAR 634# endif 635#endif 636 637/* Define if __float128 is supported on this host. */ 638#if defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__) 639#define _GLIBCXX_USE_FLOAT128 640#endif 641 642// End of prewritten config; the settings discovered at configure time follow. 643