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