+2011-01-30 Benjamin Kosnik <bkoz@redhat.com>
+
+ PR libstdc++/36104 part four
+ * include/bits/c++config (_GLIBCXX_STD): Remove.
+ (_GLIBCXX_STD_D, _GLIBCXX_PR): Now _GLIBCXX_STD_C.
+ (_GLIBCXX_P): Now _GLIBCXX_STD_A.
+ (_GLIBCXX_NAMESPACE_DEBUG, _GLIBCXX_NAMESPACE_PARALLEL,
+ _GLIBCXX_NAMESPACE_PROFILE, _GLIBCXX_NAMESPACE_VERSION): Remove.
+ (_GLIBCXX_INLINE_DEBUG, _GLIBCXX_INLINE_PARALLEL,
+ _GLIBCXX_INLINE_PROFILE): Remove.
+ (_GLIBCXX_BEGIN_NAMESPACE(X)): Remove.
+ (_GLIBCXX_END_NAMESPACE): Remove.
+ (_GLIBCXX_BEGIN_NESTED_NAMESPACE(X, Y)): Remove.
+ (_GLIBCXX_END_NESTED_NAMESPACE): Remove.
+ (_GLIBCXX_BEGIN_NAMESPACE_ALGO): Add.
+ (_GLIBCXX_END_NAMESPACE_ALGO): Add.
+ (_GLIBCXX_BEGIN_NAMESPACE_CONTAINER): Add.
+ (_GLIBCXX_END_NAMESPACE_CONTAINER): Add.
+ (_GLIBCXX_BEGIN_NAMESPACE_VERSION): Add.
+ (_GLIBCXX_END_NAMESPACE_VERSION): Add.
+ (_GLIBCXX_BEGIN_LDBL_NAMESPACE): To _GLIBCXX_BEGIN_NAMESPACE_LDBL.
+ (_GLIBCXX_END_LDBL_NAMESPACE): To _GLIBCXX_END_NAMESPACE_LDBL.
+ (_GLIBCXX_VISIBILITY_ATTR): Revert to _GLIBCXX_VISIBILITY.
+ * include/*: Use new macros for namespace scope.
+ * config/*: Same.
+ * src/*: Same.
+
+ * src/Makefile.am (sources): Remove debug_list.cc, add
+ compatibility-debug_list-2.cc.
+ (parallel_sources): Remove parallel_list.cc, add
+ compatibility-parallel_list-2.cc.
+ (compatibility-parallel_list-2.[o,lo]): New rule.
+ * src/Makefile.in: Regenerate.
+ * src/debug_list.cc: Remove.
+ * src/parallel_list.cc: Remove.
+ * src/compatibility-list-2.cc: New.
+ * src/compatibility-debug_list-2.cc: New.
+ * src/compatibility-parallel_list-2.cc: New.
+
+ * doc/doxygen/user.cfg.in: Adjust macros.
+
+ * testsuite/20_util/auto_ptr/assign_neg.cc: Adjust line numbers, macros.
+ * testsuite/20_util/declval/requirements/1_neg.cc: Same.
+ * testsuite/20_util/duration/requirements/typedefs_neg1.cc: Same.
+ * testsuite/20_util/duration/requirements/typedefs_neg2.cc: Same.
+ * testsuite/20_util/duration/requirements/typedefs_neg3.cc: Same.
+ * testsuite/20_util/forward/c_neg.cc: Same.
+ * testsuite/20_util/forward/f_neg.cc: Same.
+ * testsuite/20_util/make_signed/requirements/typedefs_neg.cc: Same.
+ * testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc: Same.
+ * testsuite/20_util/ratio/cons/cons_overflow_neg.cc: Same.
+ * testsuite/20_util/ratio/operations/ops_overflow_neg.cc: Same.
+ * testsuite/20_util/shared_ptr/cons/43820_neg.cc: Same.
+ * testsuite/20_util/weak_ptr/comparison/cmp_neg.cc: Same.
+ * testsuite/23_containers/deque/requirements/dr438/assign_neg.cc: Same.
+ * testsuite/23_containers/deque/requirements/dr438/
+ constructor_1_neg.cc: Same.
+ * testsuite/23_containers/deque/requirements/dr438/
+ constructor_2_neg.cc: Same.
+ * testsuite/23_containers/deque/requirements/dr438/insert_neg.cc: Same.
+ * testsuite/23_containers/forward_list/capacity/1.cc: Same.
+ * testsuite/23_containers/forward_list/requirements/dr438/
+ assign_neg.cc: Same.
+ * testsuite/23_containers/forward_list/requirements/dr438/
+ constructor_1_neg.cc: Same.
+ * testsuite/23_containers/forward_list/requirements/dr438/
+ constructor_2_neg.cc: Same.
+ * testsuite/23_containers/forward_list/requirements/dr438/
+ insert_neg.cc: Same.
+ * testsuite/23_containers/list/capacity/29134.cc: Same.
+ * testsuite/23_containers/list/requirements/dr438/assign_neg.cc: Same.
+ * testsuite/23_containers/list/requirements/dr438/
+ constructor_1_neg.cc: Same.
+ * testsuite/23_containers/list/requirements/dr438/
+ constructor_2_neg.cc: Same.
+ * testsuite/23_containers/list/requirements/dr438/insert_neg.cc: Same.
+ * testsuite/23_containers/vector/bool/capacity/29134.cc: Same.
+ * testsuite/23_containers/vector/bool/modifiers/insert/31370.cc: Same.
+ * testsuite/23_containers/vector/requirements/dr438/assign_neg.cc: Same.
+ * testsuite/23_containers/vector/requirements/dr438/
+ constructor_1_neg.cc: Same.
+ * testsuite/23_containers/vector/requirements/dr438/
+ constructor_2_neg.cc: Same.
+ * testsuite/23_containers/vector/requirements/dr438/insert_neg.cc: Same.
+ * testsuite/25_algorithms/sort/35588.cc: Same.
+ * testsuite/27_io/ios_base/cons/assign_neg.cc: Same.
+ * testsuite/27_io/ios_base/cons/copy_neg.cc: Same.
+ * testsuite/ext/profile/mutex_extensions_neg.cc: Same.
+ * testsuite/ext/profile/profiler_algos.cc: Same.
+ * testsuite/ext/type_traits/add_unsigned_floating_neg.cc: Same.
+ * testsuite/ext/type_traits/add_unsigned_integer_neg.cc: Same.
+ * testsuite/ext/type_traits/remove_unsigned_floating_neg.cc: Same.
+ * testsuite/ext/type_traits/remove_unsigned_integer_neg.cc: Same.
+ * testsuite/tr1/2_general_utilities/shared_ptr/cons/43820_neg.cc: Same.
+
2011-01-30 Gerald Pfeifer <gerald@pfeifer.com>
* doc/xml/manual/abi.xml: Adjust link to C++ ABI specification.
Improve description of one such reference.
2011-01-30 Gerald Pfeifer <gerald@pfeifer.com>
-
+
* doc/xml/manual/codecvt.xml: Fix link to The Austin Common
Standards Revision Group.
* doc/xml/manual/locale.xml: Ditto.
2011-01-26 Johannes Singler <singler@kit.edu>
- * include/parallel/numeric (inner_product, partial_sum):
- Qualify subsequent call with __gnu_parallel instead of
- _GLIBCXX_STD_P to reenable parallel execution without ambiguity.
- * include/parallel/algobase.h (equal): Likewise.
- * include/parallel/algo.h (find_first_of, search_n, merge,
- nth_element, partial_sort, max_element, min_element): Likewise.
- * testsuite/25_algorithms/headers/algorithm/
- parallel_algorithm_mixed1.cc (main): Add respective test cases.
- * testsuite/25_algorithms/headers/algorithm/
- parallel_algorithm_mixed2.cc (main): Likewise.
- * testsuite/26_numerics/headers/numeric/
- parallel_numeric_mixed1.cc (main): Likewise.
- * testsuite/26_numerics/headers/numeric/
- parallel_numeric_mixed2.cc (main): Likewise.
+ * include/parallel/numeric (inner_product, partial_sum):
+ Qualify subsequent call with __gnu_parallel instead of
+ _GLIBCXX_STD_P to reenable parallel execution without ambiguity.
+ * include/parallel/algobase.h (equal): Likewise.
+ * include/parallel/algo.h (find_first_of, search_n, merge,
+ nth_element, partial_sort, max_element, min_element): Likewise.
+ * testsuite/25_algorithms/headers/algorithm/
+ parallel_algorithm_mixed1.cc (main): Add respective test cases.
+ * testsuite/25_algorithms/headers/algorithm/
+ parallel_algorithm_mixed2.cc (main): Likewise.
+ * testsuite/26_numerics/headers/numeric/
+ parallel_numeric_mixed1.cc (main): Likewise.
+ * testsuite/26_numerics/headers/numeric/
+ parallel_numeric_mixed2.cc (main): Likewise.
2011-01-24 Graham Reed <greed@pobox.com>
2011-01-24 Johannes Singler <singler@kit.edu>
- PR libstdc++/47433
- * include/parallel/losertree.h
- (_LoserTree<>::__delete_min_insert):
- Do not qualify swap with std:: for value type,
- but include a using directive instead.
- (_LoserTreeUnguarded<>::__delete_min_insert): Likewise.
- * include/parallel/balanced_quicksort.h (__qsb_divide):
- Use std::iter_swap instead of std::swap.
- (__qsb_local_sort_with_helping): Likewise.
- * include/parallel/partition.h (__parallel_partition):
- Likewise. (__parallel_nth_element): Likewise.
+ PR libstdc++/47433
+ * include/parallel/losertree.h
+ (_LoserTree<>::__delete_min_insert):
+ Do not qualify swap with std:: for value type,
+ but include a using directive instead.
+ (_LoserTreeUnguarded<>::__delete_min_insert): Likewise.
+ * include/parallel/balanced_quicksort.h (__qsb_divide):
+ Use std::iter_swap instead of std::swap.
+ (__qsb_local_sort_with_helping): Likewise.
+ * include/parallel/partition.h (__parallel_partition):
+ Likewise. (__parallel_nth_element): Likewise.
2011-01-24 Johannes Singler <singler@kit.edu>
- PR libstdc++/47437
- * include/parallel/multiway_merge.h (_UnguardedIterator):
- Remove useless "mutable" from reference declaration.
+ PR libstdc++/47437
+ * include/parallel/multiway_merge.h (_UnguardedIterator):
+ Remove useless "mutable" from reference declaration.
2011-01-21 Benjamin Kosnik <bkoz@redhat.com>
_ZNSt2_69has_facetINS_*;
# hash
- _ZNSt2_68__detail12__prime_listE;
+ _ZNSt8__detail2_612__prime_listE;
+ _ZNSt3tr18__detail2_612__prime_listE;
# thread/mutex/condition_variable/future
__once_proxy;
_ZTv0_n*;
+ # std::__detail::_List_node_base
+ _ZNSt8__detail2_615_List_node_base7_M_hook*;
+ _ZNSt8__detail2_615_List_node_base9_M_unhookEv;
+ _ZNSt8__detail2_615_List_node_base10_M_reverseEv;
+ _ZNSt8__detail2_615_List_node_base11_M_transfer*;
+ _ZNSt8__detail2_615_List_node_base4swapER*;
+
# std::__convert_to_v
_ZNSt2_614__convert_to_v*;
_ZN9__gnu_cxx2_618stdio_sync_filebufI[cw]NSt2_611char_traitsI[cw]EEE[5-9]*;
# debug mode
-# xxx cxx1998?
- _ZN10__gnu_norm15_List_node_base4hook*;
- _ZN10__gnu_norm15_List_node_base4swap*;
- _ZN10__gnu_norm15_List_node_base6unhookEv;
- _ZN10__gnu_norm15_List_node_base7reverseEv;
- _ZN10__gnu_norm15_List_node_base8transfer*;
-
- _ZNSt6__norm15_List_node_base4hook*;
- _ZNSt6__norm15_List_node_base4swap*;
- _ZNSt6__norm15_List_node_base6unhookEv;
- _ZNSt6__norm15_List_node_base7reverseEv;
- _ZNSt6__norm15_List_node_base8transfer*;
-
_ZN11__gnu_debug19_Safe_sequence_base12_M_get_mutexEv;
_ZN11__gnu_debug19_Safe_sequence_base13_M_detach_allEv;
_ZN11__gnu_debug19_Safe_sequence_base18_M_detach_singularEv;
_ZNK11__gnu_debug16_Error_formatter8_M_error*;
_ZNK11__gnu_debug16_Error_formatter17_M_get_max_lengthEv;
+ # parallel mode
+ _ZN14__gnu_parallel9_Settings3getEv;
+ _ZN14__gnu_parallel9_Settings3setERS0_;
+
local:
*;
};
# std::placeholders
_ZNSt12placeholders*;
+ _ZNSt8__detail15_List_node_base7_M_hook*;
+ _ZNSt8__detail15_List_node_base9_M_unhookEv;
+ _ZNSt8__detail15_List_node_base10_M_reverseEv;
+ _ZNSt8__detail15_List_node_base11_M_transfer*;
+ _ZNSt8__detail15_List_node_base4swapERS0_S1_;
+
} GLIBCXX_3.4.14;
# Symbols in the support library (libsupc++) have their own tag.
#include <ext/atomicity.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_Atomic_word
__exchange_and_add(volatile _Atomic_word* __mem, int __val) throw ()
__atomic_add(volatile _Atomic_word* __mem, int __val) throw ()
{ __exchange_and_add(__mem, __val); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/c++config.h>
#include <bits/atomic_word.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_Atomic_word
__attribute__ ((__unused__))
__atomic_add(volatile _Atomic_word* __mem, int __val) throw ()
{ __sync_fetch_and_add(__mem, __val); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
}
} // anonymous namespace
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_Atomic_word
__attribute__ ((__unused__))
__atomic_add(volatile _Atomic_word* __mem, int __val) throw ()
{ __exchange_and_add(__mem, __val); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/c++config.h>
#include <ext/atomicity.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<int _Inst>
struct _Atomicity_lock
: : "r" (&lock), "r" (tmp) : "memory");
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <ext/atomicity.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<int __inst>
struct _Atomicity_lock
__atomic_add(volatile _Atomic_word* __mem, int __val) throw ()
{ __exchange_and_add(__mem, __val); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <ext/atomicity.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_Atomic_word
__attribute__ ((__unused__))
: "=m" (*__mem) : "ir" (__val), "m" (*__mem));
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
typedef int _Atomic_word;
-namespace __gnu_cxx
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
// Test the first byte of __g and ensure that no loads are hoisted across
// the test.
#include <ext/atomicity.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
#if ( defined(__mc68020__) || defined(__mc68030__) \
|| defined(__mc68040__) || defined(__mc68060__) ) \
__exchange_and_add(__mem, __val);
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <ext/atomicity.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef int _Atomic_word;
: "r0");
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#else /* !__SH4A__ */
__gnu_cxx::__mutex atomic_mutex;
} // anonymous namespace
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_Atomic_word
__attribute__ ((__unused__))
__atomic_add(volatile _Atomic_word* __mem, int __val) throw ()
{ __exchange_and_add(__mem, __val); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* !__SH4A__ */
#include <ext/atomicity.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
#ifdef __arch64__
_Atomic_word
}
#endif /* __arch32__ */
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
} // anonymous namespace
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Definitions for __basic_file<char>.
__basic_file<char>::__basic_file(__c_lock* /*__lock*/) throw()
return 0;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/c++io.h> // for __c_lock and __c_file
#include <ios>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Generic declaration.
template<typename _CharT>
showmanyc();
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <cstdio>
#include <bits/gthr.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef __gthread_mutex_t __c_lock;
// for basic_file.h
typedef FILE __c_file;
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <cstring>
#include <cstdio>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
// NB: The other ctype<char> specializations are in src/locale.cc and
// various /config/os/* files.
#include <ieeefp.h>
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<>
void
locale::facet::_S_lc_ctype_c_locale(__c_locale, const char*)
{ return __c_locale(); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
const char* const category_names[6 + _GLIBCXX_NUM_CATEGORIES] =
{
"LC_MESSAGES"
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
const char* const* const locale::_S_categories = __gnu_cxx::category_names;
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// XXX GLIBCXX_ABI Deprecated
#ifdef _GLIBCXX_LONG_DOUBLE_COMPAT
#define _GLIBCXX_NUM_CATEGORIES 0
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef int* __c_locale;
return __ret;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <climits> // For MB_LEN_MAX
#include <cstring>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Specializations.
#ifdef _GLIBCXX_USE_WCHAR_T
}
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <locale>
#include <cstring>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// These are basically extensions to char_traits, and perhaps should
// be put there instead of here.
{ return wcsxfrm(__to, __from, __n); }
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <cstring>
#include <cstdio>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// NB: The other ctype<char> specializations are in src/locale.cc and
// various /config/os/* files.
}
#endif // _GLIBCXX_USE_WCHAR_T
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <locale>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Specializations
template<>
{ return __dfault; }
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Written by Benjamin Kosnik <bkoz@redhat.com>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Non-virtual member functions.
template<typename _CharT>
}
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <locale>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Construct and return valid pattern consisting of some combination of:
// space none symbol sign value
{ delete _M_data; }
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <locale>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<>
void
{ delete _M_data; }
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <cstdlib>
#include <cstring>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<>
void
}
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Written by Benjamin Kosnik <bkoz@redhat.com>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT>
__timepunct<_CharT>::__timepunct(size_t __refs)
_S_destroy_c_locale(_M_c_locale_timepunct);
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <langinfo.h>
#include <bits/c++locale_internal.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<>
void
return __changed;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
const char* const category_names[6 + _GLIBCXX_NUM_CATEGORIES] =
{
"LC_IDENTIFICATION"
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
const char* const* const locale::_S_categories = __gnu_cxx::category_names;
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// XXX GLIBCXX_ABI Deprecated
#ifdef _GLIBCXX_LONG_DOUBLE_COMPAT
#define _GLIBCXX_NUM_CATEGORIES 6
#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2)
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
extern "C" __typeof(uselocale) __uselocale;
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef __locale_t __c_locale;
return __ret;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <climits> // For MB_LEN_MAX
#include <bits/c++locale_internal.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Specializations.
#ifdef _GLIBCXX_USE_WCHAR_T
}
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <locale>
#include <bits/c++locale_internal.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// These are basically extensions to char_traits, and perhaps should
// be put there instead of here.
{ return __wcsxfrm_l(__to, __from, __n, _M_c_locale_collate); }
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <cstdio>
#include <bits/c++locale_internal.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// NB: The other ctype<char> specializations are in src/locale.cc and
// various /config/os/* files.
}
#endif // _GLIBCXX_USE_WCHAR_T
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <locale>
#include <bits/c++locale_internal.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Specializations.
template<>
}
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <libintl.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Non-virtual member functions.
template<typename _CharT>
}
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <locale>
#include <bits/c++locale_internal.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Construct and return valid pattern consisting of some combination of:
// space none symbol sign value
}
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <locale>
#include <bits/c++locale_internal.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<>
void
}
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <locale>
#include <bits/c++locale_internal.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<>
void
}
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Written by Benjamin Kosnik <bkoz@redhat.com>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT>
__timepunct<_CharT>::__timepunct(size_t __refs)
_S_destroy_c_locale(_M_c_locale_timepunct);
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <locale>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
void
locale::facet::_S_create_c_locale(__c_locale&, const char*, __c_locale*)
#include <iconv.h> // For codecvt using iconv, iconv_t
#include <nl_types.h> // For messages
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef int* __c_locale;
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <locale>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
// Specializations
template<>
// Written by Benjamin Kosnik <bkoz@redhat.com>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Non-virtual member functions.
template<typename _CharT>
messages<_CharT>::do_close(catalog __c) const
{ catclose(reinterpret_cast<nl_catd>(__c)); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <sys/atomic_op.h>
}
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_Atomic_word
__attribute__ ((__unused__))
__atomic_add (volatile _Atomic_word* __mem, int __val) throw ()
{ (void) ::fetch_and_add(const_cast<atomic_p>(__mem), __val); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Information as gleaned from /usr/include/ctype.h
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
static const mask alnum = _ISALPHA | _ISDIGIT;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Support for Solaris 2.5.1
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
static const mask alnum = _U | _L | _N;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// 4.0 and all versions of the CVS managed file at:
// :pserver:anoncvs@anoncvs.freebsd.org:/home/ncvs/src/include/ctype.h
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
#endif
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
}
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// 4.0 and all versions of the CVS managed file at:
// :pserver:anoncvs@anoncvs.freebsd.org:/home/ncvs/src/include/ctype.h
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
#endif
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
}
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <sys/param.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
#endif
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ISO C++ 14882: 22.1 Locales
//
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
static const mask graph = __dj_ISALPHA | __dj_ISDIGIT | __dj_ISPUNCT; // Graphical
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/c++config.h>
#include <cerrno>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Most of the commented-out error codes are socket-related and could be
// replaced by Winsock WSA-prefixed equivalents.
// wrong_protocol_type = EPROTOTYPE
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
// Default information, may not be appropriate for specific host.
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
static const mask alnum = (1 << 2) | (1 << 3); // alpha|digit
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Constructing a synthetic "C" table should be seriously considered...
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/c++config.h>
#include <cerrno>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
enum class errc
{
wrong_protocol_type = EPROTOTYPE
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
// Information as gleaned from /usr/include/ctype.h
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
static const mask alnum = _ISalpha | _ISdigit;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Default information, may not be appropriate for specific host.
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
static const mask alnum = _ISALPHA | _ISDIGIT;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
We also force _GLIBCXX_USE_LONG_LONG here so that we don't have
to bastardize configure to deal with this sillyness. */
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_EXTERN_C
#ifndef __LP64__
#endif
_GLIBCXX_END_EXTERN_C
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#define _GLIBCXX_USE_LONG_LONG 1
#include <mutex.h>
#include <ext/atomicity.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_Atomic_word
__exchange_and_add(volatile _Atomic_word* __mem, int __val) throw ()
__atomic_add(volatile _Atomic_word* __mem, int __val) throw ()
{ __exchange_and_add(__mem, __val); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Information as gleaned from /usr/include/ctype.h on irix 6.5
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
static const mask alnum = _ISalpha | _ISdigit;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// masks here, based on the generic masks, and the corresponding
// classic_table in ctype_noninline.h.
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
static const mask alnum = (1 << 2) | (1 << 3); // alpha|digit
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <cerrno>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Most of the commented-out error codes are socket-related and could be
// replaced by Winsock WSA-prefixed equivalents.
// wrong_protocol_type = EPROTOTYPE
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
// Support for Solaris 2.5.1
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
static const mask alnum = _U | _L | _N;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Information as gleaned from /usr/include/ctype.h.
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
static const mask alnum = _DI | _LO | _UP | _XA;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// only works with solaris2.7 and solaris2.8. Thanks for not changing
// things, sun engineers!
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
static const mask alnum = _ISALPHA | _ISDIGIT;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Information as gleaned from /usr/include/ctype.h
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
static const mask alnum = _ISalpha | _ISdigit;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Information as gleaned from /usr/include/ctype.h
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
static const mask alnum = _ISalpha | _ISdigit;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Information extracted from target/h/ctype.h.
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// @brief Base class for ctype.
struct ctype_base
static const mask alnum = _C_UPPER | _C_LOWER | _C_NUMBER;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// ctype bits to be inlined go here. Non-inlinable (ie virtual do_*)
// functions go in ctype.cc
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
ctype<char>::
return __low;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
"_GLIBCXX_CONST= " \
"_GLIBCXX_NORETURN= " \
"_GLIBCXX_NOTHROW= " \
- "_GLIBCXX_STD_D= " \
- "_GLIBCXX_STD_P= " \
- "_GLIBCXX_STD_PR= " \
- _GLIBCXX_STD=std \
- "_GLIBCXX_TR1= " \
- "_GLIBCXX_BEGIN_NAMESPACE_TR1= " \
- "_GLIBCXX_END_NAMESPACE_TR1= " \
- "_GLIBCXX_BEGIN_NAMESPACE(name)=namespace name { " \
- "_GLIBCXX_BEGIN_NESTED_NAMESPACE(name, unused)=namespace name { " \
- _GLIBCXX_END_NAMESPACE=} \
- _GLIBCXX_END_NESTED_NAMESPACE=} \
+ "_GLIBCXX_STD_C= " \
+ "_GLIBCXX_STD_A= " \
+ "_GLIBCXX_VISIBILITY(V)= " \
+ "_GLIBCXX_BEGIN_NAMESPACE_VERSION= " \
+ "_GLIBCXX_BEGIN_NAMESPACE_ALGO= " \
+ "_GLIBCXX_BEGIN_NAMESPACE_CONTAINER= " \
+ "_GLIBCXX_BEGIN_NAMESPACE_LDBL= " \
+ "_GLIBCXX_END_NAMESPACE_VERSION= " \
+ "_GLIBCXX_END_NAMESPACE_ALGO= " \
+ "_GLIBCXX_END_NAMESPACE_CONTAINER= " \
+ "_GLIBCXX_END_NAMESPACE_LDBL= " \
"_GLIBCXX_TEMPLATE_ARGS=... " \
_GLIBCXX_DEPRECATED \
_GLIBCXX_CONSTEXPR=constexpr \
#include <bits/c++config.h>
#include <debug/debug.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* A wrapper class to provide auto_ptr with reference semantics.
typedef void element_type;
} _GLIBCXX_DEPRECATED_ATTR;
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _BACKWARD_AUTO_PTR_H */
#ifndef _BACKWARD_BINDERS_H
#define _BACKWARD_BINDERS_H 1
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// 20.3.6 binders
/** @defgroup binders Binder Classes
}
/** @} */
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _BACKWARD_BINDERS_H */
#include <bits/c++config.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::size_t;
{ return __x; }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <backward/hashtable.h>
#include <bits/concept_check.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::equal_to;
using std::allocator;
hash_multimap<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm2)
{ __hm1.swap(__hm2); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Specialization of insert_iterator so that it will work for hash_map
// and hash_multimap.
{ return *this; }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <backward/hashtable.h>
#include <bits/concept_check.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::equal_to;
using std::allocator;
hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2)
{ __hs1.swap(__hs2); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Specialization of insert_iterator so that it will work for hash_set
// and hash_multiset.
operator++(int) { return *this; }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/stl_function.h>
#include <backward/hash_fun.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::size_t;
using std::ptrdiff_t;
}
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <ostream>
#include <string>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Class strstreambuf, a streambuf class that manages an array of char.
// Note that this class is not a template.
strstreambuf _M_buf;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/stl_iterator_base_types.h>
#include <initializer_list>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/*
adjacent_find
_FIter
upper_bound(_FIter, _FIter, const _Tp&, _Compare);
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_P)
+_GLIBCXX_BEGIN_NAMESPACE_ALGO
template<typename _FIter>
_FIter
_OIter
unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_ALGO
+} // namespace std
#ifdef _GLIBCXX_PARALLEL
# include <parallel/algorithmfwd.h>
#include <type_traits> // For _GLIBCXX_HAS_NESTED_TYPE
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @defgroup allocators Allocators
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// 0 == __atomic0 == Never lock-free
namespace __atomic0
#undef _ATOMIC_CMPEXCHNG_
} // namespace __atomic0
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// 2 == __atomic2 == Always lock-free
// Assumed:
};
} // namespace __atomic2
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <stdbool.h>
#include <stdint.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @defgroup atomics Atomics
// @} group atomics
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/locale_facets.h>
#include <bits/streambuf_iterator.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Facet>
inline const _Facet&
_M_cache_locale(const locale& __loc);
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/basic_ios.tcc>
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits>
void
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <debug/debug.h>
#include <initializer_list>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @class basic_string basic_string.h <string>
wchar_t __delim);
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#if (defined(__GXX_EXPERIMENTAL_CXX0X__) && defined(_GLIBCXX_USE_C99) \
&& !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
#include <ext/string_conversions.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// 21.4 Numeric Conversions [string.conversions].
inline int
}
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* __GXX_EXPERIMENTAL_CXX0X__ && _GLIBCXX_USE_C99 ... */
#include <bits/functional_hash.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// DR 1182.
};
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* __GXX_EXPERIMENTAL_CXX0X__ */
#include <bits/cxxabi_forced.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits, typename _Alloc>
const typename basic_string<_CharT, _Traits, _Alloc>::size_type
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/c++config.h>
#include <bits/stl_iterator_base_types.h> // for traits and tags
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
#define _IsUnused __attribute__ ((__unused__))
typename _BackInsertionSequence::value_type __t;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#undef _IsUnused
#define __GLIBCXX__
// Macros for various attributes.
+// _GLIBCXX_PURE
+// _GLIBCXX_CONST
+// _GLIBCXX_NORETURN
+// _GLIBCXX_NOTHROW
+// _GLIBCXX_VISIBILITY
#ifndef _GLIBCXX_PURE
# define _GLIBCXX_PURE __attribute__ ((__pure__))
#endif
# endif
#endif
-// Macros for visibility.
-// _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY
-// _GLIBCXX_VISIBILITY_ATTR
+// Macros for visibility attributes.
+// _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY
+// _GLIBCXX_VISIBILITY
#define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY
#if _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY
-# define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__ ((__visibility__ (#V)))
+# define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V)))
#else
// If this is not supplied by the OS-specific or CPU-specific
// headers included below, it will be defined to an empty default.
-# define _GLIBCXX_VISIBILITY_ATTR(V) _GLIBCXX_PSEUDO_VISIBILITY(V)
+# define _GLIBCXX_VISIBILITY(V) _GLIBCXX_PSEUDO_VISIBILITY(V)
#endif
-// Macros for deprecated.
-// _GLIBCXX_DEPRECATED
-// _GLIBCXX_DEPRECATED_ATTR
+// Macros for deprecated attributes.
+// _GLIBCXX_DEPRECATED
+// _GLIBCXX_DEPRECATED_ATTR
#ifndef _GLIBCXX_DEPRECATED
# define _GLIBCXX_DEPRECATED 1
#endif
#if __cplusplus
-namespace std
-{
- typedef __SIZE_TYPE__ size_t;
- typedef __PTRDIFF_TYPE__ ptrdiff_t;
-
-#ifdef __GXX_EXPERIMENTAL_CXX0X__
- typedef decltype(nullptr) nullptr_t;
-#endif
-}
-
-// Macros for C compatibility. In particular, define extern "C"
-// linkage only when using C++.
-# define _GLIBCXX_BEGIN_EXTERN_C extern "C" {
-# define _GLIBCXX_END_EXTERN_C }
-
-
// Macro for constexpr, to support in mixed 03/0x mode.
#ifndef _GLIBCXX_CONSTEXPR
# ifdef __GXX_EXPERIMENTAL_CXX0X__
# endif
#endif
-// Macros for activating various inline namespaces.
-//
-// _GLIBCXX_NAMESPACE_DEBUG
-// _GLIBCXX_NAMESPACE_PARALLEL
-// _GLIBCXX_NAMESPACE_PROFILE
-// _GLIBCXX_NAMESPACE_VERSION
+// Macro for extern template, ie controling template linkage via use
+// of extern keyword on template declaration. As documented in the g++
+// manual, it inhibits all implicit instantiations and is used
+// throughout the library to avoid multiple weak definitions for
+// required types that are already explicitly instantiated in the
+// library binary. This substantially reduces the binary size of
+// resulting executables.
+// Special case: _GLIBCXX_EXTERN_TEMPLATE == -1 disallows extern
+// templates only in basic_string, thus activating its debug-mode
+// checks even at -O0.
+#ifndef _GLIBCXX_EXTERN_TEMPLATE
+# define _GLIBCXX_EXTERN_TEMPLATE 1
+#endif
-// Guide to libstdc++ namespaces.
/*
+ Outline of libstdc++ namespaces.
+
namespace std
{
namespace __debug { }
namespace __parallel { }
namespace __profile { }
- namespace __norm { } // __normative, __shadow, __replaced
namespace __cxx1998 { }
- namespace tr1 { }
+ namespace __detail { }
+
+ namespace rel_ops { }
+
+ namespace tr1
+ {
+ namespace placeholders { }
+ namespace regex_constants { }
+ namespace __detail { }
+ }
+
+ namespace decimal { }
+
+ namespace chrono { }
+ namespace placeholders { }
+ namespace regex_constants { }
+ namespace this_thread { }
}
-*/
-#ifdef _GLIBCXX_DEBUG
-# define _GLIBCXX_INLINE_DEBUG 1
-#endif
+ namespace abi { }
-#ifdef _GLIBCXX_PARALLEL
-# define _GLIBCXX_INLINE_PARALLEL 1
-#endif
+ namespace __gnu_cxx
+ {
+ namespace __detail { }
+ }
+
+ For full details see:
+ http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/namespaces.html
+*/
+namespace std
+{
+ typedef __SIZE_TYPE__ size_t;
+ typedef __PTRDIFF_TYPE__ ptrdiff_t;
-// Namespace association for profile.
-#ifdef _GLIBCXX_PROFILE
-# define _GLIBCXX_INLINE_PROFILE 1
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ typedef decltype(nullptr) nullptr_t;
#endif
+}
+
+// Defined if inline namespaces are used for versioning.
#define _GLIBCXX_INLINE_VERSION
-// Defined if inline namespaces modes are active.
-#if _GLIBCXX_INLINE_DEBUG \
- || _GLIBCXX_INLINE_PARALLEL \
- || _GLIBCXX_INLINE_PROFILE \
- || _GLIBCXX_INLINE_VERSION
-# define _GLIBCXX_USE_INLINE_NAMESPACES 1
-#endif
+// Inline namespace for symbol versioning.
+#if _GLIBCXX_INLINE_VERSION
+namespace std
+{
+ inline namespace _6 { }
-// Macros for namespace scope. Either namespace std:: or the name
-// of some nested namespace within it.
-// _GLIBCXX_STD
-// _GLIBCXX_STD_D
-// _GLIBCXX_STD_P
-// _GLIBCXX_STD_PR
-//
-// Macros for enclosing namespaces and possibly nested namespaces.
-// _GLIBCXX_BEGIN_NAMESPACE
-// _GLIBCXX_END_NAMESPACE
-// _GLIBCXX_BEGIN_NESTED_NAMESPACE
-// _GLIBCXX_END_NESTED_NAMESPACE
-#ifndef _GLIBCXX_USE_INLINE_NAMESPACES
-# define _GLIBCXX_STD_D _GLIBCXX_STD
-# define _GLIBCXX_STD_P _GLIBCXX_STD
-# define _GLIBCXX_STD_PR _GLIBCXX_STD
-# define _GLIBCXX_STD std
-# define _GLIBCXX_BEGIN_NESTED_NAMESPACE(X, Y) _GLIBCXX_BEGIN_NAMESPACE(X)
-# define _GLIBCXX_END_NESTED_NAMESPACE _GLIBCXX_END_NAMESPACE
-# define _GLIBCXX_BEGIN_NAMESPACE(X) namespace X _GLIBCXX_VISIBILITY_ATTR(default) {
-# define _GLIBCXX_END_NAMESPACE }
+ namespace __detail { inline namespace _6 { } }
+
+
+ namespace rel_ops { inline namespace _6 { } }
+
+ namespace tr1
+ {
+ inline namespace _6 { }
+ namespace placeholders { inline namespace _6 { } }
+ namespace regex_constants { inline namespace _6 { } }
+ namespace __detail { inline namespace _6 { } }
+ }
+
+ namespace decimal { inline namespace _6 { } }
+
+ namespace chrono { inline namespace _6 { } }
+ namespace placeholders { inline namespace _6 { } }
+ namespace regex_constants { inline namespace _6 { } }
+ namespace this_thread { inline namespace _6 { } }
+}
+
+namespace __gnu_cxx
+{
+ inline namespace _6 { }
+ namespace __detail { inline namespace _6 { } }
+}
+# define _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace _6 {
+# define _GLIBCXX_END_NAMESPACE_VERSION }
#else
+# define _GLIBCXX_BEGIN_NAMESPACE_VERSION
+# define _GLIBCXX_END_NAMESPACE_VERSION
+#endif
-# if _GLIBCXX_INLINE_VERSION // && not anything else
-# define _GLIBCXX_STD_D _GLIBCXX_STD
-# define _GLIBCXX_STD_P _GLIBCXX_STD
-# define _GLIBCXX_STD _6
-# define _GLIBCXX_BEGIN_NAMESPACE(X) _GLIBCXX_BEGIN_NESTED_NAMESPACE(X, _6)
-# define _GLIBCXX_END_NAMESPACE _GLIBCXX_END_NESTED_NAMESPACE
-# endif
-// debug
-# if _GLIBCXX_INLINE_DEBUG && !_GLIBCXX_INLINE_PARALLEL && !_GLIBCXX_INLINE_PROFILE
-# define _GLIBCXX_STD_D __norm
-# define _GLIBCXX_STD_P _GLIBCXX_STD
-# define _GLIBCXX_STD __cxx1998
-# define _GLIBCXX_BEGIN_NAMESPACE(X) namespace X _GLIBCXX_VISIBILITY_ATTR(default) {
-# define _GLIBCXX_END_NAMESPACE }
-# define _GLIBCXX_EXTERN_TEMPLATE -1
+// Inline namespaces for special modes: debug, parallel, profile.
+#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL) \
+ || defined(_GLIBCXX_PROFILE)
+namespace std
+{
+ // Non-inline namespace for components replaced by alternates in active mode.
+ namespace __cxx1998
+ {
+#if _GLIBCXX_INLINE_VERSION
+ inline namespace _6 { }
+#endif
+ }
+
+ // Inline namespace for debug mode.
+# ifdef _GLIBCXX_DEBUG
+ inline namespace __debug { }
# endif
-// parallel
-# if _GLIBCXX_INLINE_PARALLEL && !_GLIBCXX_INLINE_DEBUG && !_GLIBCXX_INLINE_PROFILE
-# define _GLIBCXX_STD_D _GLIBCXX_STD
-# define _GLIBCXX_STD_P __norm
-# define _GLIBCXX_STD __cxx1998
-# define _GLIBCXX_BEGIN_NAMESPACE(X) namespace X _GLIBCXX_VISIBILITY_ATTR(default) {
-# define _GLIBCXX_END_NAMESPACE }
+ // Inline namespaces for parallel mode.
+# ifdef _GLIBCXX_PARALLEL
+ inline namespace __parallel { }
# endif
-// debug + parallel
-# if _GLIBCXX_INLINE_PARALLEL && _GLIBCXX_INLINE_DEBUG && !_GLIBCXX_INLINE_PROFILE
-# define _GLIBCXX_STD_D __norm
-# define _GLIBCXX_STD_P __norm
-# define _GLIBCXX_STD __cxx1998
-# define _GLIBCXX_BEGIN_NAMESPACE(X) namespace X _GLIBCXX_VISIBILITY_ATTR(default) {
-# define _GLIBCXX_END_NAMESPACE }
-# define _GLIBCXX_EXTERN_TEMPLATE -1
+ // Inline namespaces for profile mode
+# ifdef _GLIBCXX_PROFILE
+ inline namespace __profile { }
# endif
+}
-// profile
-# if _GLIBCXX_INLINE_PROFILE
-# if _GLIBCXX_INLINE_PARALLEL || _GLIBCXX_INLINE_DEBUG
-# error Cannot use -D_GLIBCXX_PROFILE with -D_GLIBCXX_DEBUG or \
- -D_GLIBCXX_PARALLEL
-# endif
-# define _GLIBCXX_STD_D __norm
-# define _GLIBCXX_STD_P _GLIBCXX_STD
-# define _GLIBCXX_STD_PR __norm
-# define _GLIBCXX_STD __cxx1998
-# define _GLIBCXX_BEGIN_NAMESPACE(X) namespace X _GLIBCXX_VISIBILITY_ATTR(default) {
-# define _GLIBCXX_END_NAMESPACE }
+// Check for invalid usage and unsupported mixed-mode use.
+# if defined(_GLIBCXX_DEBUG) && defined(_GLIBCXX_PARALLEL)
+# error illegal use of multiple inlined namespaces
+# endif
+# if defined(_GLIBCXX_PROFILE) && defined(_GLIBCXX_DEBUG)
+# error illegal use of multiple inlined namespaces
+# endif
+# if defined(_GLIBCXX_PROFILE) && defined(_GLIBCXX_PARALLEL)
+# error illegal use of multiple inlined namespaces
# endif
+// Check for invalid use due to lack for weak symbols.
# if __NO_INLINE__ && !__GXX_WEAK__
# warning currently using inlined namespace mode which may fail \
without inlining due to lack of weak symbols
# endif
+#endif
+
+// Macros for namespace scope. Either namespace std:: or the name
+// of some nested namespace within it corresponding to the active mode.
+// _GLIBCXX_STD_A
+// _GLIBCXX_STD_C
+//
+// Macros for opening/closing conditional namespaces.
+// _GLIBCXX_BEGIN_NAMESPACE_ALGO
+// _GLIBCXX_END_NAMESPACE_ALGO
+// _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+// _GLIBCXX_END_NAMESPACE_CONTAINER
+#if defined(_GLIBCXX_DEBUG) or defined(_GLIBCXX_PROFILE)
+# define _GLIBCXX_STD_C __cxx1998
+# define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER \
+ namespace _GLIBCXX_STD_C { _GLIBCXX_BEGIN_NAMESPACE_VERSION
+# define _GLIBCXX_END_NAMESPACE_CONTAINER \
+ } _GLIBCXX_END_NAMESPACE_VERSION
+# undef _GLIBCXX_EXTERN_TEMPLATE
+# define _GLIBCXX_EXTERN_TEMPLATE -1
+#endif
-# define _GLIBCXX_BEGIN_NESTED_NAMESPACE(X, Y) namespace X { namespace Y _GLIBCXX_VISIBILITY_ATTR(default) {
-# define _GLIBCXX_END_NESTED_NAMESPACE } }
+#ifdef _GLIBCXX_PARALLEL
+# define _GLIBCXX_STD_A __cxx1998
+# define _GLIBCXX_BEGIN_NAMESPACE_ALGO \
+ namespace _GLIBCXX_STD_A { _GLIBCXX_BEGIN_NAMESPACE_VERSION
+# define _GLIBCXX_END_NAMESPACE_ALGO \
+ } _GLIBCXX_END_NAMESPACE_VERSION
#endif
-// Inline namespaces for debug mode.
-#if _GLIBCXX_INLINE_DEBUG && !_GLIBCXX_INLINE_PROFILE
-namespace std
-{
- namespace __norm { }
- inline namespace __debug { }
- inline namespace __cxx1998 { }
-}
+#ifndef _GLIBCXX_STD_A
+# define _GLIBCXX_STD_A std
#endif
-// Inline namespaces for parallel mode.
-#if _GLIBCXX_INLINE_PARALLEL
-namespace std
-{
- namespace __norm { }
- inline namespace __parallel { }
- inline namespace __cxx1998 { }
-}
+#ifndef _GLIBCXX_STD_C
+# define _GLIBCXX_STD_C std
#endif
-// Inline namespaces for profile mode
-#if _GLIBCXX_INLINE_PROFILE
-namespace std
-{
- namespace __norm { }
- inline namespace __profile { }
- inline namespace __cxx1998 { }
-}
+#ifndef _GLIBCXX_BEGIN_NAMESPACE_ALGO
+# define _GLIBCXX_BEGIN_NAMESPACE_ALGO
#endif
-// Inline namespaces for versioning mode.
-#if _GLIBCXX_INLINE_VERSION
-namespace std
-{
- inline namespace _6 { }
-}
+#ifndef _GLIBCXX_END_NAMESPACE_ALGO
+# define _GLIBCXX_END_NAMESPACE_ALGO
+#endif
-namespace __gnu_cxx
-{
- inline namespace _6 { }
-}
+#ifndef _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+# define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+#endif
-namespace std
-{
- namespace tr1
- {
- inline namespace _6 { }
- }
-}
+#ifndef _GLIBCXX_END_NAMESPACE_CONTAINER
+# define _GLIBCXX_END_NAMESPACE_CONTAINER
#endif
-// XXX GLIBCXX_ABI Deprecated
-// Define if compatibility should be provided for -mlong-double-64
+// GLIBCXX_ABI Deprecated
+// Define if compatibility should be provided for -mlong-double-64.
#undef _GLIBCXX_LONG_DOUBLE_COMPAT
-// Inline namespaces for long double 128 mode.
+// Inline namespace for long double 128 mode.
#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__
namespace std
{
inline namespace __gnu_cxx_ldbl128 { }
}
-# define _GLIBCXX_LDBL_NAMESPACE __gnu_cxx_ldbl128::
-# define _GLIBCXX_BEGIN_LDBL_NAMESPACE namespace __gnu_cxx_ldbl128 {
-# define _GLIBCXX_END_LDBL_NAMESPACE }
+# define _GLIBCXX_NAMESPACE_LDBL __gnu_cxx_ldbl128::
+# define _GLIBCXX_BEGIN_NAMESPACE_LDBL namespace __gnu_cxx_ldbl128 {
+# define _GLIBCXX_END_NAMESPACE_LDBL }
#else
-# define _GLIBCXX_LDBL_NAMESPACE
-# define _GLIBCXX_BEGIN_LDBL_NAMESPACE
-# define _GLIBCXX_END_LDBL_NAMESPACE
+# define _GLIBCXX_NAMESPACE_LDBL
+# define _GLIBCXX_BEGIN_NAMESPACE_LDBL
+# define _GLIBCXX_END_NAMESPACE_LDBL
+#endif
+
+// Assert.
+#if !defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_PARALLEL)
+# define __glibcxx_assert(_Condition)
+#else
+namespace std
+{
+ // Avoid the use of assert, because we're trying to keep the <cassert>
+ // include out of the mix.
+ inline void
+ __replacement_assert(const char* __file, int __line,
+ const char* __function, const char* __condition)
+ {
+ __builtin_printf("%s:%d: %s: Assertion '%s' failed.\n", __file, __line,
+ __function, __condition);
+ __builtin_abort();
+ }
+}
+#define __glibcxx_assert(_Condition) \
+ do \
+ { \
+ if (! (_Condition)) \
+ std::__replacement_assert(__FILE__, __LINE__, __PRETTY_FUNCTION__, \
+ #_Condition); \
+ } while (false)
#endif
// Macros for race detectors.
// The annotations in this example tell the race detector that all memory
// accesses occurred when the refcount was positive do not race with
// memory accesses which occurred after the refcount became zero.
-
#ifndef _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE
# define _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A)
#endif
# define _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A)
#endif
+// Macros for C linkage: define extern "C" linkage only when using C++.
+# define _GLIBCXX_BEGIN_EXTERN_C extern "C" {
+# define _GLIBCXX_END_EXTERN_C }
+
#else // !__cplusplus
# define _GLIBCXX_BEGIN_EXTERN_C
# define _GLIBCXX_END_EXTERN_C
-# undef _GLIBCXX_BEGIN_NAMESPACE
-# undef _GLIBCXX_END_NAMESPACE
-# define _GLIBCXX_BEGIN_NAMESPACE(X)
-# define _GLIBCXX_END_NAMESPACE
#endif
+
// First includes.
// Pick up any OS-specific definitions.
// If platform uses neither visibility nor psuedo-visibility,
// specify empty default for namespace annotation macros.
#ifndef _GLIBCXX_PSEUDO_VISIBILITY
-#define _GLIBCXX_PSEUDO_VISIBILITY(V)
-#endif
-
-// Allow use of the GNU syntax extension, "extern template." This
-// extension is fully documented in the g++ manual, but in a nutshell,
-// it inhibits all implicit instantiations and is used throughout the
-// library to avoid multiple weak definitions for required types that
-// are already explicitly instantiated in the library binary. This
-// substantially reduces the binary size of resulting executables.
-
-// Special case: _GLIBCXX_EXTERN_TEMPLATE == -1 disallows extern
-// templates only in basic_string, thus activating its debug-mode
-// checks even at -O0.
-#ifndef _GLIBCXX_EXTERN_TEMPLATE
-# define _GLIBCXX_EXTERN_TEMPLATE 1
+# define _GLIBCXX_PSEUDO_VISIBILITY(V)
#endif
// Certain function definitions that are meant to be overridable from
# define _GLIBCXX_WEAK_DEFINITION
#endif
-// Assert.
-// Avoid the use of assert, because we're trying to keep the <cassert>
-// include out of the mix.
-#if !defined(_GLIBCXX_DEBUG) && !defined(_GLIBCXX_PARALLEL)
-#define __glibcxx_assert(_Condition)
-#else
-_GLIBCXX_BEGIN_NAMESPACE(std)
- // Avoid the use of assert, because we're trying to keep the <cassert>
- // include out of the mix.
- inline void
- __replacement_assert(const char* __file, int __line,
- const char* __function, const char* __condition)
- {
- __builtin_printf("%s:%d: %s: Assertion '%s' failed.\n", __file, __line,
- __function, __condition);
- __builtin_abort();
- }
-_GLIBCXX_END_NAMESPACE
-
-#define __glibcxx_assert(_Condition) \
- do \
- { \
- if (! (_Condition)) \
- std::__replacement_assert(__FILE__, __LINE__, \
- __PRETTY_FUNCTION__, #_Condition); \
- } while (false)
-#endif
// The remainder of the prewritten config is automatic; all the
// user hooks are listed above.
#undef min
#undef max
-// End of prewritten config; the discovered settings follow.
+// End of prewritten config; the settings discovered at configure time follow.
#include <bits/postypes.h> // For streampos
#include <cwchar> // For WEOF, wmemmove, wmemset, etc.
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Mapping from character type to associated types.
return __s;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// 21.1
/**
};
#endif //_GLIBCXX_USE_WCHAR_T
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#if (defined(__GXX_EXPERIMENTAL_CXX0X__) \
&& defined(_GLIBCXX_USE_C99_STDINT_TR1))
#include <cstdint>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<>
struct char_traits<char16_t>
{ return eq_int_type(__c, eof()) ? 0 : __c; }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Empty base class for codecvt facet [22.2.1.5].
class codecvt_base
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // _CODECVT_H
//
// Forward declaration hack, should really include this from somewhere.
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Iterator, typename _Container>
class __normal_iterator;
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
struct __true_type { };
struct __false_type { };
};
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif //_CPP_TYPE_TRAITS_H
// Deque implementation (out of line) -*- C++ -*-
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
-// 2009, 2010
+// 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
#ifndef _DEQUE_TCC
#define _DEQUE_TCC 1
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
#ifdef __GXX_EXPERIMENTAL_CXX0X__
template <typename _Tp, typename _Alloc>
}
#endif
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#endif
// <forward_list.h> -*- C++ -*-
-// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <memory>
#include <initializer_list>
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/**
* @brief A helper basic node class for %forward_list.
forward_list<_Tp, _Alloc>& __ly)
{ __lx.swap(__ly); }
-_GLIBCXX_END_NESTED_NAMESPACE // namespace std
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#endif // _FORWARD_LIST_H
// <forward_list.tcc> -*- C++ -*-
-// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#ifndef _FORWARD_LIST_TCC
#define _FORWARD_LIST_TCC 1
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Tp, typename _Alloc>
_Fwd_list_base<_Tp, _Alloc>::
}
}
-_GLIBCXX_END_NESTED_NAMESPACE // namespace std
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#endif /* _FORWARD_LIST_TCC */
#include <bits/cxxabi_forced.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits>
void
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/c++config.h>
#include <bits/exception_defines.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Helper for exception objects in <except>
void
void
__throw_bad_function_call() __attribute__((__noreturn__));
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/hash_bytes.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/** @defgroup hashes Hashes
* @ingroup functors
// @} group hashes
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // _FUNCTIONAL_HASH_H
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup numeric_arrays
// @} group numeric_arrays
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _GSLICE_H */
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup numeric_arrays
// @} group numeric_arrays
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _GSLICE_ARRAY_H */
#include <bits/hashtable_policy.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Class template _Hashtable, class definition.
}
}
-_GLIBCXX_END_NAMESPACE // namespace std
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
#endif // _HASHTABLE_H
#ifndef _HASHTABLE_POLICY_H
#define _HASHTABLE_POLICY_H 1
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std _GLIBCXX_VISIBILITY(default)
+{
namespace __detail
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
// Helper function: return distance(first, last) for forward
// iterators, or 0 for input iterators.
template<class _Iterator>
}
return true;
}
-} // namespace __detail
-_GLIBCXX_END_NAMESPACE // namespace std
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __detail
+} // namespace std
#endif // _HASHTABLE_POLICY_H
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup numeric_arrays
// @} group numeric_arrays
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _INDIRECT_ARRAY_H */
#include <bits/localefwd.h>
#include <bits/locale_classes.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// The following definitions of bitmask types are enums, not ints,
// as permitted (but not required) in the standard, in order to provide
return __base;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _IOS_BASE_H */
#include <bits/cxxabi_forced.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>::sentry::
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
// List implementation (out of line) -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-// Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#ifndef _LIST_TCC
#define _LIST_TCC 1
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Tp, typename _Alloc>
void
}
}
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#endif /* _LIST_TCC */
#include <string>
#include <ext/atomicity.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// 22.1.1 Class locale
/**
~collate_byname() { }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
# include <bits/locale_classes.tcc>
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Facet>
locale::
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <ext/numeric_traits.h>
#include <bits/streambuf_iterator.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// NB: Don't instantiate required wchar_t facets if no wchar_t support.
#ifdef _GLIBCXX_USE_WCHAR_T
};
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Include host and configuration specific ctype inlines.
#include <bits/ctype_inline.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// 22.2.2 The numeric category.
class __num_base
~numpunct_byname() { }
};
-_GLIBCXX_BEGIN_LDBL_NAMESPACE
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
/**
* @brief Primary class template num_get.
template <typename _CharT, typename _OutIter>
locale::id num_put<_CharT, _OutIter>::id;
-_GLIBCXX_END_LDBL_NAMESPACE
+_GLIBCXX_END_NAMESPACE_LDBL
// Subclause convenience interfaces, inlines.
// NB: These are inline because, when used in a loop, some compilers
tolower(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
# include <bits/locale_facets.tcc>
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Routine to access a cache for the facet. If the cache didn't
// exist before, it gets constructed on the fly.
__verify_grouping(const char* __grouping, size_t __grouping_size,
const string& __grouping_tmp) throw ();
-_GLIBCXX_BEGIN_LDBL_NAMESPACE
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
template<typename _CharT, typename _InIter>
_InIter
__len = static_cast<int>(__w);
}
-_GLIBCXX_END_LDBL_NAMESPACE
+_GLIBCXX_END_NAMESPACE_LDBL
template<typename _CharT, typename _ValueT>
int
return __bufend - __buf;
}
-_GLIBCXX_BEGIN_LDBL_NAMESPACE
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
template<typename _CharT, typename _OutIter>
void
return __s;
}
-_GLIBCXX_END_LDBL_NAMESPACE
+_GLIBCXX_END_NAMESPACE_LDBL
// Construct correctly padded string, as per 22.2.2.2.2
// Assumes
#if _GLIBCXX_EXTERN_TEMPLATE
extern template class numpunct<char>;
extern template class numpunct_byname<char>;
- extern template class _GLIBCXX_LDBL_NAMESPACE num_get<char>;
- extern template class _GLIBCXX_LDBL_NAMESPACE num_put<char>;
+ extern template class _GLIBCXX_NAMESPACE_LDBL num_get<char>;
+ extern template class _GLIBCXX_NAMESPACE_LDBL num_put<char>;
extern template class ctype_byname<char>;
extern template
#ifdef _GLIBCXX_USE_WCHAR_T
extern template class numpunct<wchar_t>;
extern template class numpunct_byname<wchar_t>;
- extern template class _GLIBCXX_LDBL_NAMESPACE num_get<wchar_t>;
- extern template class _GLIBCXX_LDBL_NAMESPACE num_put<wchar_t>;
+ extern template class _GLIBCXX_NAMESPACE_LDBL num_get<wchar_t>;
+ extern template class _GLIBCXX_NAMESPACE_LDBL num_put<wchar_t>;
extern template class ctype_byname<wchar_t>;
extern template
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <ctime> // For struct tm
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Time format ordering data.
const tm*) const throw ();
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Include host and configuration specific timepunct functions.
#include <bits/time_members.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Primary class template time_get.
template<typename _CharT, bool _Intl>
const bool moneypunct_byname<_CharT, _Intl>::intl;
-_GLIBCXX_BEGIN_LDBL_NAMESPACE
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
/**
* @brief Primary class template money_get.
template<typename _CharT, typename _OutIter>
locale::id money_put<_CharT, _OutIter>::id;
-_GLIBCXX_END_LDBL_NAMESPACE
+_GLIBCXX_END_NAMESPACE_LDBL
/**
* @brief Messages facet base class providing catalog typedef.
{ }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Include host and configuration specific messages functions.
#include <bits/messages_members.h>
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, bool _Intl>
struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
}
}
-_GLIBCXX_BEGIN_LDBL_NAMESPACE
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
template<typename _CharT, typename _InIter>
template<bool _Intl>
{ return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
: _M_insert<false>(__s, __io, __fill, __digits); }
-_GLIBCXX_END_LDBL_NAMESPACE
+_GLIBCXX_END_NAMESPACE_LDBL
// NB: Not especially useful. Without an ios_base object or some
// kind of locale reference, we are left clawing at the air where
extern template class moneypunct<char, true>;
extern template class moneypunct_byname<char, false>;
extern template class moneypunct_byname<char, true>;
- extern template class _GLIBCXX_LDBL_NAMESPACE money_get<char>;
- extern template class _GLIBCXX_LDBL_NAMESPACE money_put<char>;
+ extern template class _GLIBCXX_NAMESPACE_LDBL money_get<char>;
+ extern template class _GLIBCXX_NAMESPACE_LDBL money_put<char>;
extern template class __timepunct<char>;
extern template class time_put<char>;
extern template class time_put_byname<char>;
extern template class moneypunct<wchar_t, true>;
extern template class moneypunct_byname<wchar_t, false>;
extern template class moneypunct_byname<wchar_t, true>;
- extern template class _GLIBCXX_LDBL_NAMESPACE money_get<wchar_t>;
- extern template class _GLIBCXX_LDBL_NAMESPACE money_put<wchar_t>;
+ extern template class _GLIBCXX_NAMESPACE_LDBL money_get<wchar_t>;
+ extern template class _GLIBCXX_NAMESPACE_LDBL money_put<wchar_t>;
extern template class __timepunct<wchar_t>;
extern template class time_put<wchar_t>;
extern template class time_put_byname<wchar_t>;
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <iosfwd> // For ostreambuf_iterator, istreambuf_iterator
#include <cctype>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @defgroup locales Locales
class codecvt_byname;
// 22.2.2 and 22.2.3 numeric
-_GLIBCXX_BEGIN_LDBL_NAMESPACE
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class num_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class num_put;
-_GLIBCXX_END_LDBL_NAMESPACE
+_GLIBCXX_END_NAMESPACE_LDBL
template<typename _CharT> class numpunct;
template<typename _CharT> class numpunct_byname;
// 22.2.6 money
class money_base;
-_GLIBCXX_BEGIN_LDBL_NAMESPACE
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class money_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class money_put;
-_GLIBCXX_END_LDBL_NAMESPACE
+_GLIBCXX_END_NAMESPACE_LDBL
template<typename _CharT, bool _Intl = false>
class moneypunct;
template<typename _CharT, bool _Intl = false>
template<typename _CharT>
class messages_byname;
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup numeric_arrays
// @} group numeric_arrays
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _MASK_ARRAY_H */
#include <bits/c++config.h>
#include <bits/concept_check.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Used, in C++03 mode too, by allocators, etc.
template<typename _Tp>
(&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <type_traits> // Brings in std::declval too.
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// forward (as per N3143)
template<typename _Tp>
addressof(_Tp& __r)
{ return std::__addressof(__r); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#define _GLIBCXX_MOVE(__val) std::move(__val)
#define _GLIBCXX_FORWARD(_Tp, __val) std::forward<_Tp>(__val)
#define _GLIBCXX_FORWARD(_Tp, __val) (__val)
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Swaps two values.
swap(__a[__n], __b[__n]);
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _MOVE_H */
#include <bits/cxxabi_forced.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>::sentry::
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <iosfwd>
#include <bits/cxxabi_forced.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits>
inline void
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _OSTREAM_INSERT_H */
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// The types streamoff, streampos and wstreampos and the class
// template fpos<> are described in clauses 21.1.2, 21.1.3, 27.1.2,
typedef fpos<mbstate_t> u32streampos;
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <vector>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// [26.4] Random number generation
_RealType
generate_canonical(_UniformRandomNumberGenerator& __g);
+_GLIBCXX_END_NAMESPACE_VERSION
+
/*
* Implementation-space details.
*/
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
template<typename _UIntType, size_t __w,
bool = __w < static_cast<size_t>
(std::numeric_limits<_UIntType>::digits)>
private:
_Engine& _M_g;
};
+
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* @addtogroup random_generators Random Number Generators
* @ingroup random
/* @} */ // group random_utilities
/* @} */ // group random
-_GLIBCXX_END_NAMESPACE
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
#endif
// random number generation (out of line) -*- C++ -*-
-// Copyright (C) 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <numeric> // std::accumulate and std::partial_sum
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std _GLIBCXX_VISIBILITY(default)
+{
/*
* (Further) implementation-space details.
*/
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
// General case for x = (ax + c) mod m -- use Schrage's algorithm to
// avoid integer overflow.
//
*__result = __unary_op(*__first);
return __result;
}
+
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
constexpr _UIntType
}
return __sum / __tmp;
}
-_GLIBCXX_END_NAMESPACE
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Return an iterator pointing to the first element of
end(_Tp (&__arr)[_Nm])
{ return __arr + _Nm; }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // __GXX_EXPERIMENTAL_CXX0X__
* Do not attempt to use it directly. @headername{regex}
*/
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @defgroup regex Regular Expressions
#endif
//@} // group regex
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
* Do not attempt to use it directly. @headername{regex}
*/
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace __regex
{
} // namespace __regex
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
/* vim: set ts=8 sw=2 sts=2: */
// class template regex -*- C++ -*-
-// Copyright (C) 2010 Free Software Foundation, Inc.
+// Copyright (C) 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* Do not attempt to use it directly. @headername{regex}
*/
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std _GLIBCXX_VISIBILITY(default)
+{
/**
* @namespace std::regex_constants
* @brief ISO C++-0x entities sub namespace for regex.
*/
namespace regex_constants
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* @name 5.1 Regular Expression Syntax Options
*/
//@}
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace regex_constants
-
-_GLIBCXX_END_NAMESPACE
+} // namespace
* Do not attempt to use it directly. @headername{regex}
*/
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace __regex
{
} // namespace __regex
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// class template regex -*- C++ -*-
-// Copyright (C) 2010 Free Software Foundation, Inc.
+// Copyright (C) 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* Do not attempt to use it directly. @headername{regex}
*/
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std _GLIBCXX_VISIBILITY(default)
+{
namespace regex_constants
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* @name 5.3 Error Types
*/
static const error_type error_stack(_S_error_stack);
//@}
-}
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace regex_constants
+
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// [7.8] Class regex_error
/**
__throw_regex_error(regex_constants::error_type __ecode)
{ throw regex_error(__ecode); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
* Do not attempt to use it directly. @headername{regex}
*/
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _BiIter>
class sub_match;
} // namespace __regex
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/regex_grep_matcher.tcc>
#include <regex>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace
{
} // namespace __regex
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
* Do not attempt to use it directly. @headername{regex}
*/
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace __regex
{
} // namespace __regex
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/regex_nfa.tcc>
*/
#include <regex>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace __regex
{
} // namespace __regex
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/shared_ptr_base.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup pointer_abstractions
// @} group pointer_abstractions
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // _SHARED_PTR_H
#ifndef _SHARED_PTR_BASE_H
#define _SHARED_PTR_BASE_H 1
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Exception possibly thrown by @c shared_ptr.
{ return std::hash<_Tp*>()(__s.get()); }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // _SHARED_PTR_BASE_H
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup numeric_arrays
// @} group numeric_arrays
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _SLICE_ARRAY_H */
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template <class _CharT, class _Traits, class _Alloc>
typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
// See concept_check.h for the __glibcxx_*_requires macros.
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Swaps the median value of *__a, *__b and *__c to *__a
template<typename _Iterator>
_Integer __count, const _Tp& __val,
std::forward_iterator_tag)
{
- __first = _GLIBCXX_STD_P::find(__first, __last, __val);
+ __first = _GLIBCXX_STD_A::find(__first, __last, __val);
while (__first != __last)
{
typename iterator_traits<_ForwardIterator>::difference_type
return __first;
if (__i == __last)
return __last;
- __first = _GLIBCXX_STD_P::find(++__i, __last, __val);
+ __first = _GLIBCXX_STD_A::find(++__i, __last, __val);
}
return __last;
}
while (1)
{
_ForwardIterator1 __new_result
- = _GLIBCXX_STD_P::search(__first1, __last1, __first2, __last2);
+ = _GLIBCXX_STD_A::search(__first1, __last1, __first2, __last2);
if (__new_result == __last1)
return __result;
else
while (1)
{
_ForwardIterator1 __new_result
- = _GLIBCXX_STD_P::search(__first1, __last1, __first2,
+ = _GLIBCXX_STD_A::search(__first1, __last1, __first2,
__last2, __comp);
if (__new_result == __last1)
return __result;
_RevIterator1 __rlast1(__first1);
_RevIterator2 __rlast2(__first2);
- _RevIterator1 __rresult = _GLIBCXX_STD_P::search(_RevIterator1(__last1),
+ _RevIterator1 __rresult = _GLIBCXX_STD_A::search(_RevIterator1(__last1),
__rlast1,
_RevIterator2(__last2),
__rlast2);
template<typename _InputIterator, typename _Predicate>
inline bool
none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
- { return __last == _GLIBCXX_STD_P::find_if(__first, __last, __pred); }
+ { return __last == _GLIBCXX_STD_A::find_if(__first, __last, __pred); }
/**
* @brief Checks that a predicate is false for at least an element
typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
__glibcxx_requires_valid_range(__first, __last);
- __first = _GLIBCXX_STD_P::find(__first, __last, __value);
+ __first = _GLIBCXX_STD_A::find(__first, __last, __value);
if(__first == __last)
return __first;
_ForwardIterator __result = __first;
typename iterator_traits<_ForwardIterator>::value_type>)
__glibcxx_requires_valid_range(__first, __last);
- __first = _GLIBCXX_STD_P::find_if(__first, __last, __pred);
+ __first = _GLIBCXX_STD_A::find_if(__first, __last, __pred);
if(__first == __last)
return __first;
_ForwardIterator __result = __first;
__glibcxx_requires_valid_range(__first, __last);
// Skip the beginning, if already unique.
- __first = _GLIBCXX_STD_P::adjacent_find(__first, __last);
+ __first = _GLIBCXX_STD_A::adjacent_find(__first, __last);
if (__first == __last)
return __last;
__glibcxx_requires_valid_range(__first, __last);
// Skip the beginning, if already unique.
- __first = _GLIBCXX_STD_P::adjacent_find(__first, __last, __binary_pred);
+ __first = _GLIBCXX_STD_A::adjacent_find(__first, __last, __binary_pred);
if (__first == __last)
return __last;
{
if (__depth_limit == 0)
{
- _GLIBCXX_STD_P::partial_sort(__first, __last, __last);
+ _GLIBCXX_STD_A::partial_sort(__first, __last, __last);
return;
}
--__depth_limit;
{
if (__depth_limit == 0)
{
- _GLIBCXX_STD_P::partial_sort(__first, __last, __last, __comp);
+ _GLIBCXX_STD_A::partial_sort(__first, __last, __last, __comp);
return;
}
--__depth_limit;
if (__len1 <= __len2 && __len1 <= __buffer_size)
{
_Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
- _GLIBCXX_STD_P::merge(_GLIBCXX_MAKE_MOVE_ITERATOR(__buffer),
+ _GLIBCXX_STD_A::merge(_GLIBCXX_MAKE_MOVE_ITERATOR(__buffer),
_GLIBCXX_MAKE_MOVE_ITERATOR(__buffer_end),
_GLIBCXX_MAKE_MOVE_ITERATOR(__middle),
_GLIBCXX_MAKE_MOVE_ITERATOR(__last),
if (__len1 <= __len2 && __len1 <= __buffer_size)
{
_Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
- _GLIBCXX_STD_P::merge(_GLIBCXX_MAKE_MOVE_ITERATOR(__buffer),
+ _GLIBCXX_STD_A::merge(_GLIBCXX_MAKE_MOVE_ITERATOR(__buffer),
_GLIBCXX_MAKE_MOVE_ITERATOR(__buffer_end),
_GLIBCXX_MAKE_MOVE_ITERATOR(__middle),
_GLIBCXX_MAKE_MOVE_ITERATOR(__last),
while (__last - __first >= __two_step)
{
- __result = _GLIBCXX_STD_P::merge(
+ __result = _GLIBCXX_STD_A::merge(
_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
_GLIBCXX_MAKE_MOVE_ITERATOR(__first + __step_size),
_GLIBCXX_MAKE_MOVE_ITERATOR(__first + __step_size),
}
__step_size = std::min(_Distance(__last - __first), __step_size);
- _GLIBCXX_STD_P::merge(_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
+ _GLIBCXX_STD_A::merge(_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
_GLIBCXX_MAKE_MOVE_ITERATOR(__first +
__step_size),
_GLIBCXX_MAKE_MOVE_ITERATOR(__first +
while (__last - __first >= __two_step)
{
- __result = _GLIBCXX_STD_P::merge(
+ __result = _GLIBCXX_STD_A::merge(
_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
_GLIBCXX_MAKE_MOVE_ITERATOR(__first + __step_size),
_GLIBCXX_MAKE_MOVE_ITERATOR(__first + __step_size),
}
__step_size = std::min(_Distance(__last - __first), __step_size);
- _GLIBCXX_STD_P::merge(_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
+ _GLIBCXX_STD_A::merge(_GLIBCXX_MAKE_MOVE_ITERATOR(__first),
_GLIBCXX_MAKE_MOVE_ITERATOR(__first +
__step_size),
_GLIBCXX_MAKE_MOVE_ITERATOR(__first +
std::advance(__last2, std::distance(__first1, __last1));
for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
{
- if (__scan != _GLIBCXX_STD_P::find(__first1, __scan, *__scan))
+ if (__scan != _GLIBCXX_STD_A::find(__first1, __scan, *__scan))
continue; // We've seen this one before.
auto __matches = std::count(__first2, __last2, *__scan);
{
using std::placeholders::_1;
- if (__scan != _GLIBCXX_STD_P::find_if(__first1, __scan,
+ if (__scan != _GLIBCXX_STD_A::find_if(__first1, __scan,
std::bind(__pred, _1, *__scan)))
continue; // We've seen this one before.
#endif // __GXX_EXPERIMENTAL_CXX0X__
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_P)
+_GLIBCXX_BEGIN_NAMESPACE_ALGO
/**
* @brief Apply a function to every element of a sequence.
// Test for a pattern of length 1.
_ForwardIterator2 __p1(__first2);
if (++__p1 == __last2)
- return _GLIBCXX_STD_P::find(__first1, __last1, *__first2);
+ return _GLIBCXX_STD_A::find(__first1, __last1, *__first2);
// General case.
_ForwardIterator2 __p;
for (;;)
{
- __first1 = _GLIBCXX_STD_P::find(__first1, __last1, *__first2);
+ __first1 = _GLIBCXX_STD_A::find(__first1, __last1, *__first2);
if (__first1 == __last1)
return __last1;
if (__count <= 0)
return __first;
if (__count == 1)
- return _GLIBCXX_STD_P::find(__first, __last, __val);
+ return _GLIBCXX_STD_A::find(__first, __last, __val);
return std::__search_n(__first, __last, __count, __val,
std::__iterator_category(__first));
}
return __result;
}
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_ALGO
+} // namespace std
#endif /* _STL_ALGO_H */
// Core algorithmic facilities -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-// Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <debug/debug.h>
#include <bits/move.h> // For std::swap and _GLIBCXX_MOVE
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// See http://gcc.gnu.org/ml/libstdc++/2004-08/msg00167.html: in a
// nutshell, we are partially implementing the resolution of DR 187,
__lg(long long __n)
{ return sizeof(long long) * __CHAR_BIT__ - 1 - __builtin_clzll(__n); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_P)
+_GLIBCXX_BEGIN_NAMESPACE_ALGO
/**
* @brief Tests a range for element-wise equality.
return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
}
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_ALGO
+} // namespace std
// NB: This file is included within many other C++ includes, as a way
// of getting the base algorithms. So, make sure that parallel bits
// vector<bool> specialization -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-// Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <initializer_list>
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
typedef unsigned long _Bit_type;
enum { _S_word_bit = int(__CHAR_BIT__ * sizeof(_Bit_type)) };
}
};
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
// Declare a partial specialization of vector<T, Alloc>.
#include <bits/stl_vector.h>
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/**
* @brief A specialization of vector for booleans which offers fixed time
{ this->_M_impl._M_finish = __pos; }
};
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <bits/functional_hash.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// DR 1182.
/// std::hash specialization for vector<bool>.
template<typename _Alloc>
- struct hash<_GLIBCXX_STD_D::vector<bool, _Alloc>>
- : public __hash_base<size_t, _GLIBCXX_STD_D::vector<bool, _Alloc>>
+ struct hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>
+ : public __hash_base<size_t, _GLIBCXX_STD_C::vector<bool, _Alloc>>
{
size_t
- operator()(const _GLIBCXX_STD_D::vector<bool, _Alloc>& __b) const;
+ operator()(const _GLIBCXX_STD_C::vector<bool, _Alloc>& __b) const;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+}// namespace std
#endif // __GXX_EXPERIMENTAL_CXX0X__
#include <new>
#include <bits/move.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* Constructs an object in existing memory by invoking an allocated
_Destroy(__first, __last);
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _STL_CONSTRUCT_H */
// Deque implementation -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-// Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <bits/stl_iterator_base_funcs.h>
#include <initializer_list>
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/**
* @brief This function controls the size of memory nodes.
#undef _GLIBCXX_DEQUE_BUF_SIZE
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#endif /* _STL_DEQUE_H */
#ifndef _STL_FUNCTION_H
#define _STL_FUNCTION_H 1
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// 20.3.1 base classes
/** @defgroup functors Function Objects
/** @} */
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#if !defined(__GXX_EXPERIMENTAL_CXX0X__) || _GLIBCXX_DEPRECATED
# include <backward/binders.h>
#include <debug/debug.h>
#include <bits/move.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @defgroup heap_algorithms Heap
{ return std::is_heap_until(__first, __last, __comp) == __last; }
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _STL_HEAP_H */
#include <ext/type_traits.h>
#include <bits/move.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup iterators
// @} group iterators
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// This iterator adapter is @a normal in the sense that it does not
// change the semantics of any of the operators of its iterator
__n, const __normal_iterator<_Iterator, _Container>& __i)
{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup iterators
// @} group iterators
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
#else
#include <bits/concept_check.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
#endif // __GXX_EXPERIMENTAL_CXX0X__
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _STL_ITERATOR_BASE_FUNCS_H */
# include <type_traits> // For _GLIBCXX_HAS_NESTED_TYPE
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @defgroup iterators Iterators
{ return __it.base(); }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _STL_ITERATOR_BASE_TYPES_H */
// List implementation -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-// Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <bits/concept_check.h>
#include <initializer_list>
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
-
- // Supporting structures are split into common and templated types; the
- // latter publicly inherits from the former in an effort to reduce code
- // duplication. This results in some "needless" static_cast'ing later on,
- // but it's all safe downcasting.
-
- /// Common part of a node in the %list.
- struct _List_node_base
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+ namespace __detail
{
- _List_node_base* _M_next;
- _List_node_base* _M_prev;
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
- static void
- swap(_List_node_base& __x, _List_node_base& __y) throw ();
+ // Supporting structures are split into common and templated
+ // types; the latter publicly inherits from the former in an
+ // effort to reduce code duplication. This results in some
+ // "needless" static_cast'ing later on, but it's all safe
+ // downcasting.
- void
- _M_transfer(_List_node_base * const __first,
- _List_node_base * const __last) throw ();
-
- void
- _M_reverse() throw ();
+ /// Common part of a node in the %list.
+ struct _List_node_base
+ {
+ _List_node_base* _M_next;
+ _List_node_base* _M_prev;
+
+ static void
+ swap(_List_node_base& __x, _List_node_base& __y) throw ();
+
+ void
+ _M_transfer(_List_node_base* const __first,
+ _List_node_base* const __last) throw ();
+
+ void
+ _M_reverse() throw ();
+
+ void
+ _M_hook(_List_node_base* const __position) throw ();
+
+ void
+ _M_unhook() throw ();
+ };
- void
- _M_hook(_List_node_base * const __position) throw ();
+ _GLIBCXX_END_NAMESPACE_VERSION
+ } // namespace detail
- void
- _M_unhook() throw ();
- };
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/// An actual node in the %list.
template<typename _Tp>
- struct _List_node : public _List_node_base
+ struct _List_node : public __detail::_List_node_base
{
///< User's data.
_Tp _M_data;
#ifdef __GXX_EXPERIMENTAL_CXX0X__
template<typename... _Args>
_List_node(_Args&&... __args)
- : _List_node_base(), _M_data(std::forward<_Args>(__args)...) { }
+ : __detail::_List_node_base(), _M_data(std::forward<_Args>(__args)...)
+ { }
#endif
};
: _M_node() { }
explicit
- _List_iterator(_List_node_base* __x)
+ _List_iterator(__detail::_List_node_base* __x)
: _M_node(__x) { }
// Must downcast from _List_node_base to _List_node to get to _M_data.
{ return _M_node != __x._M_node; }
// The only member points to the %list element.
- _List_node_base* _M_node;
+ __detail::_List_node_base* _M_node;
};
/**
: _M_node() { }
explicit
- _List_const_iterator(const _List_node_base* __x)
+ _List_const_iterator(const __detail::_List_node_base* __x)
: _M_node(__x) { }
_List_const_iterator(const iterator& __x)
{ return _M_node != __x._M_node; }
// The only member points to the %list element.
- const _List_node_base* _M_node;
+ const __detail::_List_node_base* _M_node;
};
template<typename _Val>
struct _List_impl
: public _Node_alloc_type
{
- _List_node_base _M_node;
+ __detail::_List_node_base _M_node;
_List_impl()
: _Node_alloc_type(), _M_node()
: _M_impl(__x._M_get_Node_allocator())
{
_M_init();
- _List_node_base::swap(this->_M_impl._M_node, __x._M_impl._M_node);
+ __detail::_List_node_base::swap(this->_M_impl._M_node,
+ __x._M_impl._M_node);
}
#endif
void
swap(list& __x)
{
- _List_node_base::swap(this->_M_impl._M_node, __x._M_impl._M_node);
+ __detail::_List_node_base::swap(this->_M_impl._M_node,
+ __x._M_impl._M_node);
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 431. Swapping containers with unequal allocators.
swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
{ __x.swap(__y); }
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#endif /* _STL_LIST_H */
// Map implementation -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-// Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <bits/concept_check.h>
#include <initializer_list>
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/**
* @brief A standard container made up of (key,value) pairs, which can be
map<_Key, _Tp, _Compare, _Alloc>& __y)
{ __x.swap(__y); }
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#endif /* _STL_MAP_H */
// Multimap implementation -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-// Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <bits/concept_check.h>
#include <initializer_list>
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/**
* @brief A standard container made up of (key,value) pairs, which can be
multimap<_Key, _Tp, _Compare, _Alloc>& __y)
{ __x.swap(__y); }
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#endif /* _STL_MULTIMAP_H */
// Multiset implementation -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-// Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <bits/concept_check.h>
#include <initializer_list>
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/**
* @brief A standard container made up of elements, which can be retrieved
multiset<_Key, _Compare, _Alloc>& __y)
{ __x.swap(__y); }
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#endif /* _STL_MULTISET_H */
// Numeric functions implementation -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-// Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Create a range of sequentially increasing values.
}
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
#endif
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_P)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_ALGO
/**
* @brief Accumulate values in a range.
return ++__result;
}
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_ALGO
+} // namespace std
#endif /* _STL_NUMERIC_H */
#include <type_traits> // for std::__decay_and_strip too
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
#ifdef __GXX_EXPERIMENTAL_CXX0X__
/// piecewise_construct_t
{ return pair<_T1, _T2>(__x, __y); }
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _STL_PAIR_H */
#include <bits/concept_check.h>
#include <debug/debug.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief A standard container giving FIFO behavior.
: public uses_allocator<_Sequence, _Alloc>::type { };
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _STL_QUEUE_H */
#ifndef _STL_RAW_STORAGE_ITERATOR_H
#define _STL_RAW_STORAGE_ITERATOR_H 1
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* This iterator class lets algorithms store their results into
}
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
// std::rel_ops implementation -*- C++ -*-
-// Copyright (C) 2001, 2002, 2004, 2005, 2008, 2010
+// Copyright (C) 2001, 2002, 2004, 2005, 2008, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
#ifndef _STL_RELOPS_H
#define _STL_RELOPS_H 1
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std _GLIBCXX_VISIBILITY(default)
+{
namespace rel_ops
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/** @namespace std::rel_ops
* @brief The generated relational operators are sequestered here.
*/
operator>=(const _Tp& __x, const _Tp& __y)
{ return !(__x < __y); }
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace rel_ops
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif /* _STL_RELOPS_H */
// Set implementation -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-// Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <bits/concept_check.h>
#include <initializer_list>
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/**
* @brief A standard container made up of unique keys, which can be
__glibcxx_class_requires(_Key, _SGIAssignableConcept)
__glibcxx_class_requires4(_Compare, bool, _Key, _Key,
_BinaryFunctionConcept)
- __glibcxx_class_requires2(_Key, _Alloc_value_type, _SameTypeConcept)
+ __glibcxx_class_requires2(_Key, _Alloc_value_type, _SameTypeConcept)
public:
// typedefs:
* otherwise (where N is distance(first,last)).
*/
template<typename _InputIterator>
- set(_InputIterator __first, _InputIterator __last)
+ set(_InputIterator __first, _InputIterator __last)
: _M_t()
- { _M_t._M_insert_unique(__first, __last); }
+ { _M_t._M_insert_unique(__first, __last); }
/**
* @brief Builds a %set from a range.
* otherwise (where N is distance(first,last)).
*/
template<typename _InputIterator>
- set(_InputIterator __first, _InputIterator __last,
+ set(_InputIterator __first, _InputIterator __last,
const _Compare& __comp,
const allocator_type& __a = allocator_type())
: _M_t(__comp, __a)
- { _M_t._M_insert_unique(__first, __last); }
+ { _M_t._M_insert_unique(__first, __last); }
/**
* @brief %Set copy constructor.
* std::swap(s1,s2) will feed to this function.
*/
void
- swap(set& __x)
+ swap(set& __x)
{ _M_t.swap(__x._M_t); }
// insert/erase
*
* For more on @a hinting, see:
* http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html
- *
+ *
* Insertion requires logarithmic time (if the hint is not taken).
*/
iterator
* Complexity similar to that of the range constructor.
*/
template<typename _InputIterator>
- void
- insert(_InputIterator __first, _InputIterator __last)
- { _M_t._M_insert_unique(__first, __last); }
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ { _M_t._M_insert_unique(__first, __last); }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
/**
* @brief Erases an element from a %set.
* @param position An iterator pointing to the element to be erased.
* @return An iterator pointing to the element immediately following
- * @a position prior to the element being erased. If no such
+ * @a position prior to the element being erased. If no such
* element exists, end() is returned.
*
* This function erases an element, pointed to by the given iterator,
//@}
template<typename _K1, typename _C1, typename _A1>
- friend bool
- operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
+ friend bool
+ operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
template<typename _K1, typename _C1, typename _A1>
- friend bool
- operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
+ friend bool
+ operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
};
swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
{ __x.swap(__y); }
-_GLIBCXX_END_NESTED_NAMESPACE
-
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} //namespace std
#endif /* _STL_SET_H */
#include <bits/concept_check.h>
#include <debug/debug.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief A standard container giving FILO behavior.
: public uses_allocator<_Seq, _Alloc>::type { };
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _STL_STACK_H */
#include <bits/stl_algobase.h>
#include <bits/stl_construct.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Allocates a temporary buffer.
}
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _STL_TEMPBUF_H */
#include <bits/stl_function.h>
#include <bits/cpp_type_traits.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Red-black tree class, designed for use in implementing STL
// associative containers (set, multiset, map, and multimap). The
return true;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#ifndef _STL_UNINITIALIZED_H
#define _STL_UNINITIALIZED_H 1
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<bool _TrivialValueTypes>
struct __uninitialized_copy
std::__iterator_category(__first)); }
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _STL_UNINITIALIZED_H */
// Vector implementation -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-// Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <bits/concept_check.h>
#include <initializer_list>
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/// See bits/stl_deque.h's _Deque_base for an explanation.
template<typename _Tp, typename _Alloc>
swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
{ __x.swap(__y); }
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#endif /* _STL_VECTOR_H */
#include <debug/debug.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup iterators
// @} group iterators
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits>
streamsize
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <streambuf>
#include <debug/debug.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup iterators
// @} group iterators
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/c++config.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Alloc>
class allocator;
#endif
/** @} */
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // _STRINGFWD_H
#include <utility>
#include <tuple>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup pointer_abstractions
// @} group pointer_abstractions
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _UNIQUE_PTR_H */
// unordered_map implementation -*- C++ -*-
-// Copyright (C) 2010 Free Software Foundation, Inc.
+// Copyright (C) 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#ifndef _UNORDERED_MAP_H
#define _UNORDERED_MAP_H
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
- // XXX When we get typedef templates these class definitions
+ // NB: When we get typedef templates these class definitions
// will be unnecessary.
template<class _Key, class _Tp,
class _Hash = hash<_Key>,
const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ return !(__x == __y); }
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#endif /* _UNORDERED_MAP_H */
// unordered_set implementation -*- C++ -*-
-// Copyright (C) 2010 Free Software Foundation, Inc.
+// Copyright (C) 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#ifndef _UNORDERED_SET_H
#define _UNORDERED_SET_H
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
- // XXX When we get typedef templates these class definitions
+ // NB: When we get typedef templates these class definitions
// will be unnecessary.
template<class _Value,
class _Hash = hash<_Value>,
const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
{ return !(__x == __y); }
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#endif /* _UNORDERED_SET_H */
#pragma GCC system_header
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
//
// gslice_array closure.
#undef _DEFINE_EXPR_BINARY_FUNCTION
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _CPP_VALARRAY_AFTER_H */
#include <cstdlib>
#include <new>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
//
// Helper functions on raw pointers
#undef _DEFINE_ARRAY_FUNCTION
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
# include <bits/valarray_array.tcc>
#ifndef _VALARRAY_ARRAY_TCC
#define _VALARRAY_ARRAY_TCC 1
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp>
void
}
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _VALARRAY_ARRAY_TCC */
#include <bits/slice_array.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
//
// Implementing a loosened valarray return value is tricky.
_SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {}
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _CPP_VALARRAY_BEFORE_H */
// Vector implementation (out of line) -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-// Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#ifndef _VECTOR_TCC
#define _VECTOR_TCC 1
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Tp, typename _Alloc>
void
}
}
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Alloc>
size_t
- hash<_GLIBCXX_STD_D::vector<bool, _Alloc>>::
- operator()(const _GLIBCXX_STD_D::vector<bool, _Alloc>& __b) const
+ hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>::
+ operator()(const _GLIBCXX_STD_C::vector<bool, _Alloc>& __b) const
{
size_t __hash = 0;
- using _GLIBCXX_STD_D::_S_word_bit;
- using _GLIBCXX_STD_D::_Bit_type;
+ using _GLIBCXX_STD_C::_S_word_bit;
+ using _GLIBCXX_STD_C::_Bit_type;
const size_t __words = __b.size() / _S_word_bit;
if (__words)
return __hash;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
#endif // __GXX_EXPERIMENTAL_CXX0X__
#undef islessgreater
#undef isunordered
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
inline double
abs(double __x)
// Need to do a bit of trickery here with mbstate_t as char_traits
// assumes it is in wchar.h, regardless of wchar_t specializations.
#ifndef _GLIBCXX_HAVE_MBSTATE_T
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
extern "C"
{
#undef fesetenv
#undef feupdateenv
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
// types
using ::fenv_t;
using ::fexcept_t;
using ::feholdexcept;
using ::fesetenv;
using ::feupdateenv;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace
#endif // _GLIBCXX_USE_C99_FENV_TR1
#ifdef _GLIBCXX_USE_C99_INTTYPES_TR1
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
// types
using ::imaxdiv_t;
using ::wcstoimax;
using ::wcstoumax;
#endif
-
-_GLIBCXX_END_NAMESPACE
+} // namespace
#endif _GLIBCXX_USE_C99_INTTYPES_TR1
#ifdef _GLIBCXX_USE_C99_STDINT_TR1
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::int8_t;
using ::int16_t;
using ::int32_t;
using ::uintmax_t;
using ::uintptr_t;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace
#endif // _GLIBCXX_USE_C99_STDINT_TR1
#undef tolower
#undef toupper
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::isalnum;
using ::isalpha;
using ::iscntrl;
using ::isxdigit;
using ::tolower;
using ::toupper;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#ifdef __GXX_EXPERIMENTAL_CXX0X__
#undef isblank
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::isblank;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif // _GLIBCXX_USE_C99_CTYPE_TR1
#undef fesetenv
#undef feupdateenv
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
// types
using ::fenv_t;
using ::fexcept_t;
using ::feholdexcept;
using ::fesetenv;
using ::feupdateenv;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif // _GLIBCXX_USE_C99_FENV_TR1
#ifdef _GLIBCXX_USE_C99_INTTYPES_TR1
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
// types
using ::imaxdiv_t;
using ::wcstoimax;
using ::wcstoumax;
#endif
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif // _GLIBCXX_USE_C99_INTTYPES_TR1
#undef setlocale
#undef localeconv
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::lconv;
using ::setlocale;
using ::localeconv;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif
#undef tan
#undef tanh
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
inline double
abs(double __x)
tanh(_Tp __x)
{ return __builtin_tanh(__x); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#if _GLIBCXX_USE_C99_MATH
#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
#undef islessgreater
#undef isunordered
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
#ifdef __GXX_EXPERIMENTAL_CXX0X__
inline int
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
#endif
#undef truncf
#undef truncl
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// types
using ::double_t;
return trunc(__type(__x));
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // _GLIBCXX_USE_C99_MATH_TR1
#define setjmp(env) setjmp (env)
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::jmp_buf;
using ::longjmp;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif
// Get rid of those macros defined in <signal.h> in lieu of real functions.
#undef raise
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::sig_atomic_t;
using ::signal;
using ::raise;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif
#define va_end(ap) va_end (ap)
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::va_list;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif
#ifdef _GLIBCXX_USE_C99_STDINT_TR1
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::int8_t;
using ::int16_t;
using ::int32_t;
using ::uintmax_t;
using ::uintptr_t;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif // _GLIBCXX_USE_C99_STDINT_TR1
#undef vprintf
#undef vsprintf
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::FILE;
using ::fpos_t;
using ::vfprintf;
using ::vprintf;
using ::vsprintf;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace
#if _GLIBCXX_USE_C99
#undef vsnprintf
#undef vsscanf
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
-
+namespace __gnu_cxx
+{
#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC
extern "C" int
(snprintf)(char * __restrict, std::size_t, const char * __restrict, ...)
using ::vsnprintf;
using ::vsscanf;
#endif
+} // namespace __gnu_cxx
-_GLIBCXX_END_NAMESPACE
-
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::__gnu_cxx::snprintf;
using ::__gnu_cxx::vfscanf;
using ::__gnu_cxx::vscanf;
using ::__gnu_cxx::vsnprintf;
using ::__gnu_cxx::vsscanf;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif // _GLIBCXX_USE_C99
#define EXIT_SUCCESS 0
#define EXIT_FAILURE 1
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
extern "C" void abort(void) throw () _GLIBCXX_NORETURN;
extern "C" int atexit(void (*)()) throw ();
extern "C" void exit(int) throw () _GLIBCXX_NORETURN;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#else
#undef wcstombs
#undef wctomb
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using ::div_t;
using ::ldiv_t;
inline ldiv_t
div(long __i, long __j) { return ldiv(__i, __j); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#if _GLIBCXX_USE_C99
#undef strtof
#undef strtold
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
using ::lldiv_t;
using ::strtof;
using ::strtold;
-_GLIBCXX_END_NAMESPACE
-
-_GLIBCXX_BEGIN_NAMESPACE(std)
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __gnu_cxx
+namespace std
+{
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
using ::__gnu_cxx::lldiv_t;
#endif
using ::__gnu_cxx::strtoll;
using ::__gnu_cxx::strtoull;
using ::__gnu_cxx::strtold;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
// types
using std::lldiv_t;
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
using std::div;
#endif
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif // __GXX_EXPERIMENTAL_CXX0X__
#undef strtok
#undef strxfrm
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using ::memchr;
using ::memcmp;
{ return __builtin_strstr(__s1, __s2); }
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#undef localtime
#undef strftime
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::clock_t;
using ::time_t;
using ::tm;
using ::gmtime;
using ::localtime;
using ::strftime;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace
#endif
}
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::mbstate_t;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
// Get rid of those macros defined in <wchar.h> in lieu of real functions.
#undef btowc
#if _GLIBCXX_USE_WCHAR_T
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std _GLIBCXX_VISIBILITY(default)
+{
using ::wint_t;
using ::btowc;
using ::wcsstr;
using ::wmemchr;
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#ifndef __CORRECT_ISO_CPP_WCHAR_H_PROTO
inline wchar_t*
wcschr(wchar_t* __p, wchar_t __c)
{ return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#if _GLIBCXX_USE_C99
#undef wcstoll
#undef wcstoull
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
-
+namespace __gnu_cxx
+{
#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC
extern "C" long double
(wcstold)(const wchar_t * __restrict, wchar_t ** __restrict) throw ();
using ::wcstoll;
using ::wcstoull;
#endif
+} // namespace __gnu_cxx
-_GLIBCXX_END_NAMESPACE
-
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace
#endif
#ifdef _GLIBCXX_USE_WCHAR_T
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
#if _GLIBCXX_HAVE_WCSTOF
using std::wcstof;
#endif
using std::wcstoll;
using std::wcstoull;
#endif
-
-_GLIBCXX_END_NAMESPACE
+} // namespace
#endif // _GLIBCXX_USE_WCHAR_T
#if _GLIBCXX_USE_WCHAR_T
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::wctrans_t;
using ::wctype_t;
using ::wint_t;
using ::towupper;
using ::wctrans;
using ::wctype;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace
#endif //_GLIBCXX_USE_WCHAR_T
#ifdef _GLIBCXX_USE_WCHAR_T
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
#if _GLIBCXX_HAVE_ISWBLANK
using std::iswblank;
#endif
-
-_GLIBCXX_END_NAMESPACE
+} // namespace
#endif // _GLIBCXX_USE_WCHAR_T
#undef tolower
#undef toupper
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::isalnum;
using ::isalpha;
using ::iscntrl;
using ::isxdigit;
using ::tolower;
using ::toupper;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif
#undef setlocale
#undef localeconv
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::lconv;
using ::setlocale;
using ::localeconv;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif
#undef tan
#undef tanh
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
inline double
abs(double __x)
tanh(_Tp __x)
{ return __builtin_tanh(__x); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#if _GLIBCXX_USE_C99_MATH
#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
#undef islessgreater
#undef isunordered
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
return __builtin_isunordered(__type(__f1), __type(__f2));
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
#endif
#define setjmp(env) setjmp (env)
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::jmp_buf;
using ::longjmp;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif
// Get rid of those macros defined in <signal.h> in lieu of real functions.
#undef raise
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::sig_atomic_t;
using ::signal;
using ::raise;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif
#define va_end(ap) va_end (ap)
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::va_list;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif
#undef vprintf
#undef vsprintf
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::FILE;
using ::fpos_t;
using ::vfprintf;
using ::vprintf;
using ::vsprintf;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#if _GLIBCXX_USE_C99
#undef vsnprintf
#undef vsscanf
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
-
+namespace __gnu_cxx
+{
#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC
extern "C" int
(snprintf)(char * __restrict, std::size_t, const char * __restrict, ...)
using ::vsnprintf;
using ::vsscanf;
#endif
+} // namespace __gnu_cxx
-_GLIBCXX_END_NAMESPACE
-
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::__gnu_cxx::snprintf;
using ::__gnu_cxx::vfscanf;
using ::__gnu_cxx::vscanf;
using ::__gnu_cxx::vsnprintf;
using ::__gnu_cxx::vsscanf;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif
#define EXIT_SUCCESS 0
#define EXIT_FAILURE 1
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
extern "C" void abort(void) throw () _GLIBCXX_NORETURN;
extern "C" int atexit(void (*)()) throw ();
extern "C" void exit(int) throw () _GLIBCXX_NORETURN;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace
#else
#undef wcstombs
#undef wctomb
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using ::div_t;
using ::ldiv_t;
inline ldiv_t
div(long __i, long __j) { return ldiv(__i, __j); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#if _GLIBCXX_USE_C99
#undef strtof
#undef strtold
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
using ::lldiv_t;
using ::strtof;
using ::strtold;
-_GLIBCXX_END_NAMESPACE
-
-_GLIBCXX_BEGIN_NAMESPACE(std)
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __gnu_cxx
+namespace std
+{
#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
using ::__gnu_cxx::lldiv_t;
#endif
using ::__gnu_cxx::strtoll;
using ::__gnu_cxx::strtoull;
using ::__gnu_cxx::strtold;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif // _GLIBCXX_USE_C99
#undef strerror
#undef strlen
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using ::memcpy;
using ::memmove;
{ return __builtin_strstr(__s1, __s2); }
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#undef localtime
#undef strftime
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::clock_t;
using ::time_t;
using ::tm;
using ::gmtime;
using ::localtime;
using ::strftime;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace
#endif
}
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::mbstate_t;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
// Get rid of those macros defined in <wchar.h> in lieu of real functions.
#undef btowc
#if _GLIBCXX_USE_WCHAR_T
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using ::wint_t;
{ return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#if _GLIBCXX_USE_C99
#undef wcstoll
#undef wcstoull
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
-
+namespace __gnu_cxx
+{
#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC
extern "C" long double
(wcstold)(const wchar_t * __restrict, wchar_t ** __restrict) throw ();
using ::wcstoll;
using ::wcstoull;
#endif
+} // namespace __gnu_cxx
-_GLIBCXX_END_NAMESPACE
-
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif
#if _GLIBCXX_USE_WCHAR_T
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std
+{
using ::wint_t; // cwchar
using ::wctype_t;
using ::towupper;
using ::wctrans;
using ::wctype;
-
-_GLIBCXX_END_NAMESPACE
+} // namespace std
#endif //_GLIBCXX_USE_WCHAR_T
#include <debug/safe_sequence.h>
#include <debug/safe_iterator.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
{
/// Class std::bitset with additional safety/checking/debug instrumentation.
template<size_t _Nb>
class bitset
- : public _GLIBCXX_STD_D::bitset<_Nb>
+ : public _GLIBCXX_STD_C::bitset<_Nb>
#ifndef __GXX_EXPERIMENTAL_CXX0X__
, public __gnu_debug::_Safe_sequence_base
#endif
{
- typedef _GLIBCXX_STD_D::bitset<_Nb> _Base;
+ typedef _GLIBCXX_STD_C::bitset<_Nb> _Base;
public:
// In C++0x we rely on normal reference type to preserve the property
{
size_t
operator()(const __debug::bitset<_Nb>& __b) const
- { return std::hash<_GLIBCXX_STD_D::bitset<_Nb>>()(__b._M_base()); }
+ { return std::hash<_GLIBCXX_STD_C::bitset<_Nb>>()(__b._M_base()); }
};
#endif
* @namespace std::__debug
* @brief GNU debug code, replaces standard behavior with debug behavior.
*/
-namespace std
+namespace std
{
namespace __debug { }
}
#include <debug/safe_sequence.h>
#include <debug/safe_iterator.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
{
/// Class std::deque with safety/checking/debug instrumentation.
template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
class deque
- : public _GLIBCXX_STD_D::deque<_Tp, _Allocator>,
+ : public _GLIBCXX_STD_C::deque<_Tp, _Allocator>,
public __gnu_debug::_Safe_sequence<deque<_Tp, _Allocator> >
{
- typedef _GLIBCXX_STD_D::deque<_Tp, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::deque<_Tp, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<deque> _Safe_base;
typedef typename _Base::const_iterator _Base_const_iterator;
#include <debug/safe_sequence.h>
#include <debug/safe_iterator.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
{
/// Class std::forward_list with safety/checking/debug instrumentation.
template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
class forward_list
- : public _GLIBCXX_STD_D::forward_list<_Tp, _Alloc>,
+ : public _GLIBCXX_STD_C::forward_list<_Tp, _Alloc>,
public __gnu_debug::_Safe_sequence<forward_list<_Tp, _Alloc> >
{
- typedef _GLIBCXX_STD_D::forward_list<_Tp, _Alloc> _Base;
+ typedef _GLIBCXX_STD_C::forward_list<_Tp, _Alloc> _Base;
typedef __gnu_debug::_Safe_sequence<forward_list> _Safe_base;
typedef typename _Base::iterator _Base_iterator;
#include <debug/safe_sequence.h>
#include <debug/safe_iterator.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
{
/// Class std::list with safety/checking/debug instrumentation.
template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
class list
- : public _GLIBCXX_STD_D::list<_Tp, _Allocator>,
+ : public _GLIBCXX_STD_C::list<_Tp, _Allocator>,
public __gnu_debug::_Safe_sequence<list<_Tp, _Allocator> >
{
- typedef _GLIBCXX_STD_D::list<_Tp, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::list<_Tp, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<list> _Safe_base;
typedef typename _Base::iterator _Base_iterator;
#include <debug/safe_iterator.h>
#include <utility>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
{
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
class map
- : public _GLIBCXX_STD_D::map<_Key, _Tp, _Compare, _Allocator>,
+ : public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>,
public __gnu_debug::_Safe_sequence<map<_Key, _Tp, _Compare, _Allocator> >
{
- typedef _GLIBCXX_STD_D::map<_Key, _Tp, _Compare, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<map> _Safe_base;
typedef typename _Base::const_iterator _Base_const_iterator;
#include <debug/safe_iterator.h>
#include <utility>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
{
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
class multimap
- : public _GLIBCXX_STD_D::multimap<_Key, _Tp, _Compare, _Allocator>,
+ : public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator>,
public __gnu_debug::_Safe_sequence<multimap<_Key, _Tp,
_Compare, _Allocator> >
{
- typedef _GLIBCXX_STD_D::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<multimap> _Safe_base;
typedef typename _Base::const_iterator _Base_const_iterator;
#include <debug/safe_iterator.h>
#include <utility>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
{
template<typename _Key, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<_Key> >
class multiset
- : public _GLIBCXX_STD_D::multiset<_Key, _Compare, _Allocator>,
+ : public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>,
public __gnu_debug::_Safe_sequence<multiset<_Key, _Compare, _Allocator> >
{
- typedef _GLIBCXX_STD_D::multiset<_Key, _Compare, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<multiset> _Safe_base;
typedef typename _Base::const_iterator _Base_const_iterator;
#include <debug/safe_iterator.h>
#include <utility>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
{
template<typename _Key, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<_Key> >
class set
- : public _GLIBCXX_STD_D::set<_Key,_Compare,_Allocator>,
+ : public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>,
public __gnu_debug::_Safe_sequence<set<_Key, _Compare, _Allocator> >
{
- typedef _GLIBCXX_STD_D::set<_Key, _Compare, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::set<_Key, _Compare, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<set> _Safe_base;
typedef typename _Base::const_iterator _Base_const_iterator;
#include <debug/safe_sequence.h>
#include <debug/safe_iterator.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
{
typename _Pred = std::equal_to<_Key>,
typename _Alloc = std::allocator<_Key> >
class unordered_map
- : public _GLIBCXX_STD_D::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>,
+ : public _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>,
public __gnu_debug::_Safe_sequence<unordered_map<_Key, _Tp, _Hash,
_Pred, _Alloc> >
{
- typedef _GLIBCXX_STD_D::unordered_map<_Key, _Tp, _Hash,
+ typedef _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash,
_Pred, _Alloc> _Base;
typedef __gnu_debug::_Safe_sequence<unordered_map> _Safe_base;
typedef typename _Base::const_iterator _Base_const_iterator;
typename _Pred = std::equal_to<_Key>,
typename _Alloc = std::allocator<_Key> >
class unordered_multimap
- : public _GLIBCXX_STD_D::unordered_multimap<_Key, _Tp, _Hash,
+ : public _GLIBCXX_STD_C::unordered_multimap<_Key, _Tp, _Hash,
_Pred, _Alloc>,
public __gnu_debug::_Safe_sequence<unordered_multimap<_Key, _Tp, _Hash,
_Pred, _Alloc> >
{
- typedef _GLIBCXX_STD_D::unordered_multimap<_Key, _Tp, _Hash,
+ typedef _GLIBCXX_STD_C::unordered_multimap<_Key, _Tp, _Hash,
_Pred, _Alloc> _Base;
typedef __gnu_debug::_Safe_sequence<unordered_multimap> _Safe_base;
typedef typename _Base::const_iterator _Base_const_iterator;
#include <debug/safe_sequence.h>
#include <debug/safe_iterator.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
{
typename _Pred = std::equal_to<_Value>,
typename _Alloc = std::allocator<_Value> >
class unordered_set
- : public _GLIBCXX_STD_D::unordered_set<_Value, _Hash, _Pred, _Alloc>,
+ : public _GLIBCXX_STD_C::unordered_set<_Value, _Hash, _Pred, _Alloc>,
public __gnu_debug::_Safe_sequence<unordered_set<_Value, _Hash,
_Pred, _Alloc> >
{
- typedef _GLIBCXX_STD_D::unordered_set<_Value, _Hash,
+ typedef _GLIBCXX_STD_C::unordered_set<_Value, _Hash,
_Pred, _Alloc> _Base;
typedef __gnu_debug::_Safe_sequence<unordered_set> _Safe_base;
typedef typename _Base::const_iterator _Base_const_iterator;
typename _Pred = std::equal_to<_Value>,
typename _Alloc = std::allocator<_Value> >
class unordered_multiset
- : public _GLIBCXX_STD_D::unordered_multiset<_Value, _Hash, _Pred, _Alloc>,
+ : public _GLIBCXX_STD_C::unordered_multiset<_Value, _Hash, _Pred, _Alloc>,
public __gnu_debug::_Safe_sequence<unordered_multiset<_Value, _Hash,
_Pred, _Alloc> >
{
- typedef _GLIBCXX_STD_D::unordered_multiset<_Value, _Hash,
+ typedef _GLIBCXX_STD_C::unordered_multiset<_Value, _Hash,
_Pred, _Alloc> _Base;
typedef __gnu_debug::_Safe_sequence<unordered_multiset> _Safe_base;
typedef typename _Base::const_iterator _Base_const_iterator;
#include <debug/safe_sequence.h>
#include <debug/safe_iterator.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
{
template<typename _Tp,
typename _Allocator = std::allocator<_Tp> >
class vector
- : public _GLIBCXX_STD_D::vector<_Tp, _Allocator>,
+ : public _GLIBCXX_STD_C::vector<_Tp, _Allocator>,
public __gnu_debug::_Safe_sequence<vector<_Tp, _Allocator> >
{
- typedef _GLIBCXX_STD_D::vector<_Tp, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base;
typedef __gnu_debug::_Safe_sequence<vector> _Safe_base;
typedef typename _Base::iterator _Base_iterator;
{
size_t
operator()(const __debug::vector<bool, _Alloc>& __b) const
- { return std::hash<_GLIBCXX_STD_D::vector<bool, _Alloc>>()
+ { return std::hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>()
(__b._M_base()); }
};
#endif
// <decimal> -*- C++ -*-
-// Copyright (C) 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
that is currently not available.
#endif
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
/**
* @defgroup decimal Decimal Floating-Point Arithmetic
*/
namespace decimal
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
class decimal32;
class decimal64;
class decimal128;
#define _GLIBCXX_USE_DECIMAL_ 1
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace decimal
// @} group decimal
} // namespace std
// decimal classes -*- C++ -*-
-// Copyright (C) 2009 Free Software Foundation, Inc.
+// Copyright (C) 2009, 2011 Free Software Foundation, Inc.
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
-/** @file bits/decimal.h
+/** @file decimal/decimal.h
* This is an internal header file, included by other library headers.
- * You should not attempt to use it directly.
+ * Do not attempt to use it directly. @headername{decimal}
*/
// ISO/IEC TR 24733
#pragma GCC system_header
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace decimal
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
// ISO/IEC TR 24733 3.2.[234].1 Construct/copy/destroy.
inline decimal32::decimal32(decimal64 __r) : __val(__r.__getval()) {}
#undef _DEFINE_DECIMAL_COMPARISON_LHS
#undef _DEFINE_DECIMAL_COMPARISON_RHS
#undef _DEFINE_DECIMAL_COMPARISONS
-
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace decimal
} // namespace std
#include <algorithm>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::ptrdiff_t;
using std::min;
return __b;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _EXT_ALGORITHM */
#include <tr1/array>
#include <bits/move.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::size_t;
using std::ptrdiff_t;
const array_allocator<_Tp, _Array>&)
{ return false; }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/gthr.h>
#include <bits/atomic_word.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Functions for portable atomic access.
// To abstract locking primitives across all thread policies, use:
#endif
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Even if the CPU doesn't need a memory barrier, we need to ensure
// that the compiler doesn't reorder memory accesses across the
// Bitmap Allocator. -*- C++ -*-
-// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
+// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
*/
#define _BALLOC_ALIGN_BYTES 8
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
-
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
using std::size_t;
using std::ptrdiff_t;
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/** @class __mini_vector bitmap_allocator.h bitmap_allocator.h
*
* @brief __mini_vector<> is a stripped down version of the
size_t __mask = 1 << __pos;
*__pbmap |= __mask;
}
+
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/** @brief Generic Version of the bsf instruction.
*/
inline size_t
bitmap_allocator<_Tp>::_S_mut;
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace __gnu_cxx
#endif
#ifndef _GLIBCXX_CAST_H
#define _GLIBCXX_CAST_H 1
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* These functions are here to allow containers to support non standard
{ return _ToType(reinterpret_cast<typename _Caster<_ToType>::
type>(__arg)); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // __GLIBCXX_CAST_H
#include <locale>
#include <iconv.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Extension to use iconv for dealing with character encodings.
// This includes conversions and comparisons between various character
typedef typename std::fpos<state_type> pos_type;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using __gnu_cxx::encoding_state;
do_max_length() const throw()
{ return 1; }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/cpp_type_traits.h>
#include <ext/type_traits.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Available locking policies:
// _S_single single-threaded code that doesn't need to be locked.
};
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <stdexcept>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::size_t;
}
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <locale>
#include <ext/codecvt_specializations.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// class enc_filebuf.
template<typename _CharT>
__glibcxx_class_requires(state_type, _SGIAssignableConcept)
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <limits>
#include <ext/pointer.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief An example allocator which uses a non-standard pointer type.
__larg._M_real_alloc = __tmp;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _EXTPTR_ALLOCATOR_H */
#include <functional>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::size_t;
using std::unary_function;
mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
{ return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/concept_check.h>
#include <iterator>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// There are two signatures for distance. In addition to the one
// taking two iterators and returning a result, there is another
__distance(__first, __last, __n, std::__iterator_category(__first));
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/functexcept.h>
#include <bits/move.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::size_t;
using std::ptrdiff_t;
operator!=(const malloc_allocator<_Tp>&, const malloc_allocator<_Tp>&)
{ return false; }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <memory>
#include <bits/stl_tempbuf.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::ptrdiff_t;
using std::pair;
~temporary_buffer() { }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <ext/atomicity.h>
#include <bits/move.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::size_t;
using std::ptrdiff_t;
#undef __thread_default
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/functexcept.h>
#include <bits/move.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::size_t;
using std::ptrdiff_t;
operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
{ return false; }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <ext/functional> // For identity_element
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Returns __x ** __n, where __n >= 0. _Note that "multiplication"
// is required to be associative, but not necessarily commutative.
*__first++ = __value++;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/cpp_type_traits.h>
#include <ext/type_traits.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Compile time constants for builtin types.
// Sadly std::numeric_limits member functions cannot be used for this.
__numeric_traits_floating<_Value> >::__type
{ };
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#undef __glibcxx_floating
#undef __glibcxx_max_digits10
typedef typename std::allocator<Key> key_allocator;
typedef typename key_allocator::size_type size_type;
typedef Const_Key_Reference const_key_reference;
- typedef std::__norm::list<Key> key_set;
+ typedef std::_GLIBCXX_STD_C::list<Key> key_set;
typedef typename key_set::iterator key_set_iterator;
typedef typename key_set::const_iterator const_key_set_iterator;
typedef __gnu_cxx::throw_allocator_random<Key> key_db_allocator;
#include <string>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// POD character abstraction.
// NB: The char_type parameter is a subset of int_type, as to allow
operator<(const character<V, I, S>& lhs, const character<V, I, S>& rhs)
{ return lhs.value < rhs.value; }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/// char_traits<__gnu_cxx::character> specialization.
template<typename V, typename I, typename S>
{ return eq_int_type(__c, eof()) ? int_type() : __c; }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <ext/cast.h>
#include <ext/type_traits.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief A storage policy for use with _Pointer_adapter<> which yields a
const _Pointer_adapter<_StoreT>& __p)
{ return (__os << __p.get()); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // _POINTER_H
#include <ext/concurrence.h>
#include <bits/move.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::size_t;
using std::ptrdiff_t;
}
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/stl_tree.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::_Rb_tree;
using std::allocator;
~rb_tree() { }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <ext/atomicity.h>
#include <bits/stl_iterator_base_funcs.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* Documentation? What's that?
}
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _RC_STRING_BASE_H */
#include <ext/memory> // For uninitialized_copy_n
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
-
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
namespace __detail
{
enum { _S_max_rope_depth = 45 };
using std::allocator;
using std::_Destroy;
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
// See libstdc++/36832.
template<typename _ForwardIterator, typename _Allocator>
void
swap(rope<_CharT, _Alloc>& __x, rope<_CharT, _Alloc>& __y)
{ __x.swap(__y); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
template<>
struct hash<__gnu_cxx::crope>
{
return 13 * __str[0] + 5 * __str[__size - 1] + __size;
}
};
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace tr1
} // namespace std
#include <ext/memory> // For uninitialized_copy_n
#include <ext/numeric> // For power
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::size_t;
using std::printf;
{ _Rope_rotate(__first, __middle, __last); }
# endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/stl_uninitialized.h>
#include <bits/concept_check.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::size_t;
using std::ptrdiff_t;
}
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Specialization of insert_iterator so that insertions will be constant
// time rather than linear time.
{ return *this; }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#ifndef _SSO_STRING_BASE_H
#define _SSO_STRING_BASE_H 1
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits, typename _Alloc>
class __sso_string_base
_M_set_length(_M_length() - __n);
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _SSO_STRING_BASE_H */
#include <fstream>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Provides a layer of compatibility for C/POSIX.
}
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <cwchar>
#endif
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Provides a layer of compatibility for C.
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <cstdio>
#include <cerrno>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Helper for all the sto* functions.
template<typename _TRet, typename _Ret = _TRet, typename _CharT,
return _String(__s, __s + __len);
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // _STRING_CONVERSIONS_H
# include <tr1/random>
#endif
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Thown by exception safety machinery.
~throw_allocator_random() throw() { }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#ifdef __GXX_EXPERIMENTAL_CXX0X__
# include <bits/functional_hash.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
/// Explicit specialization of std::hash for __gnu_cxx::throw_value_limit.
template<>
#include <bits/c++config.h>
#include <bits/cpp_type_traits.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Define a nested type if some predicate holds.
template<bool, typename>
typedef __typeof__(__type1() + __type2() + __type3() + __type4()) __type;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <ext/type_traits.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/** @namespace __gnu_cxx::typelist
* @brief GNU typelist extensions for public compile-time use.
struct create6;
} // namespace typelist
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace typelist
{
} // namespace detail
} // namespace typelist
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#define _GLIBCXX_TYPELIST_CHAIN1(X0) __gnu_cxx::typelist::chain<X0, __gnu_cxx::typelist::null_type>
#define _GLIBCXX_TYPELIST_CHAIN2(X0, X1) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN1(X1) >
#define _GLIBCXX_TYPELIST_CHAIN14(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN13(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13) >
#define _GLIBCXX_TYPELIST_CHAIN15(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN14(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14) >
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace typelist
{
typedef node<_GLIBCXX_TYPELIST_CHAIN6(T1,T2,T3,T4,T5,T6)> type;
};
} // namespace typelist
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <ext/rc_string_base.h>
#include <ext/sso_string_base.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @class __versa_string vstring.h
__versa_string<_CharT, _Traits, _Alloc, _Base>& __rhs)
{ __lhs.swap(__rhs); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Read stream into a string.
__gnu_cxx::__versa_string<_CharT, _Traits, _Alloc, _Base>& __str)
{ return getline(__is, __str, __is.widen('\n')); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#if (defined(__GXX_EXPERIMENTAL_CXX0X__) && defined(_GLIBCXX_USE_C99))
#include <ext/string_conversions.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// 21.4 Numeric Conversions [string.conversions].
inline int
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <bits/cxxabi_forced.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits, typename _Alloc,
template <typename, typename, typename> class _Base>
return __r;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits, typename _Alloc,
template <typename, typename, typename> class _Base>
return __in;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // _VSTRING_TCC
#include <bits/char_traits.h>
#include <bits/allocator.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits, typename _Alloc>
class __sso_string_base;
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _VSTRING_FWD_H */
#include <bits/move.h>
#include <bits/range_access.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits, typename _Alloc>
struct __vstring_utility
}
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _VSTRING_UTIL_H */
#include <parallel/unique_copy.h>
#include <parallel/set_operations.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __parallel
{
inline _Function
for_each(_IIter __begin, _IIter __end, _Function __f,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::for_each(__begin, __end, __f); }
+ { return _GLIBCXX_STD_A::for_each(__begin, __end, __f); }
// Sequential fallback for input iterator case
inline _IIter
find(_IIter __begin, _IIter __end, const _Tp& __val,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::find(__begin, __end, __val); }
+ { return _GLIBCXX_STD_A::find(__begin, __end, __val); }
// Sequential fallback for input iterator case
template<typename _IIter, typename _Tp, typename _IteratorTag>
inline _IIter
__find_switch(_IIter __begin, _IIter __end, const _Tp& __val,
_IteratorTag)
- { return _GLIBCXX_STD_P::find(__begin, __end, __val); }
+ { return _GLIBCXX_STD_A::find(__begin, __end, __val); }
// Parallel find for random access iterators
template<typename _RAIter, typename _Tp>
__gnu_parallel::__find_if_selector()).first;
}
else
- return _GLIBCXX_STD_P::find(__begin, __end, __val);
+ return _GLIBCXX_STD_A::find(__begin, __end, __val);
}
// Public interface
inline _IIter
find_if(_IIter __begin, _IIter __end, _Predicate __pred,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::find_if(__begin, __end, __pred); }
+ { return _GLIBCXX_STD_A::find_if(__begin, __end, __pred); }
// Sequential fallback for input iterator case
template<typename _IIter, typename _Predicate, typename _IteratorTag>
inline _IIter
__find_if_switch(_IIter __begin, _IIter __end, _Predicate __pred,
_IteratorTag)
- { return _GLIBCXX_STD_P::find_if(__begin, __end, __pred); }
+ { return _GLIBCXX_STD_A::find_if(__begin, __end, __pred); }
// Parallel find_if for random access iterators
template<typename _RAIter, typename _Predicate>
__gnu_parallel::
__find_if_selector()).first;
else
- return _GLIBCXX_STD_P::find_if(__begin, __end, __pred);
+ return _GLIBCXX_STD_A::find_if(__begin, __end, __pred);
}
// Public interface
find_first_of(_IIter __begin1, _IIter __end1,
_FIterator __begin2, _FIterator __end2,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::find_first_of(__begin1, __end1, __begin2, __end2);
+ { return _GLIBCXX_STD_A::find_first_of(__begin1, __end1, __begin2, __end2);
}
// Sequential fallback
find_first_of(_IIter __begin1, _IIter __end1,
_FIterator __begin2, _FIterator __end2,
_BinaryPredicate __comp, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::find_first_of(
+ { return _GLIBCXX_STD_A::find_first_of(
__begin1, __end1, __begin2, __end2, __comp); }
// Sequential fallback for input iterator type
inline _OutputIterator
unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::unique_copy(__begin1, __end1, __out); }
+ { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, __out); }
// Sequential fallback
template<typename _IIter, typename _OutputIterator,
inline _OutputIterator
unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
_Predicate __pred, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::unique_copy(__begin1, __end1, __out, __pred); }
+ { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, __out, __pred); }
// Sequential fallback for input iterator case
template<typename _IIter, typename _OutputIterator,
__unique_copy_switch(_IIter __begin, _IIter __last,
_OutputIterator __out, _Predicate __pred,
_IteratorTag1, _IteratorTag2)
- { return _GLIBCXX_STD_P::unique_copy(__begin, __last, __out, __pred); }
+ { return _GLIBCXX_STD_A::unique_copy(__begin, __last, __out, __pred); }
// Parallel unique_copy for random access iterators
template<typename _RAIter, typename RandomAccessOutputIterator,
return __gnu_parallel::__parallel_unique_copy(
__begin, __last, __out, __pred);
else
- return _GLIBCXX_STD_P::unique_copy(__begin, __last, __out, __pred);
+ return _GLIBCXX_STD_A::unique_copy(__begin, __last, __out, __pred);
}
// Public interface
set_union(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
_OutputIterator __out, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::set_union(
+ { return _GLIBCXX_STD_A::set_union(
__begin1, __end1, __begin2, __end2, __out); }
// Sequential fallback
_IIter2 __begin2, _IIter2 __end2,
_OutputIterator __out, _Predicate __pred,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::set_union(__begin1, __end1,
+ { return _GLIBCXX_STD_A::set_union(__begin1, __end1,
__begin2, __end2, __out, __pred); }
// Sequential fallback for input iterator case
_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2,
_OutputIterator __result, _Predicate __pred,
_IteratorTag1, _IteratorTag2, _IteratorTag3)
- { return _GLIBCXX_STD_P::set_union(__begin1, __end1,
+ { return _GLIBCXX_STD_A::set_union(__begin1, __end1,
__begin2, __end2, __result, __pred); }
// Parallel set_union for random access iterators
return __gnu_parallel::__parallel_set_union(
__begin1, __end1, __begin2, __end2, __result, __pred);
else
- return _GLIBCXX_STD_P::set_union(__begin1, __end1,
+ return _GLIBCXX_STD_A::set_union(__begin1, __end1,
__begin2, __end2, __result, __pred);
}
set_intersection(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
_OutputIterator __out, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::set_intersection(__begin1, __end1,
+ { return _GLIBCXX_STD_A::set_intersection(__begin1, __end1,
__begin2, __end2, __out); }
// Sequential fallback.
_IIter2 __begin2, _IIter2 __end2,
_OutputIterator __out, _Predicate __pred,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::set_intersection(
+ { return _GLIBCXX_STD_A::set_intersection(
__begin1, __end1, __begin2, __end2, __out, __pred); }
// Sequential fallback for input iterator case
_IIter2 __begin2, _IIter2 __end2,
_OutputIterator __result, _Predicate __pred,
_IteratorTag1, _IteratorTag2, _IteratorTag3)
- { return _GLIBCXX_STD_P::set_intersection(__begin1, __end1, __begin2,
+ { return _GLIBCXX_STD_A::set_intersection(__begin1, __end1, __begin2,
__end2, __result, __pred); }
// Parallel set_intersection for random access iterators
return __gnu_parallel::__parallel_set_intersection(
__begin1, __end1, __begin2, __end2, __result, __pred);
else
- return _GLIBCXX_STD_P::set_intersection(
+ return _GLIBCXX_STD_A::set_intersection(
__begin1, __end1, __begin2, __end2, __result, __pred);
}
_IIter2 __begin2, _IIter2 __end2,
_OutputIterator __out,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::set_symmetric_difference(
+ { return _GLIBCXX_STD_A::set_symmetric_difference(
__begin1, __end1, __begin2, __end2, __out); }
// Sequential fallback
_IIter2 __begin2, _IIter2 __end2,
_OutputIterator __out, _Predicate __pred,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::set_symmetric_difference(
+ { return _GLIBCXX_STD_A::set_symmetric_difference(
__begin1, __end1, __begin2, __end2, __out, __pred); }
// Sequential fallback for input iterator case
_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2, _IIter2 __end2,
_OutputIterator __result, _Predicate __pred,
_IteratorTag1, _IteratorTag2, _IteratorTag3)
- { return _GLIBCXX_STD_P::set_symmetric_difference(
+ { return _GLIBCXX_STD_A::set_symmetric_difference(
__begin1, __end1, __begin2, __end2, __result, __pred); }
// Parallel set_symmetric_difference for random access iterators
return __gnu_parallel::__parallel_set_symmetric_difference(
__begin1, __end1, __begin2, __end2, __result, __pred);
else
- return _GLIBCXX_STD_P::set_symmetric_difference(
+ return _GLIBCXX_STD_A::set_symmetric_difference(
__begin1, __end1, __begin2, __end2, __result, __pred);
}
set_difference(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
_OutputIterator __out, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::set_difference(
+ { return _GLIBCXX_STD_A::set_difference(
__begin1,__end1, __begin2, __end2, __out); }
// Sequential fallback.
_IIter2 __begin2, _IIter2 __end2,
_OutputIterator __out, _Predicate __pred,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::set_difference(__begin1, __end1,
+ { return _GLIBCXX_STD_A::set_difference(__begin1, __end1,
__begin2, __end2, __out, __pred); }
// Sequential fallback for input iterator case.
_IIter2 __begin2, _IIter2 __end2,
_OutputIterator __result, _Predicate __pred,
_IteratorTag1, _IteratorTag2, _IteratorTag3)
- { return _GLIBCXX_STD_P::set_difference(
+ { return _GLIBCXX_STD_A::set_difference(
__begin1, __end1, __begin2, __end2, __result, __pred); }
// Parallel set_difference for random access iterators
return __gnu_parallel::__parallel_set_difference(
__begin1, __end1, __begin2, __end2, __result, __pred);
else
- return _GLIBCXX_STD_P::set_difference(
+ return _GLIBCXX_STD_A::set_difference(
__begin1, __end1, __begin2, __end2, __result, __pred);
}
inline _FIterator
adjacent_find(_FIterator __begin, _FIterator __end,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::adjacent_find(__begin, __end); }
+ { return _GLIBCXX_STD_A::adjacent_find(__begin, __end); }
// Sequential fallback
template<typename _FIterator, typename _BinaryPredicate>
adjacent_find(_FIterator __begin, _FIterator __end,
_BinaryPredicate __binary_pred,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::adjacent_find(__begin, __end, __binary_pred); }
+ { return _GLIBCXX_STD_A::adjacent_find(__begin, __end, __binary_pred); }
// Parallel algorithm for random access iterators
template<typename _RAIter>
inline typename iterator_traits<_IIter>::difference_type
count(_IIter __begin, _IIter __end, const _Tp& __value,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::count(__begin, __end, __value); }
+ { return _GLIBCXX_STD_A::count(__begin, __end, __value); }
// Parallel code for random access iterators
template<typename _RAIter, typename _Tp>
inline typename iterator_traits<_IIter>::difference_type
count_if(_IIter __begin, _IIter __end, _Predicate __pred,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::count_if(__begin, __end, __pred); }
+ { return _GLIBCXX_STD_A::count_if(__begin, __end, __pred); }
// Parallel count_if for random access iterators
template<typename _RAIter, typename _Predicate>
search(_FIterator1 __begin1, _FIterator1 __end1,
_FIterator2 __begin2, _FIterator2 __end2,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::search(__begin1, __end1, __begin2, __end2); }
+ { return _GLIBCXX_STD_A::search(__begin1, __end1, __begin2, __end2); }
// Parallel algorithm for random access iterator
template<typename _RAIter1, typename _RAIter2>
search(_FIterator1 __begin1, _FIterator1 __end1,
_FIterator2 __begin2, _FIterator2 __end2,
_BinaryPredicate __pred, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::search(
+ { return _GLIBCXX_STD_A::search(
__begin1, __end1, __begin2, __end2, __pred); }
// Parallel algorithm for random access iterator.
inline _FIterator
search_n(_FIterator __begin, _FIterator __end, _Integer __count,
const _Tp& __val, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::search_n(__begin, __end, __count, __val); }
+ { return _GLIBCXX_STD_A::search_n(__begin, __end, __count, __val); }
// Sequential fallback
template<typename _FIterator, typename _Integer, typename _Tp,
search_n(_FIterator __begin, _FIterator __end, _Integer __count,
const _Tp& __val, _BinaryPredicate __binary_pred,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::search_n(
+ { return _GLIBCXX_STD_A::search_n(
__begin, __end, __count, __val, __binary_pred); }
// Public interface.
__begin, __end, __ps.begin(), __ps.end(), __binary_pred);
}
else
- return _GLIBCXX_STD_P::search_n(__begin, __end, __count, __val,
+ return _GLIBCXX_STD_A::search_n(__begin, __end, __count, __val,
__binary_pred);
}
__search_n_switch(_FIterator __begin, _FIterator __end, _Integer __count,
const _Tp& __val, _BinaryPredicate __binary_pred,
_IteratorTag)
- { return _GLIBCXX_STD_P::search_n(__begin, __end, __count, __val,
+ { return _GLIBCXX_STD_A::search_n(__begin, __end, __count, __val,
__binary_pred); }
// Public interface.
inline _OutputIterator
transform(_IIter __begin, _IIter __end, _OutputIterator __result,
_UnaryOperation __unary_op, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::transform(__begin, __end, __result, __unary_op); }
+ { return _GLIBCXX_STD_A::transform(__begin, __end, __result, __unary_op); }
// Parallel unary transform for random access iterators.
template<typename _RAIter1, typename _RAIter2,
transform(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _OutputIterator __result,
_BinaryOperation __binary_op, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::transform(__begin1, __end1,
+ { return _GLIBCXX_STD_A::transform(__begin1, __end1,
__begin2, __result, __binary_op); }
// Parallel binary transform for random access iterators.
inline void
replace(_FIterator __begin, _FIterator __end, const _Tp& __old_value,
const _Tp& __new_value, __gnu_parallel::sequential_tag)
- { _GLIBCXX_STD_P::replace(__begin, __end, __old_value, __new_value); }
+ { _GLIBCXX_STD_A::replace(__begin, __end, __old_value, __new_value); }
// Sequential fallback for input iterator case
template<typename _FIterator, typename _Tp, typename _IteratorTag>
inline void
replace_if(_FIterator __begin, _FIterator __end, _Predicate __pred,
const _Tp& __new_value, __gnu_parallel::sequential_tag)
- { _GLIBCXX_STD_P::replace_if(__begin, __end, __pred, __new_value); }
+ { _GLIBCXX_STD_A::replace_if(__begin, __end, __pred, __new_value); }
// Sequential fallback for input iterator case
template<typename _FIterator, typename _Predicate, typename _Tp,
inline void
generate(_FIterator __begin, _FIterator __end, _Generator __gen,
__gnu_parallel::sequential_tag)
- { _GLIBCXX_STD_P::generate(__begin, __end, __gen); }
+ { _GLIBCXX_STD_A::generate(__begin, __end, __gen); }
// Sequential fallback for input iterator case.
template<typename _FIterator, typename _Generator, typename _IteratorTag>
inline _OutputIterator
generate_n(_OutputIterator __begin, _Size __n, _Generator __gen,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::generate_n(__begin, __n, __gen); }
+ { return _GLIBCXX_STD_A::generate_n(__begin, __n, __gen); }
// Sequential fallback for input iterator case.
template<typename _OutputIterator, typename _Size, typename _Generator,
inline void
random_shuffle(_RAIter __begin, _RAIter __end,
__gnu_parallel::sequential_tag)
- { _GLIBCXX_STD_P::random_shuffle(__begin, __end); }
+ { _GLIBCXX_STD_A::random_shuffle(__begin, __end); }
// Sequential fallback.
template<typename _RAIter, typename _RandomNumberGenerator>
random_shuffle(_RAIter __begin, _RAIter __end,
_RandomNumberGenerator& __rand,
__gnu_parallel::sequential_tag)
- { _GLIBCXX_STD_P::random_shuffle(__begin, __end, __rand); }
+ { _GLIBCXX_STD_A::random_shuffle(__begin, __end, __rand); }
/** @brief Functor wrapper for std::rand(). */
inline _FIterator
partition(_FIterator __begin, _FIterator __end,
_Predicate __pred, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::partition(__begin, __end, __pred); }
+ { return _GLIBCXX_STD_A::partition(__begin, __end, __pred); }
// Sequential fallback for input iterator case.
template<typename _FIterator, typename _Predicate, typename _IteratorTag>
inline void
sort(_RAIter __begin, _RAIter __end,
__gnu_parallel::sequential_tag)
- { _GLIBCXX_STD_P::sort(__begin, __end); }
+ { _GLIBCXX_STD_A::sort(__begin, __end); }
// Sequential fallback
template<typename _RAIter, typename _Compare>
inline void
sort(_RAIter __begin, _RAIter __end, _Compare __comp,
__gnu_parallel::sequential_tag)
- { _GLIBCXX_STD_P::sort<_RAIter, _Compare>(__begin, __end,
+ { _GLIBCXX_STD_A::sort<_RAIter, _Compare>(__begin, __end,
__comp); }
// Public interface
inline void
stable_sort(_RAIter __begin, _RAIter __end,
__gnu_parallel::sequential_tag)
- { _GLIBCXX_STD_P::stable_sort(__begin, __end); }
+ { _GLIBCXX_STD_A::stable_sort(__begin, __end); }
// Sequential fallback
template<typename _RAIter, typename _Compare>
inline void
stable_sort(_RAIter __begin, _RAIter __end,
_Compare __comp, __gnu_parallel::sequential_tag)
- { _GLIBCXX_STD_P::stable_sort<_RAIter, _Compare>(
+ { _GLIBCXX_STD_A::stable_sort<_RAIter, _Compare>(
__begin, __end, __comp); }
// Public interface
merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
_IIter2 __end2, _OutputIterator __result,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::merge(
+ { return _GLIBCXX_STD_A::merge(
__begin1, __end1, __begin2, __end2, __result); }
// Sequential fallback
merge(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
_IIter2 __end2, _OutputIterator __result, _Compare __comp,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::merge(
+ { return _GLIBCXX_STD_A::merge(
__begin1, __end1, __begin2, __end2, __result, __comp); }
// Sequential fallback for input iterator case
_IIter2 __begin2, _IIter2 __end2,
_OutputIterator __result, _Compare __comp,
_IteratorTag1, _IteratorTag2, _IteratorTag3)
- { return _GLIBCXX_STD_P::merge(__begin1, __end1, __begin2, __end2,
+ { return _GLIBCXX_STD_A::merge(__begin1, __end1, __begin2, __end2,
__result, __comp); }
// Parallel algorithm for random access iterators
inline void
nth_element(_RAIter __begin, _RAIter __nth,
_RAIter __end, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::nth_element(__begin, __nth, __end); }
+ { return _GLIBCXX_STD_A::nth_element(__begin, __nth, __end); }
// Sequential fallback
template<typename _RAIter, typename _Compare>
nth_element(_RAIter __begin, _RAIter __nth,
_RAIter __end, _Compare __comp,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::nth_element(__begin, __nth, __end, __comp); }
+ { return _GLIBCXX_STD_A::nth_element(__begin, __nth, __end, __comp); }
// Public interface
template<typename _RAIter, typename _Compare>
partial_sort(_RAIter __begin, _RAIter __middle,
_RAIter __end, _Compare __comp,
__gnu_parallel::sequential_tag)
- { _GLIBCXX_STD_P::partial_sort(__begin, __middle, __end, __comp); }
+ { _GLIBCXX_STD_A::partial_sort(__begin, __middle, __end, __comp); }
// Sequential fallback
template<typename _RAIter>
inline void
partial_sort(_RAIter __begin, _RAIter __middle,
_RAIter __end, __gnu_parallel::sequential_tag)
- { _GLIBCXX_STD_P::partial_sort(__begin, __middle, __end); }
+ { _GLIBCXX_STD_A::partial_sort(__begin, __middle, __end); }
// Public interface, parallel algorithm for random access iterators
template<typename _RAIter, typename _Compare>
inline _FIterator
max_element(_FIterator __begin, _FIterator __end,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::max_element(__begin, __end); }
+ { return _GLIBCXX_STD_A::max_element(__begin, __end); }
// Sequential fallback
template<typename _FIterator, typename _Compare>
inline _FIterator
max_element(_FIterator __begin, _FIterator __end, _Compare __comp,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::max_element(__begin, __end, __comp); }
+ { return _GLIBCXX_STD_A::max_element(__begin, __end, __comp); }
// Sequential fallback for input iterator case
template<typename _FIterator, typename _Compare, typename _IteratorTag>
inline _FIterator
min_element(_FIterator __begin, _FIterator __end,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::min_element(__begin, __end); }
+ { return _GLIBCXX_STD_A::min_element(__begin, __end); }
// Sequential fallback
template<typename _FIterator, typename _Compare>
inline _FIterator
min_element(_FIterator __begin, _FIterator __end, _Compare __comp,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::min_element(__begin, __end, __comp); }
+ { return _GLIBCXX_STD_A::min_element(__begin, __end, __comp); }
// Sequential fallback for input iterator case
template<typename _FIterator, typename _Compare, typename _IteratorTag>
#include <parallel/find.h>
#include <parallel/find_selectors.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __parallel
{
inline pair<_IIter1, _IIter2>
mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2); }
+ { return _GLIBCXX_STD_A::mismatch(__begin1, __end1, __begin2); }
// Sequential fallback
template<typename _IIter1, typename _IIter2, typename _Predicate>
inline pair<_IIter1, _IIter2>
mismatch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
_Predicate __pred, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2, __pred); }
+ { return _GLIBCXX_STD_A::mismatch(__begin1, __end1, __begin2, __pred); }
// Sequential fallback for input iterator case
template<typename _IIter1, typename _IIter2,
inline pair<_IIter1, _IIter2>
__mismatch_switch(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
_Predicate __pred, _IteratorTag1, _IteratorTag2)
- { return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2, __pred); }
+ { return _GLIBCXX_STD_A::mismatch(__begin1, __end1, __begin2, __pred); }
// Parallel mismatch for random access iterators
template<typename _RAIter1, typename _RAIter2, typename _Predicate>
return make_pair(__res , __begin2 + (__res - __begin1));
}
else
- return _GLIBCXX_STD_P::mismatch(__begin1, __end1, __begin2, __pred);
+ return _GLIBCXX_STD_A::mismatch(__begin1, __end1, __begin2, __pred);
}
// Public interface
inline bool
equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::equal(__begin1, __end1, __begin2); }
+ { return _GLIBCXX_STD_A::equal(__begin1, __end1, __begin2); }
// Sequential fallback
template<typename _IIter1, typename _IIter2, typename _Predicate>
inline bool
equal(_IIter1 __begin1, _IIter1 __end1, _IIter2 __begin2,
_Predicate __pred, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::equal(__begin1, __end1, __begin2, __pred); }
+ { return _GLIBCXX_STD_A::equal(__begin1, __end1, __begin2, __pred); }
// Public interface
template<typename _IIter1, typename _IIter2>
lexicographical_compare(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::lexicographical_compare(__begin1, __end1,
+ { return _GLIBCXX_STD_A::lexicographical_compare(__begin1, __end1,
__begin2, __end2); }
// Sequential fallback
lexicographical_compare(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
_Predicate __pred, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::lexicographical_compare(
+ { return _GLIBCXX_STD_A::lexicographical_compare(
__begin1, __end1, __begin2, __end2, __pred); }
// Sequential fallback for input iterator case
_IIter2 __begin2, _IIter2 __end2,
_Predicate __pred,
_IteratorTag1, _IteratorTag2)
- { return _GLIBCXX_STD_P::lexicographical_compare(
+ { return _GLIBCXX_STD_A::lexicographical_compare(
__begin1, __end1, __begin2, __end2, __pred); }
// Parallel lexicographical_compare for random access iterators
}
}
else
- return _GLIBCXX_STD_P::lexicographical_compare(
+ return _GLIBCXX_STD_A::lexicographical_compare(
__begin1, __end1, __begin2, __end2, __pred);
}
#include <parallel/tags.h>
#include <parallel/settings.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __parallel
{
// -*- C++ -*-
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the terms
* @namespace std::__parallel
* @brief GNU parallel code, replaces standard behavior with parallel behavior.
*/
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __parallel { }
}
{
// Import whatever is the serial version.
#ifdef _GLIBCXX_PARALLEL
- using namespace std::__norm;
+ using namespace std::_GLIBCXX_STD_A;
#else
using namespace std;
#endif
#include <parallel/for_each_selectors.h>
#include <parallel/partial_sum.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __parallel
{
inline _Tp
accumulate(_IIter __begin, _IIter __end, _Tp __init,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::accumulate(__begin, __end, __init); }
+ { return _GLIBCXX_STD_A::accumulate(__begin, __end, __init); }
template<typename _IIter, typename _Tp, typename _BinaryOperation>
inline _Tp
accumulate(_IIter __begin, _IIter __end, _Tp __init,
_BinaryOperation __binary_op, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::accumulate(__begin, __end, __init, __binary_op); }
+ { return _GLIBCXX_STD_A::accumulate(__begin, __end, __init, __binary_op); }
// Sequential fallback for input iterator case.
template<typename _IIter, typename _Tp, typename _IteratorTag>
inner_product(_IIter1 __first1, _IIter1 __last1,
_IIter2 __first2, _Tp __init,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::inner_product(
+ { return _GLIBCXX_STD_A::inner_product(
__first1, __last1, __first2, __init); }
template<typename _IIter1, typename _IIter2, typename _Tp,
_IIter2 __first2, _Tp __init, _BinaryFunction1 __binary_op1,
_BinaryFunction2 __binary_op2,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::inner_product(__first1, __last1, __first2, __init,
+ { return _GLIBCXX_STD_A::inner_product(__first1, __last1, __first2, __init,
__binary_op1, __binary_op2); }
// Parallel algorithm for random access iterators.
inline _OutputIterator
partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::partial_sum(__begin, __end, __result); }
+ { return _GLIBCXX_STD_A::partial_sum(__begin, __end, __result); }
// Sequential fallback.
template<typename _IIter, typename _OutputIterator,
inline _OutputIterator
partial_sum(_IIter __begin, _IIter __end, _OutputIterator __result,
_BinaryOperation __bin_op, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::partial_sum(__begin, __end, __result, __bin_op); }
+ { return _GLIBCXX_STD_A::partial_sum(__begin, __end, __result, __bin_op); }
// Sequential fallback for input iterator case.
template<typename _IIter, typename _OutputIterator,
__partial_sum_switch(_IIter __begin, _IIter __end,
_OutputIterator __result, _BinaryOperation __bin_op,
_IteratorTag1, _IteratorTag2)
- { return _GLIBCXX_STD_P::partial_sum(__begin, __end, __result, __bin_op); }
+ { return _GLIBCXX_STD_A::partial_sum(__begin, __end, __result, __bin_op); }
// Parallel algorithm for random access iterators.
template<typename _IIter, typename _OutputIterator,
inline _OutputIterator
adjacent_difference(_IIter __begin, _IIter __end, _OutputIterator __result,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::adjacent_difference(__begin, __end, __result); }
+ { return _GLIBCXX_STD_A::adjacent_difference(__begin, __end, __result); }
// Sequential fallback.
template<typename _IIter, typename _OutputIterator,
adjacent_difference(_IIter __begin, _IIter __end,
_OutputIterator __result, _BinaryOperation __bin_op,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_P::adjacent_difference(__begin, __end,
+ { return _GLIBCXX_STD_A::adjacent_difference(__begin, __end,
__result, __bin_op); }
// Sequential fallback for input iterator case.
#include <parallel/tags.h>
#include <parallel/settings.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __parallel
{
* @namespace std::__profile
* @brief GNU profile code, replaces standard behavior with profile behavior.
*/
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile { }
}
#include <bitset>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
/// Class std::bitset wrapper with performance instrumentation.
template<size_t _Nb>
class bitset
- : public _GLIBCXX_STD_D::bitset<_Nb>
+ : public _GLIBCXX_STD_C::bitset<_Nb>
{
- typedef _GLIBCXX_STD_D::bitset<_Nb> _Base;
+ typedef _GLIBCXX_STD_C::bitset<_Nb> _Base;
public:
// bit reference:
{
size_t
operator()(const __profile::bitset<_Nb>& __b) const
- { return std::hash<_GLIBCXX_STD_D::bitset<_Nb>>()(__b._M_base()); }
+ { return std::hash<_GLIBCXX_STD_C::bitset<_Nb>>()(__b._M_base()); }
};
#endif
#include <deque>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
/// Class std::deque wrapper with performance instrumentation.
template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
class deque
- : public _GLIBCXX_STD_D::deque<_Tp, _Allocator>
+ : public _GLIBCXX_STD_C::deque<_Tp, _Allocator>
{
- typedef _GLIBCXX_STD_D::deque<_Tp, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::deque<_Tp, _Allocator> _Base;
public:
typedef typename _Base::reference reference;
#include <forward_list>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
/// Class std::forward_list wrapper with performance instrumentation.
template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
class forward_list
- : public _GLIBCXX_STD_D::forward_list<_Tp, _Alloc>
+ : public _GLIBCXX_STD_C::forward_list<_Tp, _Alloc>
{
- typedef _GLIBCXX_STD_D::forward_list<_Tp, _Alloc> _Base;
+ typedef _GLIBCXX_STD_C::forward_list<_Tp, _Alloc> _Base;
public:
typedef typename _Base::size_type size_type;
{
typedef const void* __object_t;
typedef void* __instruction_address_t;
- typedef std::_GLIBCXX_STD_PR::vector<__instruction_address_t> __stack_npt;
+ typedef std::_GLIBCXX_STD_C::vector<__instruction_address_t> __stack_npt;
typedef __stack_npt* __stack_t;
std::size_t __stack_max_depth();
#include <cstdlib> // atof, atoi, strtol, getenv, atexit, abort
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-#define _GLIBCXX_IMPL_UNORDERED_MAP std::_GLIBCXX_STD_PR::unordered_map
+#define _GLIBCXX_IMPL_UNORDERED_MAP std::_GLIBCXX_STD_C::unordered_map
#include <unordered_map>
#else
#include <tr1/unordered_map>
{ return __magnitude < __other.__magnitude; }
};
- typedef std::_GLIBCXX_STD_PR::vector<__warning_data> __warning_vector_t;
+ typedef std::_GLIBCXX_STD_C::vector<__warning_data> __warning_vector_t;
// Defined in profiler_<diagnostic name>.h.
class __trace_hash_func;
float __value;
};
- typedef std::_GLIBCXX_STD_PR::vector<__cost_factor*> __cost_factor_vector;
+ typedef std::_GLIBCXX_STD_C::vector<__cost_factor*> __cost_factor_vector;
_GLIBCXX_PROFILE_DEFINE_DATA(__trace_hash_func*, _S_hash_func, 0);
_GLIBCXX_PROFILE_DEFINE_DATA(__trace_hashtable_size*, _S_hashtable_size, 0);
#include <ext/type_traits.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
#include <profile/base.h>
#include <profile/iterator_tracker.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
/** @brief List wrapper with performance instrumentation. */
template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
class list
- : public _GLIBCXX_STD_D::list<_Tp, _Allocator>
+ : public _GLIBCXX_STD_C::list<_Tp, _Allocator>
{
- typedef _GLIBCXX_STD_D::list<_Tp, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::list<_Tp, _Allocator> _Base;
public:
typedef typename _Base::reference reference;
#include <utility>
#include <profile/base.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
class map
- : public _GLIBCXX_STD_D::map<_Key, _Tp, _Compare, _Allocator>
+ : public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>
{
- typedef _GLIBCXX_STD_D::map<_Key, _Tp, _Compare, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator> _Base;
public:
// types:
#include <utility>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
class multimap
- : public _GLIBCXX_STD_D::multimap<_Key, _Tp, _Compare, _Allocator>
+ : public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator>
{
- typedef _GLIBCXX_STD_D::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
public:
// types:
#include <utility>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
template<typename _Key, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<_Key> >
class multiset
- : public _GLIBCXX_STD_D::multiset<_Key, _Compare, _Allocator>
+ : public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>
{
- typedef _GLIBCXX_STD_D::multiset<_Key, _Compare, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator> _Base;
public:
// types:
#include <utility>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
template<typename _Key, typename _Compare = std::less<_Key>,
typename _Allocator = std::allocator<_Key> >
class set
- : public _GLIBCXX_STD_D::set<_Key,_Compare,_Allocator>
+ : public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>
{
- typedef _GLIBCXX_STD_D::set<_Key, _Compare, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::set<_Key, _Compare, _Allocator> _Base;
public:
// types:
#include <profile/base.h>
#define _GLIBCXX_BASE unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
-#define _GLIBCXX_STD_BASE _GLIBCXX_STD_PR::_GLIBCXX_BASE
+#define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
#undef _GLIBCXX_BASE
#undef _GLIBCXX_STD_BASE
#define _GLIBCXX_BASE unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
-#define _GLIBCXX_STD_BASE _GLIBCXX_STD_PR::_GLIBCXX_BASE
+#define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE
/// Class std::unordered_multimap wrapper with performance instrumentation.
template<typename _Key, typename _Tp,
#include <profile/base.h>
#define _GLIBCXX_BASE unordered_set<_Key, _Hash, _Pred, _Alloc>
-#define _GLIBCXX_STD_BASE _GLIBCXX_STD_PR::_GLIBCXX_BASE
+#define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
#undef _GLIBCXX_BASE
#undef _GLIBCXX_STD_BASE
-#define _GLIBCXX_STD_BASE _GLIBCXX_STD_PR::_GLIBCXX_BASE
+#define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE
#define _GLIBCXX_BASE unordered_multiset<_Value, _Hash, _Pred, _Alloc>
/** @brief Unordered_multiset wrapper with performance instrumentation. */
#include <profile/base.h>
#include <profile/iterator_tracker.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
template<typename _Tp,
typename _Allocator = std::allocator<_Tp> >
class vector
- : public _GLIBCXX_STD_PR::vector<_Tp, _Allocator>
+ : public _GLIBCXX_STD_C::vector<_Tp, _Allocator>
{
- typedef _GLIBCXX_STD_PR::vector<_Tp, _Allocator> _Base;
+ typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base;
public:
typedef typename _Base::reference reference;
{
size_t
operator()(const __profile::vector<bool, _Alloc>& __b) const
- { return std::hash<_GLIBCXX_STD_D::vector<bool, _Alloc>>()
+ { return std::hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>()
(__b._M_base()); }
};
#endif
#include <bits/stl_algobase.h>
#include <bits/range_access.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief A standard container for storing a fixed size sequence of elements.
get(const array<_Tp, _Nm>& __arr)
{ return __arr[_Int]; }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // __GXX_EXPERIMENTAL_CXX0X__
#include <bits/atomic_0.h>
#include <bits/atomic_2.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup atomics
// @} group atomics
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
((__n) / _GLIBCXX_BITSET_BITS_PER_WORD + \
((__n) % _GLIBCXX_BITSET_BITS_PER_WORD == 0 ? 0 : 1))
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/**
* Base class, general case. It is a class invariant that _Nw will be
}
//@}
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_CONTAINER
+} // namespace std
#undef _GLIBCXX_BITSET_WORDS
#undef _GLIBCXX_BITSET_BITS_PER_WORD
#include <bits/functional_hash.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// DR 1182.
/// std::hash specialization for bitset.
template<size_t _Nb>
- struct hash<_GLIBCXX_STD_D::bitset<_Nb>>
- : public __hash_base<size_t, _GLIBCXX_STD_D::bitset<_Nb>>
+ struct hash<_GLIBCXX_STD_C::bitset<_Nb>>
+ : public __hash_base<size_t, _GLIBCXX_STD_C::bitset<_Nb>>
{
size_t
- operator()(const _GLIBCXX_STD_D::bitset<_Nb>& __b) const
+ operator()(const _GLIBCXX_STD_C::bitset<_Nb>& __b) const
{
const size_t __clength = (_Nb + __CHAR_BIT__ - 1) / __CHAR_BIT__;
return std::_Hash_impl::hash(__b._M_getdata(), __clength);
};
template<>
- struct hash<_GLIBCXX_STD_D::bitset<0>>
- : public __hash_base<size_t, _GLIBCXX_STD_D::bitset<0>>
+ struct hash<_GLIBCXX_STD_C::bitset<0>>
+ : public __hash_base<size_t, _GLIBCXX_STD_C::bitset<0>>
{
size_t
- operator()(const _GLIBCXX_STD_D::bitset<0>&) const
+ operator()(const _GLIBCXX_STD_C::bitset<0>&) const
{ return 0; }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // __GXX_EXPERIMENTAL_CXX0X__
#ifdef _GLIBCXX_USE_C99_STDINT_TR1
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std _GLIBCXX_VISIBILITY(default)
+{
/**
* @defgroup chrono Time
* @ingroup utilities
*/
namespace chrono
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
template<typename _Rep, typename _Period = ratio<1>>
struct duration;
template<typename _Clock, typename _Dur = typename _Clock::duration>
struct time_point;
+
+ _GLIBCXX_END_NAMESPACE_VERSION
}
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// 20.8.2.3 specialization of common_type (for duration)
template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
struct common_type<chrono::duration<_Rep1, _Period1>,
public:
typedef chrono::time_point<_Clock, __ct> type;
};
+_GLIBCXX_END_NAMESPACE_VERSION
namespace chrono
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
// Primary template for duration_cast impl.
template<typename _ToDur, typename _CF, typename _CR,
bool _NumIsOne = false, bool _DenIsOne = false>
template<typename _Rep, typename _Period>
struct duration
{
- typedef _Rep rep;
+ typedef _Rep rep;
typedef _Period period;
static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
#elif defined(_GLIBCXX_USE_GETTIMEOFDAY)
typedef chrono::microseconds duration;
#else
- typedef chrono::seconds duration;
+ typedef chrono::seconds duration;
#endif
typedef duration::rep rep;
struct monotonic_clock
{
typedef chrono::nanoseconds duration;
- typedef duration::rep rep;
- typedef duration::period period;
+ typedef duration::rep rep;
+ typedef duration::period period;
typedef chrono::time_point<monotonic_clock, duration> time_point;
static constexpr bool is_monotonic = true;
#endif
typedef system_clock high_resolution_clock;
+
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace chrono
// @} group chrono
-_GLIBCXX_END_NAMESPACE
+} // namespace
#endif //_GLIBCXX_USE_C99_STDINT_TR1
#include <cmath>
#include <sstream>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @defgroup complex_numbers Complex Numbers
// @} group complex_numbers
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// See ext/type_traits.h for the primary template.
template<typename _Tp, typename _Up>
typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Forward declarations.
template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
conj(_Tp __x)
{ return __x; }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // __GXX_EXPERIMENTAL_CXX0X__
#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @defgroup condition_variables Condition Variables
};
// @} group condition_variables
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
#include <string> // For std::string overloads.
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// [27.8.1.1] template class basic_filebuf
/**
}
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/fstream.tcc>
// <functional> -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
-// Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+// 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <bits/functexcept.h>
#include <bits/functional_hash.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_HAS_NESTED_TYPE(result_type)
/// The type of placeholder objects defined by libstdc++.
template<int _Num> struct _Placeholder { };
+ _GLIBCXX_END_NAMESPACE_VERSION
+
/** @namespace std::placeholders
* @brief ISO C++ 0x entities sub namespace for functional.
* @ingroup binders
*/
namespace placeholders
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
extern const _Placeholder<1> _1;
extern const _Placeholder<2> _2;
extern const _Placeholder<3> _3;
extern const _Placeholder<27> _27;
extern const _Placeholder<28> _28;
extern const _Placeholder<29> _29;
+ _GLIBCXX_END_NAMESPACE_VERSION
}
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* Partial specialization of is_placeholder that provides the placeholder
* number for the placeholder objects defined by libstdc++.
swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y)
{ __x.swap(__y); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
#endif // __GXX_EXPERIMENTAL_CXX0X__
#include <atomic>
#include <bits/functexcept.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @defgroup futures Futures
// && _GLIBCXX_ATOMIC_BUILTINS_4
// @} group futures
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // __GXX_EXPERIMENTAL_CXX0X__
#include <locale>
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// [27.6.3] standard manipulators
// Also see DR 183.
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _GLIBCXX_IOMANIP */
#include <bits/stringfwd.h> // For string forward declarations.
#include <bits/postypes.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @defgroup io I/O
#endif
/** @} */
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _GLIBCXX_IOSFWD */
#include <ostream>
#include <istream>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @name Standard Stream Objects
// For construction of filebuffers for cout, cin, cerr, clog et. al.
static ios_base::Init __ioinit;
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _GLIBCXX_IOSTREAM */
#include <ios>
#include <ostream>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// [27.6.1.1] Template class basic_istream
/**
{ return (__is >> __x); }
#endif // __GXX_EXPERIMENTAL_CXX0X__
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/istream.tcc>
#define __glibcxx_max_digits10(T) \
(2 + (T) * 643L / 2136)
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Describes the rounding style for floating-point types.
#undef __glibcxx_long_double_traps
#undef __glibcxx_long_double_tinyness_before
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#undef __glibcxx_signed
#undef __glibcxx_min
#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @defgroup mutexes Mutexes
}
// @} group mutexes
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
#include <ios>
#include <bits/ostream_insert.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// [27.6.2.1] Template class basic_ostream
/**
{ return (__os << __x); }
#endif // __GXX_EXPERIMENTAL_CXX0X__
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/ostream.tcc>
#ifdef _GLIBCXX_USE_C99_STDINT_TR1
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @defgroup ratio Rational Arithmetic
typedef ratio< 1000000000000000000, 1> exa;
// @} group ratio
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif //_GLIBCXX_USE_C99_STDINT_TR1
#include <istream>
#include <ostream>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// [27.7.1] template class basic_stringbuf
/**
{ _M_stringbuf.str(__s); }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/sstream.tcc>
#include <exception>
#include <string>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup exceptions
// @} group exceptions
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _GLIBCXX_STDEXCEPT */
#include <bits/cpp_type_traits.h>
#include <ext/type_traits.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits>
streamsize
basic_streambuf<wchar_t>* __sbout, bool& __ineof);
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/streambuf.tcc>
#include <iosfwd>
#include <stdexcept>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
class error_code;
class error_condition;
code() const throw() { return _M_code; }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#ifndef _GLIBCXX_COMPATIBILITY_CXX0X
#include <bits/functional_hash.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// DR 1182.
/// std::hash specialization for error_code.
}
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // _GLIBCXX_COMPATIBILITY_CXX0X
// <thread> -*- C++ -*-
-// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @defgroup threads Threads
return __out << __id._M_thread;
}
+_GLIBCXX_END_NAMESPACE_VERSION
+
/** @namespace std::this_thread
* @brief ISO C++ 0x entities sub namespace for thread.
* 30.2.2 Namespace this_thread.
*/
namespace this_thread
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/// get_id
inline thread::id
get_id() { return thread::id(__gthread_self()); }
::nanosleep(&__ts, 0);
}
#endif
+
+ _GLIBCXX_END_NAMESPACE_VERSION
}
// @} group threads
-_GLIBCXX_END_NAMESPACE
+
+} // namespace
#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
#include <utility>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Adds a const reference to a non-reference type.
template<typename _Tp>
const _Index_tuple<_Indexes...>&)
{ return _Tp(std::forward<_Args>(get<_Indexes>(__tuple))...); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // __GXX_EXPERIMENTAL_CXX0X__
#include <bits/c++config.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup metaprogramming
#undef _DEFINE_SPEC
// @} group metaprogramming
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // __GXX_EXPERIMENTAL_CXX0X__
#include <typeinfo>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
@brief The class type_index provides a simple wrapper for type_info
{ return __ti.hash_code(); }
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // __GXX_EXPERIMENTAL_CXX0X__
#include <bits/move.h>
#include <initializer_list>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<class _Tp>
class tuple_size;
get(const std::pair<_Tp1, _Tp2>& __in)
{ return __pair_get<_Int>::__const_get(__in); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
#include <debug/debug.h>
#include <initializer_list>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<class _Clos, typename _Tp>
class _Expr;
template<class _Tp> class mask_array; // masked array
template<class _Tp> class indirect_array; // indirected array
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/valarray_array.h>
#include <bits/valarray_before.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @defgroup numeric_arrays Numeric Arrays
// @} group numeric_arrays
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/valarray_after.h>
#include <bits/slice_array.h>
#include <bits/mask_array.h>
#include <bits/indirect_array.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @addtogroup numeric_arrays
// @} group numeric_arrays
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif /* _GLIBCXX_VALARRAY */
#include <bits/stl_algobase.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* @brief A standard container for storing a fixed size sequence of elements.
*
inline const _Tp&
get(const array<_Tp, _Nm>& __arr)
{ return __arr[_Int]; }
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
#include "special_function_util.h"
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
-
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Compute the gamma functions required by the Temme series
* @param __x The argument of the spherical Bessel function.
* @param __j_n The output spherical Bessel function.
* @param __n_n The output spherical Neumann function.
- * @param __jp_n The output derivative of the spherical Bessel function.
- * @param __np_n The output derivative of the spherical Neumann function.
+ * @param __jp_n The output derivative of the spherical Bessel function.
+ * @param __np_n The output derivative of the spherical Neumann function.
*/
template <typename _Tp>
void
}
}
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#ifndef _GLIBCXX_TR1_BETA_FUNCTION_TCC
#define _GLIBCXX_TR1_BETA_FUNCTION_TCC 1
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
-
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Return the beta function: \f$B(x,y)\f$.
return __beta_lgamma(__x, __y);
}
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#undef isblank
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
#undef fesetenv
#undef feupdateenv
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
#ifdef _GLIBCXX_USE_C99_INTTYPES_TR1
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
#endif
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#if _GLIBCXX_USE_C99_MATH_TR1
// types
}
#endif
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
// DR 550. What should the return type of pow(float,int) be?
// NB: C++0x and TR1 != C++03.
inline double
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
return std::pow(__type(__x), __type(__y));
}
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
#include <tr1/poly_laguerre.tcc>
#include <tr1/riemann_zeta.tcc>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* @defgroup tr1_math_spec_func Mathematical Special Functions
* @ingroup numerics
}
/* @} */ // tr1_math_spec_func
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
#include <complex>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* @addtogroup complex_numbers
* @{
{ return std::pow(__x, __y); }
// @} group complex_numbers
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
#ifdef _GLIBCXX_USE_C99_STDINT_TR1
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
#if _GLIBCXX_USE_C99
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
#if _GLIBCXX_USE_C99
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
#ifdef _GLIBCXX_USE_WCHAR_T
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
#ifdef _GLIBCXX_USE_WCHAR_T
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
#ifndef _GLIBCXX_TR1_ELL_INTEGRAL_TCC
#define _GLIBCXX_TR1_ELL_INTEGRAL_TCC 1
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
-
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Return the Carlson elliptic function @f$ R_F(x,y,z) @f$
}
}
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#include "special_function_util.h"
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
-
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Return the exponential integral @f$ E_1(x) @f$
return __expint_Ei(__x);
}
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
// TR1 functional header -*- C++ -*-
-// Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010
+// Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
#include <ext/type_traits.h>
#include <bits/move.h> // for std::__addressof
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
template<typename _MemberPointer>
class _Mem_fn;
/// The type of placeholder objects defined by libstdc++.
template<int _Num> struct _Placeholder { };
+_GLIBCXX_END_NAMESPACE_VERSION
+
/** @namespace std::placeholders
* @brief ISO C++ 0x entities sub namespace for functional.
*
*/
namespace placeholders
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace
{
_Placeholder<1> _1;
_Placeholder<28> _28;
_Placeholder<29> _29;
}
+ _GLIBCXX_END_NAMESPACE_VERSION
}
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* Partial specialization of is_placeholder that provides the placeholder
* number for the placeholder objects defined by libstdc++.
inline void
swap(function<_Signature>& __x, function<_Signature>& __y)
{ __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
#pragma GCC system_header
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/// Class template hash.
// Declaration of default hash functor std::tr1::hash. The types for
// which std::tr1::hash<T> is well-defined is in clause 6.3.3. of the PDTR.
_GLIBCXX_PURE size_t
hash<const wstring&>::operator()(const wstring&) const;
#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
#include "special_function_util.h"
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// Implementation-space details.
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief This returns Bernoulli numbers from a table or by summation
}
}
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
// TR1 hashtable.h header -*- C++ -*-
-// Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <tr1/hashtable_policy.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
// Class template _Hashtable, class definition.
// Meaning of class template _Hashtable's template parameters
__throw_exception_again;
}
}
-}
-}
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace tr1
+} // namespace std
#endif // _GLIBCXX_TR1_HASHTABLE_H
// Internal policy header for TR1 unordered_set and unordered_map -*- C++ -*-
-// Copyright (C) 2010 Free Software Foundation, Inc.
+// Copyright (C) 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
* @headername{tr1/unordered_map, tr1/unordered_set}
*/
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
namespace __detail
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
// Helper function: return distance(first, last) for forward
// iterators, or 0 for input iterators.
template<class _Iterator>
_H1 _M_h1;
_H2 _M_h2;
};
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
}
}
#ifndef _GLIBCXX_TR1_HYPERGEOMETRIC_TCC
#define _GLIBCXX_TR1_HYPERGEOMETRIC_TCC 1
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
-
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief This routine returns the confluent hypergeometric function
return __hyperg_luke(__a, __b, __c, __x);
}
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#include "special_function_util.h"
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
-
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Return the Legendre polynomial by recursion on order
}
}
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#include "special_function_util.h"
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
-
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Compute the modified Bessel functions @f$ I_\nu(x) @f$ and
return;
}
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#ifndef _GLIBCXX_TR1_POLY_HERMITE_TCC
#define _GLIBCXX_TR1_POLY_HERMITE_TCC 1
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
-
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief This routine returns the Hermite polynomial
return __poly_hermite_recursion(__n, __x);
}
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#ifndef _GLIBCXX_TR1_POLY_LAGUERRE_TCC
#define _GLIBCXX_TR1_POLY_LAGUERRE_TCC 1
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
-
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
-
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief This routine returns the associated Laguerre polynomial
return __poly_laguerre<unsigned int, _Tp>(__n, 0, __x);
}
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#pragma GCC system_header
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
*/
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
template<typename _UIntType, int __w,
bool = __w < std::numeric_limits<_UIntType>::digits>
struct _Shift
private:
_Engine* _M_g;
};
+
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* Produces random numbers on a given distribution function using a
* non-uniform random number generation engine.
/* @} */ // group tr1_random_distributions_continuous
/* @} */ // group tr1_random_distributions
/* @} */ // group tr1_random
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
#ifndef _GLIBCXX_TR1_RANDOM_TCC
#define _GLIBCXX_TR1_RANDOM_TCC 1
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
*/
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
// General case for x = (ax + c) mod m -- use Schrage's algorithm to avoid
// integer overflow.
//
__calc(_Tp __x)
{ return __a * __x + __c; }
};
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
const _UIntType
__os.precision(__precision);
return __os;
}
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
#include <utility>
#include <sstream>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
*/
namespace regex_constants
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* @name 5.1 Regular Expression Syntax Options
*/
static const error_type error_stack(_S_error_stack);
//@}
+_GLIBCXX_END_NAMESPACE_VERSION
}
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// [7.8] Class regex_error
/**
/**
* @name 10.4 Formatting
*
- * These functions perform formatted substitution of the matched character
- * sequences into their target. The format specifiers and escape sequences
- * accepted by these functions are determined by their @p flags parameter
- * as documented above.
+ * These functions perform formatted substitution of the matched
+ * character sequences into their target. The format specifiers
+ * and escape sequences accepted by these functions are
+ * determined by their @p flags parameter as documented above.
*/
//@{
#endif
//@}
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
#include "special_function_util.h"
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
-
// [5.2] Special functions
// Implementation-space details.
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Compute the Riemann zeta function @f$ \zeta(s) @f$
return __hurwitz_zeta_glob(__a, __s);
}
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace std::tr1::__detail
}
}
#ifndef _TR1_SHARED_PTR_H
#define _TR1_SHARED_PTR_H 1
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* @brief Exception possibly thrown by @c shared_ptr.
* @ingroup exceptions
mutable weak_ptr<_Tp> _M_weak_this;
};
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
#ifndef _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H
#define _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H 1
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
-
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// A class to encapsulate type dependent floating point
/// constants. Not everything will be able to be expressed as
#endif
+ _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
-
}
}
#include <utility>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
// Adds a const reference to a non-reference type.
template<typename _Tp>
struct __add_c_ref
{
_Swallow_assign ignore;
}; // anonymous namespace
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
#include <bits/c++config.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* @defgroup metaprogramming Type Traits
* @ingroup utilities
#undef _DEFINE_SPEC_1_HELPER
#undef _DEFINE_SPEC_2_HELPER
#undef _DEFINE_SPEC
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
* Do not attempt to use it directly. @headername{tr1/unordered_map}
*/
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
- // XXX When we get typedef templates these class definitions
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ // NB: When we get typedef templates these class definitions
// will be unnecessary.
template<class _Key, class _Tp,
class _Hash = hash<_Key>,
swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
* Do not attempt to use it directly. @headername{tr1/unordered_set}
*/
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
- // XXX When we get typedef templates these class definitions
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ // NB: When we get typedef templates these class definitions
// will be unnecessary.
template<class _Value,
class _Hash = hash<_Value>,
swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
{ __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
// TR1 utility -*- C++ -*-
-// Copyright (C) 2004, 2005, 2006, 2007, 2008. 2009, 2010
+// Copyright (C) 2004, 2005, 2006, 2007, 2008. 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
#include <bits/stl_relops.h>
#include <bits/stl_pair.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
template<class _Tp>
class tuple_size;
inline const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
get(const std::pair<_Tp1, _Tp2>& __in)
{ return __pair_get<_Int>::__const_get(__in); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
}
#if !_GLIBCXX_HOSTED
// A freestanding C runtime may not provide "free" -- but there is no
// other reasonable way to implement "operator delete".
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
extern "C" void free(void*);
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#else
# include <cstdlib>
#endif
// @} group exceptions
} // namespace std
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief A replacement for the standard terminate_handler which
*/
void __verbose_terminate_handler();
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
} // extern "C++"
#endif
}
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
#if __SIZEOF_SIZE_T__ == 4
#endif /* __SIZEOF_SIZE_T__ */
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <bits/c++config.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Hash function implementation for the nontrivial specialization.
// All of them are based on a primitive that hashes a pointer to a
size_t
_Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
using namespace std;
using namespace abi;
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// A replacement for the standard terminate_handler which prints
// more information about the terminating exception (if any) on
abort();
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
$(LN_S) ${glibcxx_srcdir}/$(BASIC_FILE_CC) ./$@ || true
if ENABLE_PARALLEL
-parallel_sources = parallel_list.cc parallel_settings.cc \
- compatibility-parallel_list.cc
+parallel_sources = parallel_settings.cc \
+ compatibility-parallel_list.cc \
+ compatibility-parallel_list-2.cc
else
parallel_sources =
endif
compatibility.cc \
compatibility-c++0x.cc \
compatibility-debug_list.cc \
+ compatibility-debug_list-2.cc \
compatibility-list.cc \
+ compatibility-list-2.cc \
complex_io.cc \
ctype.cc \
debug.cc \
ios_locale.cc \
limits.cc \
list.cc \
- debug_list.cc \
locale.cc \
locale_init.cc \
locale_facets.cc \
# Use special rules for parallel mode compilation.
PARALLEL_FLAGS = -fopenmp -D_GLIBCXX_PARALLEL -I$(glibcxx_builddir)/../libgomp
-parallel_list.lo: parallel_list.cc
- $(LTCXXCOMPILE) $(PARALLEL_FLAGS) -c $<
-parallel_list.o: parallel_list.cc
- $(CXXCOMPILE) $(PARALLEL_FLAGS) -c $<
-
parallel_settings.lo: parallel_settings.cc
$(LTCXXCOMPILE) $(PARALLEL_FLAGS) -c $<
parallel_settings.o: parallel_settings.cc
$(CXXCOMPILE) $(PARALLEL_FLAGS) -c $<
compatibility-parallel_list.lo: compatibility-parallel_list.cc
- $(LTCXXCOMPILE) $(PARALLEL_FLAGS) -c $<
+ $(LTCXXCOMPILE) -c $<
compatibility-parallel_list.o: compatibility-parallel_list.cc
- $(CXXCOMPILE) $(PARALLEL_FLAGS) -c $<
+ $(CXXCOMPILE) -c $<
+
+compatibility-parallel_list-2.lo: compatibility-parallel_list-2.cc
+ $(LTCXXCOMPILE) -c $<
+compatibility-parallel_list-2.o: compatibility-parallel_list-2.cc
+ $(CXXCOMPILE) -c $<
# Use special rules for the C++0x sources so that the proper flags are passed.
functexcept.lo: functexcept.cc
ctype_members.lo messages_members.lo monetary_members.lo \
numeric_members.lo time_members.lo
@GLIBCXX_LDBL_COMPAT_TRUE@am__objects_2 = compatibility-ldbl.lo
-@ENABLE_PARALLEL_TRUE@am__objects_3 = parallel_list.lo \
-@ENABLE_PARALLEL_TRUE@ parallel_settings.lo \
-@ENABLE_PARALLEL_TRUE@ compatibility-parallel_list.lo
+@ENABLE_PARALLEL_TRUE@am__objects_3 = parallel_settings.lo \
+@ENABLE_PARALLEL_TRUE@ compatibility-parallel_list.lo \
+@ENABLE_PARALLEL_TRUE@ compatibility-parallel_list-2.lo
am__objects_4 = basic_file.lo c++locale.lo $(am__objects_2) \
$(am__objects_3)
am__objects_5 = atomic.lo bitmap_allocator.lo pool_allocator.lo \
mt_allocator.lo codecvt.lo compatibility.lo \
compatibility-c++0x.lo compatibility-debug_list.lo \
- compatibility-list.lo complex_io.lo ctype.lo debug.lo \
+ compatibility-debug_list-2.lo compatibility-list.lo \
+ compatibility-list-2.lo complex_io.lo ctype.lo debug.lo \
functexcept.lo globals_io.lo hash_c++0x.lo hash_tr1.lo \
hashtable_c++0x.lo hashtable_tr1.lo ios.lo ios_failure.lo \
- ios_init.lo ios_locale.lo limits.lo list.lo debug_list.lo \
- locale.lo locale_init.lo locale_facets.lo localename.lo \
+ ios_init.lo ios_locale.lo limits.lo list.lo locale.lo \
+ locale_init.lo locale_facets.lo localename.lo \
math_stubs_float.lo math_stubs_long_double.lo stdexcept.lo \
strstream.lo system_error.lo tree.lo allocator-inst.lo \
concept-inst.lo fstream-inst.lo ext-inst.lo ios-inst.lo \
basic_file.cc c++locale.cc ${ldbl_compat_sources} ${parallel_sources}
@ENABLE_PARALLEL_FALSE@parallel_sources =
-@ENABLE_PARALLEL_TRUE@parallel_sources = parallel_list.cc parallel_settings.cc \
-@ENABLE_PARALLEL_TRUE@ compatibility-parallel_list.cc
+@ENABLE_PARALLEL_TRUE@parallel_sources = parallel_settings.cc \
+@ENABLE_PARALLEL_TRUE@ compatibility-parallel_list.cc \
+@ENABLE_PARALLEL_TRUE@ compatibility-parallel_list-2.cc
@GLIBCXX_LDBL_COMPAT_FALSE@ldbl_compat_sources =
@GLIBCXX_LDBL_COMPAT_TRUE@ldbl_compat_sources = compatibility-ldbl.cc
compatibility.cc \
compatibility-c++0x.cc \
compatibility-debug_list.cc \
+ compatibility-debug_list-2.cc \
compatibility-list.cc \
+ compatibility-list-2.cc \
complex_io.cc \
ctype.cc \
debug.cc \
ios_locale.cc \
limits.cc \
list.cc \
- debug_list.cc \
locale.cc \
locale_init.cc \
locale_facets.cc \
$(LTCXXCOMPILE) -D_GLIBCXX_CONCEPT_CHECKS -fimplicit-templates -c $<
concept-inst.o: concept-inst.cc
$(CXXCOMPILE) -D_GLIBCXX_CONCEPT_CHECKS -fimplicit-templates -c $<
-parallel_list.lo: parallel_list.cc
- $(LTCXXCOMPILE) $(PARALLEL_FLAGS) -c $<
-parallel_list.o: parallel_list.cc
- $(CXXCOMPILE) $(PARALLEL_FLAGS) -c $<
-
parallel_settings.lo: parallel_settings.cc
$(LTCXXCOMPILE) $(PARALLEL_FLAGS) -c $<
parallel_settings.o: parallel_settings.cc
$(CXXCOMPILE) $(PARALLEL_FLAGS) -c $<
compatibility-parallel_list.lo: compatibility-parallel_list.cc
- $(LTCXXCOMPILE) $(PARALLEL_FLAGS) -c $<
+ $(LTCXXCOMPILE) -c $<
compatibility-parallel_list.o: compatibility-parallel_list.cc
- $(CXXCOMPILE) $(PARALLEL_FLAGS) -c $<
+ $(CXXCOMPILE) -c $<
+
+compatibility-parallel_list-2.lo: compatibility-parallel_list-2.cc
+ $(LTCXXCOMPILE) -c $<
+compatibility-parallel_list-2.o: compatibility-parallel_list-2.cc
+ $(CXXCOMPILE) -c $<
# Use special rules for the C++0x sources so that the proper flags are passed.
functexcept.lo: functexcept.cc
#include <memory>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template class allocator<char>;
template class allocator<wchar_t>;
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
};
} // anonymous namespace
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace __atomic0
{
} // namespace __atomic0
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// XXX GLIBCXX_ABI Deprecated
// Bitmap Allocator. Out of line function definitions. -*- C++ -*-
-// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
+// Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
#include <ext/bitmap_allocator.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
-
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
namespace __detail
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template class __mini_vector<
std::pair<bitmap_allocator<char>::_Alloc_block*,
bitmap_allocator<char>::_Alloc_block*> >;
template size_t** __lower_bound(size_t**, size_t**, size_t const&,
free_list::_LT_pointer_compare);
+ _GLIBCXX_END_NAMESPACE_VERSION
}
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
size_t*
free_list::
_M_get(size_t __sz) throw(std::bad_alloc)
template class bitmap_allocator<char>;
template class bitmap_allocator<wchar_t>;
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// chrono -*- C++ -*-
-// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <sys/time.h>
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std _GLIBCXX_VISIBILITY(default)
+{
namespace chrono
{
- constexpr bool system_clock::is_monotonic;
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ constexpr bool system_clock::is_monotonic;
system_clock::time_point
system_clock::now() throw ()
+ chrono::nanoseconds(tp.tv_nsec)));
}
#endif
- }
-_GLIBCXX_END_NAMESPACE
+ _GLIBCXX_END_NAMESPACE_VERSION
+ } // namespace chrono
+} // namespace std
#endif // _GLIBCXX_USE_C99_STDINT_TR1
#include <locale>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Definitions for locale::id of standard facets that are specialized.
locale::id codecvt<char, char, mbstate_t>::id;
{ return false; }
#endif // _GLIBCXX_USE_WCHAR_T
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
# error "compatibility-c++0x.cc must be compiled with -std=gnu++0x"
#endif
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
// gcc-4.4.0
// <mutex> exported std::lock_error
-// Debugging mode support code for list -*- C++ -*-
+// Compatibility symbols for previous versions, debug list -*- C++ -*-
-// Copyright (C) 2004, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
-#define _GLIBCXX_DEBUG
-
-#include "list.cc"
+#define _GLIBCXX_BEGIN_NAMESPACE_COMPAT namespace __norm {
+#define _GLIBCXX_END_NAMESPACE_COMPAT }
+#include "compatibility-list-2.cc"
// Compatibility symbols for previous versions, debug list -*- C++ -*-
-// Copyright (C) 2010 Free Software Foundation, Inc.
+// Copyright (C) 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
-#define _GLIBCXX_DEBUG
+#define _GLIBCXX_BEGIN_NAMESPACE_COMPAT namespace __norm {
+#define _GLIBCXX_END_NAMESPACE_COMPAT }
#include "compatibility-list.cc"
#error "compatibility-ldbl.cc must be compiled with -mlong-double-64"
#endif
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
#define C char
template class num_get<C, istreambuf_iterator<C> >;
// For std::tr1::hash<long double>::operator()
#define _GLIBCXX_LONG_DOUBLE_COMPAT_IMPL
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
--- /dev/null
+// Compatibility symbols for previous versions, list bits -*- C++ -*-
+
+// Copyright (C) 2011 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+#include <bits/move.h>
+
+#ifndef _GLIBCXX_BEGIN_NAMESPACE_COMPAT
+# define _GLIBCXX_BEGIN_NAMESPACE_COMPAT
+#endif
+
+#ifndef _GLIBCXX_END_NAMESPACE_COMPAT
+# define _GLIBCXX_END_NAMESPACE_COMPAT
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_COMPAT
+
+ struct _List_node_base
+ {
+ _List_node_base* _M_next;
+ _List_node_base* _M_prev;
+
+ void
+ _M_transfer(_List_node_base * const __first,
+ _List_node_base * const __last) throw ();
+
+ void
+ _M_reverse() throw ();
+
+ void
+ _M_hook(_List_node_base * const __position) throw ();
+
+ void
+ _M_unhook() throw ();
+ };
+
+ void
+ _List_node_base::_M_transfer(_List_node_base * const __first,
+ _List_node_base * const __last) throw ()
+ {
+ if (this != __last)
+ {
+ // Remove [first, last) from its old position.
+ __last->_M_prev->_M_next = this;
+ __first->_M_prev->_M_next = __last;
+ this->_M_prev->_M_next = __first;
+
+ // Splice [first, last) into its new position.
+ _List_node_base* const __tmp = this->_M_prev;
+ this->_M_prev = __last->_M_prev;
+ __last->_M_prev = __first->_M_prev;
+ __first->_M_prev = __tmp;
+ }
+ }
+
+ void
+ _List_node_base::_M_reverse() throw ()
+ {
+ _List_node_base* __tmp = this;
+ do
+ {
+ std::swap(__tmp->_M_next, __tmp->_M_prev);
+
+ // Old next node is now prev.
+ __tmp = __tmp->_M_prev;
+ }
+ while (__tmp != this);
+ }
+
+ void
+ _List_node_base::_M_hook(_List_node_base* const __position) throw ()
+ {
+ this->_M_next = __position;
+ this->_M_prev = __position->_M_prev;
+ __position->_M_prev->_M_next = this;
+ __position->_M_prev = this;
+ }
+
+ void
+ _List_node_base::_M_unhook() throw ()
+ {
+ _List_node_base* const __next_node = this->_M_next;
+ _List_node_base* const __prev_node = this->_M_prev;
+ __prev_node->_M_next = __next_node;
+ __next_node->_M_prev = __prev_node;
+ }
+
+_GLIBCXX_END_NAMESPACE_COMPAT
+
+} // namespace std
// Compatibility symbols for previous versions, list bits -*- C++ -*-
-// Copyright (C) 2010 Free Software Foundation, Inc.
+// Copyright (C) 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <bits/move.h>
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
+#ifndef _GLIBCXX_BEGIN_NAMESPACE_COMPAT
+# define _GLIBCXX_BEGIN_NAMESPACE_COMPAT
+#endif
+
+#ifndef _GLIBCXX_END_NAMESPACE_COMPAT
+# define _GLIBCXX_END_NAMESPACE_COMPAT
+#endif
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_COMPAT
struct _List_node_base
{
_List_node_base* _M_next;
_List_node_base* _M_prev;
+ static void
+ swap(_List_node_base& __x, _List_node_base& __y) throw ();
+
void
transfer(_List_node_base * const __first,
_List_node_base * const __last) throw ();
unhook() throw ();
};
+ void
+ _List_node_base::swap(_List_node_base& __x, _List_node_base& __y) throw()
+ {
+ if ( __x._M_next != &__x )
+ {
+ if ( __y._M_next != &__y )
+ {
+ // Both __x and __y are not empty.
+ std::swap(__x._M_next,__y._M_next);
+ std::swap(__x._M_prev,__y._M_prev);
+ __x._M_next->_M_prev = __x._M_prev->_M_next = &__x;
+ __y._M_next->_M_prev = __y._M_prev->_M_next = &__y;
+ }
+ else
+ {
+ // __x is not empty, __y is empty.
+ __y._M_next = __x._M_next;
+ __y._M_prev = __x._M_prev;
+ __y._M_next->_M_prev = __y._M_prev->_M_next = &__y;
+ __x._M_next = __x._M_prev = &__x;
+ }
+ }
+ else if ( __y._M_next != &__y )
+ {
+ // __x is empty, __y is not empty.
+ __x._M_next = __y._M_next;
+ __x._M_prev = __y._M_prev;
+ __x._M_next->_M_prev = __x._M_prev->_M_next = &__x;
+ __y._M_next = __y._M_prev = &__y;
+ }
+ }
+
void
_List_node_base::transfer(_List_node_base * const __first,
- _List_node_base * const __last) throw ()
+ _List_node_base * const __last) throw ()
{
if (this != __last)
{
__last->_M_prev->_M_next = this;
__first->_M_prev->_M_next = __last;
this->_M_prev->_M_next = __first;
-
+
// Splice [first, last) into its new position.
_List_node_base* const __tmp = this->_M_prev;
this->_M_prev = __last->_M_prev;
std::swap(__tmp->_M_next, __tmp->_M_prev);
// Old next node is now prev.
- __tmp = __tmp->_M_prev;
- }
+ __tmp = __tmp->_M_prev;
+ }
while (__tmp != this);
}
__next_node->_M_prev = __prev_node;
}
-_GLIBCXX_END_NESTED_NAMESPACE
+_GLIBCXX_END_NAMESPACE_COMPAT
+
+} // namespace std
-// Parallel mode support code for list -*- C++ -*-
+// Compatibility symbols for previous versions, parallel list -*- C++ -*-
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
-#include "list.cc"
+#define _GLIBCXX_BEGIN_NAMESPACE_COMPAT namespace __cxx1998 {
+#define _GLIBCXX_END_NAMESPACE_COMPAT }
+
+#include "compatibility-list-2.cc"
// Compatibility symbols for previous versions, parallel list -*- C++ -*-
-// Copyright (C) 2010 Free Software Foundation, Inc.
+// Copyright (C) 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
+#define _GLIBCXX_BEGIN_NAMESPACE_COMPAT namespace __cxx1998 {
+#define _GLIBCXX_END_NAMESPACE_COMPAT }
+
#include "compatibility-list.cc"
// Compatibility symbols for previous versions -*- C++ -*-
-// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010
+// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
#include <cmath>
#include <ext/numeric_traits.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// std::istream ignore explicit specializations.
template<>
}
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// NB: These symbols renames should go into the shared library only,
_ZNSt19istreambuf_iteratorIwSt11char_traitsIwEEppEv
*/
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template
istreambuf_iterator<char>&
istreambuf_iterator<wchar_t>::operator++();
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
/* gcc-4.0.0
_ZNSt11char_traitsIcE2eqERKcS2_
_ZNSt11char_traitsIwE2eqERKwS2_
*/
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// std::char_traits is explicitly specialized
bool (* __p1)(const char&, const char&) = &char_traits<char>::eq;
basic_ofstream<wchar_t>::is_open() const;
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// The rename syntax for default exported names is
// asm (".symver name1,exportedname@GLIBCXX_3.4")
_ZN10__gnu_norm15_List_node_base7reverseEv;
_ZN10__gnu_norm15_List_node_base8transferEPS0_S1_;
*/
-#include "list.cc"
-_GLIBCXX_ASM_SYMVER(_ZNSt17_List_node_baseXX7_M_hookEPS_, \
+#include "list.cc"
+_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX7_M_hookEPS0_, \
_ZN10__gnu_norm15_List_node_base4hookEPS0_, \
GLIBCXX_3.4)
-_GLIBCXX_ASM_SYMVER(_ZNSt17_List_node_baseXX4swapERS_S0_, \
+_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX4swapERS0_S1_, \
_ZN10__gnu_norm15_List_node_base4swapERS0_S1_, \
GLIBCXX_3.4)
-_GLIBCXX_ASM_SYMVER(_ZNSt17_List_node_baseXX9_M_unhookEv, \
+_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX9_M_unhookEv, \
_ZN10__gnu_norm15_List_node_base6unhookEv, \
GLIBCXX_3.4)
-_GLIBCXX_ASM_SYMVER(_ZNSt17_List_node_baseXX10_M_reverseEv, \
+_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX10_M_reverseEv, \
_ZN10__gnu_norm15_List_node_base7reverseEv, \
GLIBCXX_3.4)
-_GLIBCXX_ASM_SYMVER(_ZNSt17_List_node_baseXX11_M_transferEPS_S0_, \
+_GLIBCXX_ASM_SYMVER(_ZNSt8__detail17_List_node_baseXX11_M_transferEPS0_S1_, \
_ZN10__gnu_norm15_List_node_base8transferEPS0_S1_, \
GLIBCXX_3.4)
#undef _List_node_base
#include <complex>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template
basic_istream<char, char_traits<char> >&
const complex<long double>&);
#endif //_GLIBCXX_USE_WCHAR_T
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// XXX GLIBCXX_ABI Deprecated
#ifdef _GLIBCXX_LONG_DOUBLE_COMPAT
#define _Instantiate(...) template void __function_requires< __VA_ARGS__ > ()
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template void __aux_require_boolean_expr<bool>(bool const&);
_Instantiate(_RandomAccessIteratorConcept<wchar_t const*> );
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#undef _Instantiate
#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
condition_variable::condition_variable() throw ()
{
condition_variable_any::~condition_variable_any() throw ()
{ }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
#include <cstdlib>
#include <cstring>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Definitions for static const data members of ctype_base.
const ctype_base::mask ctype_base::space;
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <ext/rope>
#include <ext/stdio_filebuf.h>
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace
{
template class stdio_filebuf<wchar_t>;
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <fstream>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template class basic_filebuf<char, char_traits<char> >;
template class basic_ifstream<char>;
template class basic_fstream<wchar_t>;
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
# define _(msgid) (msgid)
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
#if __EXCEPTIONS
void
#endif //__EXCEPTIONS
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
}
}
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
const error_category& future_category()
{ return __future_category_instance(); }
const char*
future_error::what() const throw() { return _M_code.message().c_str(); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// XXX GLIBCXX_ABI Deprecated
// gcc-4.6.0
&& defined(_GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE) \
&& defined(_GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT)
-namespace __gnu_cxx
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
const std::error_category* future_category = &__future_category_instance();
}
-// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2009
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2009, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// In macro form:
// _GLIBCXX_ASM_SYMVER(currentname, oldname, GLIBCXX_3.2)
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Standard stream objects.
// NB: Iff <iostream> is included, these definitions become wonky.
fake_wostream wclog;
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-namespace __gnu_internal _GLIBCXX_VISIBILITY_ATTR(hidden)
+namespace __gnu_internal _GLIBCXX_VISIBILITY(hidden)
{
using namespace std;
using namespace __gnu_cxx;
#include <bits/functional_hash.h>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
#include "hash-long-double-aux.cc"
}
#include <string>
#include <tr1/functional>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
// std::__detail and std::tr1::__detail definitions -*- C++ -*-
-// Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2009, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
+#include <bits/c++config.h>
+
namespace __detail
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
extern const unsigned long __prime_list[] = // 256 + 1 or 256 + 48 + 1
{
2ul, 3ul, 5ul, 7ul, 11ul, 13ul, 17ul, 19ul, 23ul, 29ul, 31ul,
18446744073709551557ul, 18446744073709551557ul
#endif
};
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
# error "hashtable_c++0x.cc must be compiled with -std=gnu++0x"
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std _GLIBCXX_VISIBILITY(default)
+{
#include "hashtable-aux.cc"
-
-_GLIBCXX_END_NAMESPACE // namespace std
+} // namespace // namespace std
// std::__detail definitions -*- C++ -*-
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
-namespace std
+#include <bits/c++config.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace tr1
{
#include <ios>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template class basic_ios<char>;
template class basic_ios<wchar_t>;
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <ios>
#include <limits>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Definitions for static const members of ios_base.
const ios_base::fmtflags ios_base::boolalpha;
_M_callbacks = 0;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <ios>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
ios_base::failure::failure(const string& __str) throw()
: _M_msg(__str) { }
ios_base::failure::what() const throw()
{ return _M_msg.c_str(); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// Iostreams base classes -*- C++ -*-
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-// 2006, 2007, 2008, 2009, 2010
+// 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
#include <ext/stdio_filebuf.h>
#include <ext/stdio_sync_filebuf.h>
-namespace __gnu_internal _GLIBCXX_VISIBILITY_ATTR(hidden)
+namespace __gnu_internal _GLIBCXX_VISIBILITY(hidden)
{
using namespace __gnu_cxx;
#endif
} // namespace __gnu_internal
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using namespace __gnu_internal;
return __ret;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <ios>
#include <locale>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Called only by basic_ios<>::init.
void
return __old;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <iomanip>
#include <istream>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template class _Setfill<char>;
template _Setfill<char> setfill(char);
template class basic_iostream<wchar_t>;
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <istream>
#include <iomanip>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template class basic_istream<char>;
template istream& ws(istream&);
template wistream& wistream::_M_extract(void*&);
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// XXX GLIBCXX_ABI Deprecated
#ifdef _GLIBCXX_LONG_DOUBLE_COMPAT
#include <istream>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<>
basic_istream<char>&
}
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <limits>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
#define const _GLIBCXX_USE_CONSTEXPR
#undef const
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// XXX GLIBCXX_ABI Deprecated
#ifdef _GLIBCXX_LONG_DOUBLE_COMPAT
// std::list utilities implementation -*- C++ -*-
-// Copyright (C) 2003, 2005, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2003, 2005, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <list>
-_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)
-
- void
- _List_node_base::swap(_List_node_base& __x, _List_node_base& __y) throw()
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+ namespace __detail
{
- if ( __x._M_next != &__x )
- {
- if ( __y._M_next != &__y )
- {
- // Both __x and __y are not empty.
- std::swap(__x._M_next,__y._M_next);
- std::swap(__x._M_prev,__y._M_prev);
- __x._M_next->_M_prev = __x._M_prev->_M_next = &__x;
- __y._M_next->_M_prev = __y._M_prev->_M_next = &__y;
- }
- else
- {
- // __x is not empty, __y is empty.
- __y._M_next = __x._M_next;
- __y._M_prev = __x._M_prev;
- __y._M_next->_M_prev = __y._M_prev->_M_next = &__y;
- __x._M_next = __x._M_prev = &__x;
- }
- }
- else if ( __y._M_next != &__y )
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ void
+ _List_node_base::swap(_List_node_base& __x, _List_node_base& __y) throw()
{
- // __x is empty, __y is not empty.
- __x._M_next = __y._M_next;
- __x._M_prev = __y._M_prev;
- __x._M_next->_M_prev = __x._M_prev->_M_next = &__x;
- __y._M_next = __y._M_prev = &__y;
+ if ( __x._M_next != &__x )
+ {
+ if ( __y._M_next != &__y )
+ {
+ // Both __x and __y are not empty.
+ std::swap(__x._M_next,__y._M_next);
+ std::swap(__x._M_prev,__y._M_prev);
+ __x._M_next->_M_prev = __x._M_prev->_M_next = &__x;
+ __y._M_next->_M_prev = __y._M_prev->_M_next = &__y;
+ }
+ else
+ {
+ // __x is not empty, __y is empty.
+ __y._M_next = __x._M_next;
+ __y._M_prev = __x._M_prev;
+ __y._M_next->_M_prev = __y._M_prev->_M_next = &__y;
+ __x._M_next = __x._M_prev = &__x;
+ }
+ }
+ else if ( __y._M_next != &__y )
+ {
+ // __x is empty, __y is not empty.
+ __x._M_next = __y._M_next;
+ __x._M_prev = __y._M_prev;
+ __x._M_next->_M_prev = __x._M_prev->_M_next = &__x;
+ __y._M_next = __y._M_prev = &__y;
+ }
}
- }
- void
- _List_node_base::_M_transfer(_List_node_base * const __first,
- _List_node_base * const __last) throw()
- {
- if (this != __last)
+ void
+ _List_node_base::_M_transfer(_List_node_base * const __first,
+ _List_node_base * const __last) throw()
{
- // Remove [first, last) from its old position.
- __last->_M_prev->_M_next = this;
- __first->_M_prev->_M_next = __last;
- this->_M_prev->_M_next = __first;
-
- // Splice [first, last) into its new position.
- _List_node_base* const __tmp = this->_M_prev;
- this->_M_prev = __last->_M_prev;
- __last->_M_prev = __first->_M_prev;
- __first->_M_prev = __tmp;
+ if (this != __last)
+ {
+ // Remove [first, last) from its old position.
+ __last->_M_prev->_M_next = this;
+ __first->_M_prev->_M_next = __last;
+ this->_M_prev->_M_next = __first;
+
+ // Splice [first, last) into its new position.
+ _List_node_base* const __tmp = this->_M_prev;
+ this->_M_prev = __last->_M_prev;
+ __last->_M_prev = __first->_M_prev;
+ __first->_M_prev = __tmp;
+ }
}
- }
- void
- _List_node_base::_M_reverse() throw()
- {
- _List_node_base* __tmp = this;
- do
+ void
+ _List_node_base::_M_reverse() throw()
{
- std::swap(__tmp->_M_next, __tmp->_M_prev);
+ _List_node_base* __tmp = this;
+ do
+ {
+ std::swap(__tmp->_M_next, __tmp->_M_prev);
- // Old next node is now prev.
- __tmp = __tmp->_M_prev;
- }
- while (__tmp != this);
- }
+ // Old next node is now prev.
+ __tmp = __tmp->_M_prev;
+ }
+ while (__tmp != this);
+ }
- void
- _List_node_base::_M_hook(_List_node_base* const __position) throw()
- {
- this->_M_next = __position;
- this->_M_prev = __position->_M_prev;
- __position->_M_prev->_M_next = this;
- __position->_M_prev = this;
- }
+ void
+ _List_node_base::_M_hook(_List_node_base* const __position) throw()
+ {
+ this->_M_next = __position;
+ this->_M_prev = __position->_M_prev;
+ __position->_M_prev->_M_next = this;
+ __position->_M_prev = this;
+ }
- void
- _List_node_base::_M_unhook() throw()
- {
- _List_node_base* const __next_node = this->_M_next;
- _List_node_base* const __prev_node = this->_M_prev;
- __prev_node->_M_next = __next_node;
- __next_node->_M_prev = __prev_node;
- }
+ void
+ _List_node_base::_M_unhook() throw()
+ {
+ _List_node_base* const __next_node = this->_M_next;
+ _List_node_base* const __prev_node = this->_M_prev;
+ __prev_node->_M_next = __next_node;
+ __next_node->_M_prev = __prev_node;
+ }
-_GLIBCXX_END_NESTED_NAMESPACE
+ _GLIBCXX_END_NAMESPACE_VERSION
+ } // namespace __detail
+} // namespace std
// Locale support -*- C++ -*-
// Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
-// 2009 Free Software Foundation, Inc.
+// 2009, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
# define C_is_char
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// moneypunct, money_get, and money_put
template class moneypunct<C, false>;
template struct __moneypunct_cache<C, true>;
template class moneypunct_byname<C, false>;
template class moneypunct_byname<C, true>;
-_GLIBCXX_BEGIN_LDBL_NAMESPACE
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
template class money_get<C, istreambuf_iterator<C> >;
template class money_put<C, ostreambuf_iterator<C> >;
template
money_put<C, ostreambuf_iterator<C> >::
_M_insert<false>(ostreambuf_iterator<C>, ios_base&, C,
const string_type&) const;
-_GLIBCXX_END_LDBL_NAMESPACE
+_GLIBCXX_END_NAMESPACE_LDBL
// numpunct, numpunct_byname, num_get, and num_put
template class numpunct<C>;
template struct __numpunct_cache<C>;
template class numpunct_byname<C>;
-_GLIBCXX_BEGIN_LDBL_NAMESPACE
+_GLIBCXX_BEGIN_NAMESPACE_LDBL
template class num_get<C, istreambuf_iterator<C> >;
template class num_put<C, ostreambuf_iterator<C> >;
template
num_put<C, ostreambuf_iterator<C> >::
_M_insert_float(ostreambuf_iterator<C>, ios_base&, C, char,
long double) const;
-_GLIBCXX_END_LDBL_NAMESPACE
+_GLIBCXX_END_NAMESPACE_LDBL
// time_get and time_put
template class __timepunct<C>;
ios_base::fmtflags, bool);
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// XXX GLIBCXX_ABI Deprecated
#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined C_is_char
# endif
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Definitions for static const data members of locale.
const locale::category locale::none;
return _M_index - 1;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <locale>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Definitions for static const data members of time_base.
template<>
return __test;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
} // anonymous namespace
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
locale::locale() throw() : _M_impl(0)
{
#endif
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <cstdlib>
#include <locale>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using namespace __gnu_cxx;
}
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <ostream>
#include <ext/stdio_sync_filebuf.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// string related to iostreams
template
getline(basic_istream<wchar_t>&, wstring&);
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template class stdio_sync_filebuf<char>;
#ifdef _GLIBCXX_USE_WCHAR_T
template class stdio_sync_filebuf<wchar_t>;
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#endif
} // anonymous namespace
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
void
__pool<false>::_M_destroy() throw()
template class __mt_alloc<char>;
template class __mt_alloc<wchar_t>;
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
}
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
#ifdef _GLIBCXX_HAVE_TLS
__thread void* __once_callable;
}
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// XXX GLIBCXX_ABI Deprecated
// gcc-4.6.0
&& defined(_GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE) \
&& defined(_GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT)
-namespace __gnu_cxx
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
std::defer_lock_t defer_lock;
std::try_to_lock_t try_to_lock;
#include <ostream>
#include <iomanip>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// ostream
template class basic_ostream<char>;
template wostream& wostream::_M_insert(const void*);
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// XXX GLIBCXX_ABI Deprecated
#ifdef _GLIBCXX_LONG_DOUBLE_COMPAT
#include <functional>
-namespace std
+namespace std _GLIBCXX_VISIBILITY(default)
{
namespace placeholders
{
+ _GLIBCXX_BEGIN_NAMESPACE_VERSION
extern const _Placeholder<1> _1{};
extern const _Placeholder<2> _2{};
extern const _Placeholder<3> _3{};
extern const _Placeholder<27> _27{};
extern const _Placeholder<28> _28{};
extern const _Placeholder<29> _29{};
+ _GLIBCXX_END_NAMESPACE_VERSION
}
}
}
} // anonymous namespace
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Definitions for __pool_alloc_base.
__pool_alloc_base::_Obj* volatile*
template class __pool_alloc<char>;
template class __pool_alloc<wchar_t>;
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <sstream>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template class basic_stringbuf<char>;
template class basic_istringstream<char>;
template class basic_stringstream<wchar_t>;
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <string>
#include <stdexcept>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
logic_error::logic_error(const string& __arg)
: exception(), _M_msg(__arg) { }
underflow_error::underflow_error(const string& __arg)
: runtime_error(__arg) { }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <ios>
#include <streambuf>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// streambuf
template class basic_streambuf<char>;
basic_streambuf<wchar_t>*, bool&);
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <streambuf>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<>
streamsize
}
#endif
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
# define C char
#endif
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef basic_string<C> S;
S::_S_construct(const C*, const C*, const allocator<C>&,
forward_iterator_tag);
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
using std::S;
template bool operator==(const S::iterator&, const S::iterator&);
template bool operator==(const S::const_iterator&, const S::const_iterator&);
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <string.h>
#include <limits.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
strstreambuf::strstreambuf(streamsize initial_capacity)
: _Base(), _M_alloc_fun(0), _M_free_fun(0), _M_dynamic(true),
strstream::str() throw ()
{ return _M_buf.str(); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
const system_error_category system_category_instance;
}
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
const error_category&
system_category() throw() { return system_category_instance; }
error_code::default_error_condition() const
{ return category().default_error_condition(value()); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// thread -*- C++ -*-
-// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
-_GLIBCXX_BEGIN_NAMESPACE(std)
-
+namespace std _GLIBCXX_VISIBILITY(default)
+{
namespace
{
extern "C" void*
}
}
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
void
thread::join()
{
}
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
#include <bits/stl_tree.h>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_Rb_tree_node_base*
_Rb_tree_increment(_Rb_tree_node_base* __x) throw ()
return __sum;
}
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#include <valarray>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Some explicit instantiations.
template void
_M_index(__l.size() == 0 ? 0 : __valarray_product(__l))
{ __gslice_to_index(__o, __l, __s, _M_index); }
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
// { dg-do compile }
-// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free
-// Software Foundation
+// Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011
+// Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
test01();
return 0;
}
-// { dg-error "::auto_ptr|no known conversion" "" { target *-*-* } 134 }
-// { dg-error "note" "" { target *-*-* } 152 }
-// { dg-error "::auto_ptr|no known conversion" "" { target *-*-* } 262 }
+// { dg-error "::auto_ptr|no known conversion" "" { target *-*-* } 136 }
+// { dg-error "note" "" { target *-*-* } 154 }
+// { dg-error "::auto_ptr|no known conversion" "" { target *-*-* } 264 }
// { dg-do compile }
// 2009-11-12 Paolo Carlini <paolo.carlini@oracle.com>
//
-// Copyright (C) 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
-// { dg-error "static assertion failed" "" { target *-*-* } 1132 }
+// { dg-error "static assertion failed" "" { target *-*-* } 1134 }
#include <utility>
// { dg-require-cstdint "" }
// 2008-07-31 Chris Fairles <chris.fairles@gmail.com>
-// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
test_type d;
}
-// { dg-error "rep cannot be a duration" "" { target *-*-* } 218 }
+// { dg-error "rep cannot be a duration" "" { target *-*-* } 226 }
// { dg-error "instantiated from here" "" { target *-*-* } 31 }
test_type d;
}
-// { dg-error "must be a specialization of ratio" "" { target *-*-* } 219 }
+// { dg-error "must be a specialization of ratio" "" { target *-*-* } 227 }
// { dg-error "instantiated from here" "" { target *-*-* } 32 }
// { dg-excess-errors "In instantiation of" }
// { dg-require-cstdint "" }
// 2008-07-31 Chris Fairles <chris.fairles@gmail.com>
-// Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
test_type d;
}
-// { dg-error "period must be positive" "" { target *-*-* } 221 }
+// { dg-error "period must be positive" "" { target *-*-* } 229 }
// { dg-error "instantiated from here" "" { target *-*-* } 33 }
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
-// Copyright (C) 2010 Free Software Foundation, Inc.
+// Copyright (C) 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
-// { dg-error "static assertion failed" "" { target *-*-* } 64 }
+// { dg-error "static assertion failed" "" { target *-*-* } 69 }
#include <list>
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
-// { dg-error "static assertion failed" "" { target *-*-* } 64 }
+// { dg-error "static assertion failed" "" { target *-*-* } 69 }
#include <utility>
// { dg-error "instantiated from here" "" { target *-*-* } 40 }
// { dg-error "instantiated from here" "" { target *-*-* } 42 }
-// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1095 }
-// { dg-error "declaration of" "" { target *-*-* } 1059 }
+// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1097 }
+// { dg-error "declaration of" "" { target *-*-* } 1061 }
// 2007-05-03 Benjamin Kosnik <bkoz@redhat.com>
//
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// { dg-error "instantiated from here" "" { target *-*-* } 40 }
// { dg-error "instantiated from here" "" { target *-*-* } 42 }
-// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1018 }
-// { dg-error "declaration of" "" { target *-*-* } 982 }
+// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1020 }
+// { dg-error "declaration of" "" { target *-*-* } 984 }
// { dg-options "-std=gnu++0x" }
// { dg-require-cstdint "" }
-// Copyright (C) 2008, 2009, 2010 Free Software Foundation
+// Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// { dg-error "instantiated from here" "" { target *-*-* } 34 }
// { dg-error "instantiated from here" "" { target *-*-* } 40 }
// { dg-error "instantiated from here" "" { target *-*-* } 46 }
-// { dg-error "denominator cannot be zero" "" { target *-*-* } 153 }
-// { dg-error "out of range" "" { target *-*-* } 154 }
-// { dg-error "non-constant expression" "" { target *-*-* } 59 }
-// { dg-error "overflow in constant expression" "" { target *-*-* } 59 }
-// { dg-error "not a member" "" { target *-*-* } 162 }
-// { dg-error "not a valid template argument" "" { target *-*-* } 164 }
+// { dg-error "denominator cannot be zero" "" { target *-*-* } 155 }
+// { dg-error "out of range" "" { target *-*-* } 156 }
+// { dg-error "non-constant expression" "" { target *-*-* } 61 }
+// { dg-error "overflow in constant expression" "" { target *-*-* } 61 }
+// { dg-error "not a member" "" { target *-*-* } 164 }
+// { dg-error "not a valid template argument" "" { target *-*-* } 166 }
// 2008-07-03 Chris Fairles <chris.fairles@gmail.com>
-// Copyright (C) 2008, 2009 Free Software Foundation
+// Copyright (C) 2008, 2009, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// { dg-error "instantiated from here" "" { target *-*-* } 29 }
// { dg-error "instantiated from here" "" { target *-*-* } 35 }
// { dg-error "instantiated from here" "" { target *-*-* } 36 }
-// { dg-error "overflow in addition" "" { target *-*-* } 130 }
-// { dg-error "overflow in multiplication" "" { target *-*-* } 98 }
+// { dg-error "overflow in addition" "" { target *-*-* } 132 }
+// { dg-error "overflow in multiplication" "" { target *-*-* } 104 }
// { dg-error "overflow in multiplication" "" { target *-*-* } 100 }
// { dg-error "overflow in multiplication" "" { target *-*-* } 102 }
// { dg-excess-errors "In instantiation of" }
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
-// Copyright (C) 2010 Free Software Foundation
+// Copyright (C) 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
{
X* px = 0;
std::shared_ptr<X> p1(px); // { dg-error "here" }
- // { dg-error "incomplete" "" { target *-*-* } 763 }
+ // { dg-error "incomplete" "" { target *-*-* } 765 }
std::shared_ptr<X> p9(ap()); // { dg-error "here" }
- // { dg-error "incomplete" "" { target *-*-* } 855 }
+ // { dg-error "incomplete" "" { target *-*-* } 857 }
}
// { dg-options "-std=gnu++0x " }
// { dg-do compile }
-// Copyright (C) 2008, 2009, 2010 Free Software Foundation
+// Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
return 0;
}
-// { dg-warning "note" "" { target *-*-* } 352 }
-// { dg-warning "note" "" { target *-*-* } 1083 }
-// { dg-warning "note" "" { target *-*-* } 465 }
-// { dg-warning "note" "" { target *-*-* } 585 }
-// { dg-warning "note" "" { target *-*-* } 1048 }
-// { dg-warning "note" "" { target *-*-* } 1042 }
-// { dg-warning "note" "" { target *-*-* } 340 }
-// { dg-warning "note" "" { target *-*-* } 290 }
-// { dg-warning "note" "" { target *-*-* } 205 }
+// { dg-warning "note" "" { target *-*-* } 354 }
+// { dg-warning "note" "" { target *-*-* } 1085 }
+// { dg-warning "note" "" { target *-*-* } 467 }
+// { dg-warning "note" "" { target *-*-* } 587 }
+// { dg-warning "note" "" { target *-*-* } 1050 }
+// { dg-warning "note" "" { target *-*-* } 1056 }
+// { dg-warning "note" "" { target *-*-* } 342 }
+// { dg-warning "note" "" { target *-*-* } 292 }
+// { dg-warning "note" "" { target *-*-* } 207 }
// 2007-04-27 Paolo Carlini <pcarlini@suse.de>
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1659 }
+// { dg-error "no matching" "" { target *-*-* } 1661 }
// { dg-excess-errors "" }
#include <deque>
// 2007-04-27 Paolo Carlini <pcarlini@suse.de>
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1592 }
+// { dg-error "no matching" "" { target *-*-* } 1594 }
// { dg-excess-errors "" }
#include <deque>
// 2007-04-27 Paolo Carlini <pcarlini@suse.de>
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1592 }
+// { dg-error "no matching" "" { target *-*-* } 1594 }
// { dg-excess-errors "" }
#include <deque>
// 2007-04-27 Paolo Carlini <pcarlini@suse.de>
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1743 }
+// { dg-error "no matching" "" { target *-*-* } 1745 }
// { dg-excess-errors "" }
#include <deque>
VERIFY(fld.empty() == true);
#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PROFILE)
- using std::_GLIBCXX_STD_D::_Fwd_list_node;
+ using std::_GLIBCXX_STD_C::_Fwd_list_node;
#else
using std::_Fwd_list_node;
#endif
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
-// { dg-error "no matching" "" { target *-*-* } 1204 }
+// { dg-error "no matching" "" { target *-*-* } 1206 }
// { dg-excess-errors "" }
// Copyright (C) 2009, 2010 Free Software Foundation
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
-// { dg-error "no matching" "" { target *-*-* } 1204 }
+// { dg-error "no matching" "" { target *-*-* } 1206 }
// { dg-excess-errors "" }
-// Copyright (C) 2009, 2010 Free Software Foundation
+// Copyright (C) 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
-// { dg-error "no matching" "" { target *-*-* } 1204 }
+// { dg-error "no matching" "" { target *-*-* } 1206 }
// { dg-excess-errors "" }
-// Copyright (C) 2009, 2010 Free Software Foundation
+// Copyright (C) 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
-// { dg-error "no matching" "" { target *-*-* } 1204 }
+// { dg-error "no matching" "" { target *-*-* } 1206 }
// { dg-excess-errors "" }
-// Copyright (C) 2009, 2010 Free Software Foundation
+// Copyright (C) 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#if ! defined _GLIBCXX_DEBUG && ! defined _GLIBCXX_PROFILE
using std::_List_node;
#else
- using std::_GLIBCXX_STD_D::_List_node;
+ using std::_GLIBCXX_STD_C::_List_node;
#endif
VERIFY( l.max_size() == std::allocator<_List_node<int> >().max_size() );
// 2007-04-27 Paolo Carlini <pcarlini@suse.de>
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1478 }
+// { dg-error "no matching" "" { target *-*-* } 1491 }
// { dg-excess-errors "" }
#include <list>
// 2007-04-27 Paolo Carlini <pcarlini@suse.de>
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1434 }
+// { dg-error "no matching" "" { target *-*-* } 1447 }
// { dg-excess-errors "" }
#include <list>
// 2007-04-27 Paolo Carlini <pcarlini@suse.de>
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1434 }
+// { dg-error "no matching" "" { target *-*-* } 1447 }
// { dg-excess-errors "" }
#include <list>
// 2007-04-27 Paolo Carlini <pcarlini@suse.de>
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1434 }
+// { dg-error "no matching" "" { target *-*-* } 1447 }
// { dg-excess-errors "" }
#include <list>
using std::numeric_limits;
#ifdef _GLIBCXX_DEBUG
- using std::_GLIBCXX_STD_D::_S_word_bit;
+ using std::_GLIBCXX_STD_C::_S_word_bit;
#elif defined(_GLIBCXX_PROFILE)
- using std::_GLIBCXX_STD_PR::_S_word_bit;
+ using std::_GLIBCXX_STD_C::_S_word_bit;
#else
using std::_S_word_bit;
#endif
#include <testsuite_hooks.h>
#ifdef _GLIBCXX_DEBUG
- using std::_GLIBCXX_STD_D::_S_word_bit;
+ using std::_GLIBCXX_STD_C::_S_word_bit;
#elif defined(_GLIBCXX_PROFILE)
- using std::_GLIBCXX_STD_PR::_S_word_bit;
+ using std::_GLIBCXX_STD_C::_S_word_bit;
#else
using std::_S_word_bit;
#endif
// 2007-04-27 Paolo Carlini <pcarlini@suse.de>
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1148 }
+// { dg-error "no matching" "" { target *-*-* } 1150 }
// { dg-excess-errors "" }
#include <vector>
// 2007-04-27 Paolo Carlini <pcarlini@suse.de>
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1078 }
+// { dg-error "no matching" "" { target *-*-* } 1080 }
// { dg-excess-errors "" }
#include <vector>
// 2007-04-27 Paolo Carlini <pcarlini@suse.de>
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1078 }
+// { dg-error "no matching" "" { target *-*-* } 1080 }
// { dg-excess-errors "" }
#include <vector>
// 2007-04-27 Paolo Carlini <pcarlini@suse.de>
-// Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation
+// Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// <http://www.gnu.org/licenses/>.
// { dg-do compile }
-// { dg-error "no matching" "" { target *-*-* } 1189 }
+// { dg-error "no matching" "" { target *-*-* } 1191 }
// { dg-excess-errors "" }
#include <vector>
-// Copyright (C) 2008, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2008, 2009, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
{
using namespace std;
using namespace tr1;
- using namespace placeholders;
+ using namespace std::tr1::placeholders;
int t[10];
sort(t, t+10, bind(less<int>(), _1, _2));
// { dg-do compile }
-// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
-// Foundation, Inc.
+// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
}
// { dg-error "synthesized" "" { target *-*-* } 33 }
// { dg-error "within this context" "" { target *-*-* } 26 }
-// { dg-error "is private" "" { target *-*-* } 789 }
+// { dg-error "is private" "" { target *-*-* } 791 }
// { dg-error "operator=" "" { target *-*-* } 0 }
// { dg-do compile }
-// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
-// Foundation, Inc.
+// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
}
// { dg-error "within this context" "" { target *-*-* } 26 }
// { dg-error "synthesized" "" { target *-*-* } 33 }
-// { dg-error "is private" "" { target *-*-* } 786 }
+// { dg-error "is private" "" { target *-*-* } 788 }
// { dg-error "copy constructor" "" { target *-*-* } 0 }
#include <vector>
-// { dg-error "Cannot use -D_GLIBCXX_PROFILE with " "" { target *-*-* } 220 }
+// { dg-error "multiple inlined namespaces" "" { target *-*-* } 243 }
// Unit tests for profile/impl/profile_algos.h.
-// Copyright (C) 2010 Free Software Foundation, Inc.
+// Copyright (C) 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
#include <vector>
#include <profile/impl/profiler.h>
-using std::__norm::vector;
+using std::_GLIBCXX_STD_C::vector;
enum Failure
{
// { dg-do compile }
// -*- C++ -*-
-// Copyright (C) 2006, 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007, 2009, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
}
// { dg-error "instantiated from" "" { target *-*-* } 28 }
-// { dg-error "no type" "" { target *-*-* } 67 }
+// { dg-error "no type" "" { target *-*-* } 69 }
// { dg-do compile }
// -*- C++ -*-
-// Copyright (C) 2006, 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007, 2009, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
}
// { dg-error "invalid use of incomplete" "" { target *-*-* } 28 }
-// { dg-error "declaration of" "" { target *-*-* } 61 }
+// { dg-error "declaration of" "" { target *-*-* } 63 }
// { dg-do compile }
// -*- C++ -*-
-// Copyright (C) 2006, 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007, 2009, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
}
// { dg-error "instantiated from" "" { target *-*-* } 28 }
-// { dg-error "no type" "" { target *-*-* } 110 }
+// { dg-error "no type" "" { target *-*-* } 112 }
// { dg-do compile }
// -*- C++ -*-
-// Copyright (C) 2006, 2007, 2009 Free Software Foundation, Inc.
+// Copyright (C) 2006, 2007, 2009, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
}
// { dg-error "invalid use of incomplete" "" { target *-*-* } 28 }
-// { dg-error "declaration of" "" { target *-*-* } 104 }
+// { dg-error "declaration of" "" { target *-*-* } 106 }
{
X* px = 0;
std::tr1::shared_ptr<X> p1(px); // { dg-error "here" }
- // { dg-error "incomplete" "" { target *-*-* } 561 }
+ // { dg-error "incomplete" "" { target *-*-* } 563 }
std::tr1::shared_ptr<X> p9(ap()); // { dg-error "here" }
- // { dg-error "incomplete" "" { target *-*-* } 600 }
+ // { dg-error "incomplete" "" { target *-*-* } 602 }
}
projects / thirdparty / gcc.git / commitdiff
