Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. // Predefined symbols and macros -*- C++ -*-
  2.  
  3. // Copyright (C) 1997-2015 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_USE_NOEXCEPT noexcept
  119. #  define _GLIBCXX_THROW(_EXC)
  120. # else
  121. #  define _GLIBCXX_NOEXCEPT
  122. #  define _GLIBCXX_USE_NOEXCEPT throw()
  123. #  define _GLIBCXX_THROW(_EXC) throw(_EXC)
  124. # endif
  125. #endif
  126.  
  127. #ifndef _GLIBCXX_NOTHROW
  128. # define _GLIBCXX_NOTHROW _GLIBCXX_USE_NOEXCEPT
  129. #endif
  130.  
  131. #ifndef _GLIBCXX_THROW_OR_ABORT
  132. # if __cpp_exceptions
  133. #  define _GLIBCXX_THROW_OR_ABORT(_EXC) (throw (_EXC))
  134. # else
  135. #  define _GLIBCXX_THROW_OR_ABORT(_EXC) (__builtin_abort())
  136. # endif
  137. #endif
  138.  
  139. // Macro for extern template, ie controling template linkage via use
  140. // of extern keyword on template declaration. As documented in the g++
  141. // manual, it inhibits all implicit instantiations and is used
  142. // throughout the library to avoid multiple weak definitions for
  143. // required types that are already explicitly instantiated in the
  144. // library binary. This substantially reduces the binary size of
  145. // resulting executables.
  146. // Special case: _GLIBCXX_EXTERN_TEMPLATE == -1 disallows extern
  147. // templates only in basic_string, thus activating its debug-mode
  148. // checks even at -O0.
  149. #define _GLIBCXX_EXTERN_TEMPLATE
  150.  
  151. /*
  152.   Outline of libstdc++ namespaces.
  153.  
  154.   namespace std
  155.   {
  156.     namespace __debug { }
  157.     namespace __parallel { }
  158.     namespace __profile { }
  159.     namespace __cxx1998 { }
  160.  
  161.     namespace __detail { }
  162.  
  163.     namespace rel_ops { }
  164.  
  165.     namespace tr1
  166.     {
  167.       namespace placeholders { }
  168.       namespace regex_constants { }
  169.       namespace __detail { }
  170.     }
  171.  
  172.     namespace tr2 { }
  173.    
  174.     namespace decimal { }
  175.  
  176.     namespace chrono { }
  177.     namespace placeholders { }
  178.     namespace regex_constants { }
  179.     namespace this_thread { }
  180.  
  181.     namespace experimental { }
  182.   }
  183.  
  184.   namespace abi { }
  185.  
  186.   namespace __gnu_cxx
  187.   {
  188.     namespace __detail { }
  189.   }
  190.  
  191.   For full details see:
  192.   http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/namespaces.html
  193. */
  194. namespace std
  195. {
  196.   typedef __SIZE_TYPE__         size_t;
  197.   typedef __PTRDIFF_TYPE__      ptrdiff_t;
  198.  
  199. #if __cplusplus >= 201103L
  200.   typedef decltype(nullptr)     nullptr_t;
  201. #endif
  202. }
  203.  
  204. #define _GLIBCXX_USE_DUAL_ABI
  205.  
  206. #if ! _GLIBCXX_USE_DUAL_ABI
  207. // Ignore any pre-defined value of _GLIBCXX_USE_CXX11_ABI
  208. # undef _GLIBCXX_USE_CXX11_ABI
  209. #endif
  210.  
  211. #ifndef _GLIBCXX_USE_CXX11_ABI
  212. #define _GLIBCXX_USE_CXX11_ABI
  213. #endif
  214.  
  215. #if _GLIBCXX_USE_CXX11_ABI
  216. namespace std
  217. {
  218.   inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
  219. }
  220. namespace __gnu_cxx
  221. {
  222.   inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
  223. }
  224. # define _GLIBCXX_NAMESPACE_CXX11 __cxx11::
  225. # define _GLIBCXX_BEGIN_NAMESPACE_CXX11 namespace __cxx11 {
  226. # define _GLIBCXX_END_NAMESPACE_CXX11 }
  227. # define _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_ABI_TAG_CXX11
  228. #else
  229. # define _GLIBCXX_NAMESPACE_CXX11
  230. # define _GLIBCXX_BEGIN_NAMESPACE_CXX11
  231. # define _GLIBCXX_END_NAMESPACE_CXX11
  232. # define _GLIBCXX_DEFAULT_ABI_TAG
  233. #endif
  234.  
  235.  
  236. // Defined if inline namespaces are used for versioning.
  237. #define _GLIBCXX_INLINE_VERSION
  238.  
  239. // Inline namespace for symbol versioning.
  240. #if _GLIBCXX_INLINE_VERSION
  241.  
  242. namespace std
  243. {
  244.   inline namespace __7 { }
  245.  
  246.   namespace rel_ops { inline namespace __7 { } }
  247.  
  248.   namespace tr1
  249.   {
  250.     inline namespace __7 { }
  251.     namespace placeholders { inline namespace __7 { } }
  252.     namespace regex_constants { inline namespace __7 { } }
  253.     namespace __detail { inline namespace __7 { } }
  254.   }
  255.  
  256.   namespace tr2
  257.   { inline namespace __7 { } }
  258.  
  259.   namespace decimal { inline namespace __7 { } }
  260.  
  261.   namespace chrono { inline namespace __7 { } }
  262.   namespace placeholders { inline namespace __7 { } }
  263.   namespace regex_constants { inline namespace __7 { } }
  264.   namespace this_thread { inline namespace __7 { } }
  265.  
  266.   namespace experimental { inline namespace __7 { } }
  267.  
  268.   namespace __detail { inline namespace __7 { } }
  269. }
  270.  
  271. namespace __gnu_cxx
  272. {
  273.   inline namespace __7 { }
  274.   namespace __detail { inline namespace __7 { } }
  275. }
  276. # define _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace __7 {
  277. # define _GLIBCXX_END_NAMESPACE_VERSION }
  278. #else
  279. # define _GLIBCXX_BEGIN_NAMESPACE_VERSION
  280. # define _GLIBCXX_END_NAMESPACE_VERSION
  281. #endif
  282.  
  283.  
  284. // Inline namespaces for special modes: debug, parallel, profile.
  285. #if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL) \
  286.     || defined(_GLIBCXX_PROFILE)
  287. namespace std
  288. {
  289.   // Non-inline namespace for components replaced by alternates in active mode.
  290.   namespace __cxx1998
  291.   {
  292. # if _GLIBCXX_INLINE_VERSION
  293.   inline namespace __7 { }
  294. # endif
  295.  
  296. # if _GLIBCXX_USE_CXX11_ABI
  297.   inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
  298. # endif
  299.   }
  300.  
  301.   // Inline namespace for debug mode.
  302. # ifdef _GLIBCXX_DEBUG
  303.   inline namespace __debug { }
  304. # endif
  305.  
  306.   // Inline namespaces for parallel mode.
  307. # ifdef _GLIBCXX_PARALLEL
  308.   inline namespace __parallel { }
  309. # endif
  310.  
  311.   // Inline namespaces for profile mode
  312. # ifdef _GLIBCXX_PROFILE
  313.   inline namespace __profile { }
  314. # endif
  315. }
  316.  
  317. // Check for invalid usage and unsupported mixed-mode use.
  318. # if defined(_GLIBCXX_DEBUG) && defined(_GLIBCXX_PARALLEL)
  319. #  error illegal use of multiple inlined namespaces
  320. # endif
  321. # if defined(_GLIBCXX_PROFILE) && defined(_GLIBCXX_DEBUG)
  322. #  error illegal use of multiple inlined namespaces
  323. # endif
  324. # if defined(_GLIBCXX_PROFILE) && defined(_GLIBCXX_PARALLEL)
  325. #  error illegal use of multiple inlined namespaces
  326. # endif
  327.  
  328. // Check for invalid use due to lack for weak symbols.
  329. # if __NO_INLINE__ && !__GXX_WEAK__
  330. #  warning currently using inlined namespace mode which may fail \
  331.    without inlining due to lack of weak symbols
  332. # endif
  333. #endif
  334.  
  335. // Macros for namespace scope. Either namespace std:: or the name
  336. // of some nested namespace within it corresponding to the active mode.
  337. // _GLIBCXX_STD_A
  338. // _GLIBCXX_STD_C
  339. //
  340. // Macros for opening/closing conditional namespaces.
  341. // _GLIBCXX_BEGIN_NAMESPACE_ALGO
  342. // _GLIBCXX_END_NAMESPACE_ALGO
  343. // _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
  344. // _GLIBCXX_END_NAMESPACE_CONTAINER
  345. #if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PROFILE)
  346. # define _GLIBCXX_STD_C __cxx1998
  347. # define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER \
  348.          namespace _GLIBCXX_STD_C { _GLIBCXX_BEGIN_NAMESPACE_VERSION
  349. # define _GLIBCXX_END_NAMESPACE_CONTAINER \
  350.          _GLIBCXX_END_NAMESPACE_VERSION }
  351. # undef _GLIBCXX_EXTERN_TEMPLATE
  352. # define _GLIBCXX_EXTERN_TEMPLATE -1
  353. #endif
  354.  
  355. #ifdef _GLIBCXX_PARALLEL
  356. # define _GLIBCXX_STD_A __cxx1998
  357. # define _GLIBCXX_BEGIN_NAMESPACE_ALGO \
  358.          namespace _GLIBCXX_STD_A { _GLIBCXX_BEGIN_NAMESPACE_VERSION
  359. # define _GLIBCXX_END_NAMESPACE_ALGO \
  360.          _GLIBCXX_END_NAMESPACE_VERSION }
  361. #endif
  362.  
  363. #ifndef _GLIBCXX_STD_A
  364. # define _GLIBCXX_STD_A std
  365. #endif
  366.  
  367. #ifndef _GLIBCXX_STD_C
  368. # define _GLIBCXX_STD_C std
  369. #endif
  370.  
  371. #ifndef _GLIBCXX_BEGIN_NAMESPACE_ALGO
  372. # define _GLIBCXX_BEGIN_NAMESPACE_ALGO
  373. #endif
  374.  
  375. #ifndef _GLIBCXX_END_NAMESPACE_ALGO
  376. # define _GLIBCXX_END_NAMESPACE_ALGO
  377. #endif
  378.  
  379. #ifndef _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
  380. # define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
  381. #endif
  382.  
  383. #ifndef _GLIBCXX_END_NAMESPACE_CONTAINER
  384. # define _GLIBCXX_END_NAMESPACE_CONTAINER
  385. #endif
  386.  
  387. // GLIBCXX_ABI Deprecated
  388. // Define if compatibility should be provided for -mlong-double-64.
  389. #undef _GLIBCXX_LONG_DOUBLE_COMPAT
  390.  
  391. // Inline namespace for long double 128 mode.
  392. #if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
  393. namespace std
  394. {
  395.   inline namespace __gnu_cxx_ldbl128 { }
  396. }
  397. # define _GLIBCXX_NAMESPACE_LDBL __gnu_cxx_ldbl128::
  398. # define _GLIBCXX_BEGIN_NAMESPACE_LDBL namespace __gnu_cxx_ldbl128 {
  399. # define _GLIBCXX_END_NAMESPACE_LDBL }
  400. #else
  401. # define _GLIBCXX_NAMESPACE_LDBL
  402. # define _GLIBCXX_BEGIN_NAMESPACE_LDBL
  403. # define _GLIBCXX_END_NAMESPACE_LDBL
  404. #endif
  405. #if _GLIBCXX_USE_CXX11_ABI
  406. # define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_CXX11
  407. # define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_CXX11
  408. # define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_CXX11
  409. #else
  410. # define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_LDBL
  411. # define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_LDBL
  412. # define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_LDBL
  413. #endif
  414.  
  415. // Assert.
  416. #if !defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_PARALLEL)
  417. # define __glibcxx_assert(_Condition)
  418. #else
  419. namespace std
  420. {
  421.   // Avoid the use of assert, because we're trying to keep the <cassert>
  422.   // include out of the mix.
  423.   inline void
  424.   __replacement_assert(const char* __file, int __line,
  425.                        const char* __function, const char* __condition)
  426.   {
  427.     __builtin_printf("%s:%d: %s: Assertion '%s' failed.\n", __file, __line,
  428.                      __function, __condition);
  429.     __builtin_abort();
  430.   }
  431. }
  432. #define __glibcxx_assert(_Condition)                                     \
  433.   do                                                                     \
  434.   {                                                                      \
  435.     if (! (_Condition))                                                  \
  436.       std::__replacement_assert(__FILE__, __LINE__, __PRETTY_FUNCTION__, \
  437.                                 #_Condition);                            \
  438.   } while (false)
  439. #endif
  440.  
  441. // Macros for race detectors.
  442. // _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) and
  443. // _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) should be used to explain
  444. // atomic (lock-free) synchronization to race detectors:
  445. // the race detector will infer a happens-before arc from the former to the
  446. // latter when they share the same argument pointer.
  447. //
  448. // The most frequent use case for these macros (and the only case in the
  449. // current implementation of the library) is atomic reference counting:
  450. //   void _M_remove_reference()
  451. //   {
  452. //     _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount);
  453. //     if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <= 0)
  454. //       {
  455. //         _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount);
  456. //         _M_destroy(__a);
  457. //       }
  458. //   }
  459. // The annotations in this example tell the race detector that all memory
  460. // accesses occurred when the refcount was positive do not race with
  461. // memory accesses which occurred after the refcount became zero.
  462. #ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE
  463. # define  _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A)
  464. #endif
  465. #ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER
  466. # define  _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A)
  467. #endif
  468.  
  469. // Macros for C linkage: define extern "C" linkage only when using C++.
  470. # define _GLIBCXX_BEGIN_EXTERN_C extern "C" {
  471. # define _GLIBCXX_END_EXTERN_C }
  472.  
  473. #else // !__cplusplus
  474. # define _GLIBCXX_BEGIN_EXTERN_C
  475. # define _GLIBCXX_END_EXTERN_C
  476. #endif
  477.  
  478.  
  479. // First includes.
  480.  
  481. // Pick up any OS-specific definitions.
  482. #include <bits/os_defines.h>
  483.  
  484. // Pick up any CPU-specific definitions.
  485. #include <bits/cpu_defines.h>
  486.  
  487. // If platform uses neither visibility nor psuedo-visibility,
  488. // specify empty default for namespace annotation macros.
  489. #ifndef _GLIBCXX_PSEUDO_VISIBILITY
  490. # define _GLIBCXX_PSEUDO_VISIBILITY(V)
  491. #endif
  492.  
  493. // Certain function definitions that are meant to be overridable from
  494. // user code are decorated with this macro.  For some targets, this
  495. // macro causes these definitions to be weak.
  496. #ifndef _GLIBCXX_WEAK_DEFINITION
  497. # define _GLIBCXX_WEAK_DEFINITION
  498. #endif
  499.  
  500.  
  501. // The remainder of the prewritten config is automatic; all the
  502. // user hooks are listed above.
  503.  
  504. // Create a boolean flag to be used to determine if --fast-math is set.
  505. #ifdef __FAST_MATH__
  506. # define _GLIBCXX_FAST_MATH 1
  507. #else
  508. # define _GLIBCXX_FAST_MATH 0
  509. #endif
  510.  
  511. // This marks string literals in header files to be extracted for eventual
  512. // translation.  It is primarily used for messages in thrown exceptions; see
  513. // src/functexcept.cc.  We use __N because the more traditional _N is used
  514. // for something else under certain OSes (see BADNAMES).
  515. #define __N(msgid)     (msgid)
  516.  
  517. // For example, <windows.h> is known to #define min and max as macros...
  518. #undef min
  519. #undef max
  520.  
  521. // End of prewritten config; the settings discovered at configure time follow.
  522.