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