This is an archive of the discontinued LLVM Phabricator instance.

Differential D143163

[libc++][NFC] Rename _LIBCPP_NO_EXCEPTIONS to _LIBCPP_HAS_NO_EXCEPTIONS
ClosedPublic

Authored by philnik on Feb 2 2023, 3:04 AM.

Details

Reviewers
ldionne
Mordante
Group Reviewers
Restricted Project
Commits
rGb22aa3d74f27: [libc++][NFC] Rename _LIBCPP_NO_EXCEPTIONS to _LIBCPP_HAS_NO_EXCEPTIONS
Summary

Other macros that disable parts of the library are named _LIBCPP_HAS_NO_WHATEVER.

Diff Detail

Event Timeline

philnik created this revision.Feb 2 2023, 3:04 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 2 2023, 3:04 AM
Herald added a subscriber: smeenai. · View Herald Transcript
philnik requested review of this revision.Feb 2 2023, 3:04 AM
Herald added a project: Restricted Project. · View Herald TranscriptFeb 2 2023, 3:04 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Harbormaster completed remote builds in B211434: Diff 494232.Feb 2 2023, 5:40 AM
Mordante accepted this revision.Feb 2 2023, 10:03 AM

Nice cleanup, thanks! LGTM!

This revision is now accepted and ready to land.Feb 2 2023, 10:03 AM
philnik mentioned this in D143164: [libc++][NFC] Rename _LIBCPP_NO_RTTI to _LIBCPP_HAS_NO_RTTI.Feb 3 2023, 2:42 PM
ldionne accepted this revision.Feb 15 2023, 7:52 AM

The blast radius is smaller than I expected, let's do this.

Closed by commit rGb22aa3d74f27: [libc++][NFC] Rename _LIBCPP_NO_EXCEPTIONS to _LIBCPP_HAS_NO_EXCEPTIONS (authored by philnik). · Explain WhyFeb 17 2023, 8:39 AM
This revision was automatically updated to reflect the committed changes.
philnik added a commit: rGb22aa3d74f27: [libc++][NFC] Rename _LIBCPP_NO_EXCEPTIONS to _LIBCPP_HAS_NO_EXCEPTIONS.

Revision Contents

PathSize
libcxx/
include/
4 lines
2 lines
__expected/
2 lines
__filesystem/
2 lines
__format/
2 lines
__functional/
2 lines
24 lines
__iterator/
4 lines
__memory/
34 lines
42 lines
8 lines
__utility/
4 lines
2 lines
16 lines
6 lines
16 lines
8 lines
72 lines
32 lines
2 lines
154 lines
32 lines
2 lines
2 lines
176 lines
2 lines
8 lines
16 lines
26 lines
2 lines
72 lines
4 lines
48 lines
src/
filesystem/
24 lines
4 lines
8 lines
28 lines
16 lines
38 lines
2 lines
support/
runtime/
8 lines
8 lines
2 lines

Diff 498391

libcxx/include/__availability

Show First 20 Lines • Show All 264 Lines • ▼ Show 20 Lines
#else #else
// ...New vendors can add availability markup here... // ...New vendors can add availability markup here...
# error "It looks like you're trying to enable vendor availability markup, but you haven't defined the corresponding macros yet!" # error "It looks like you're trying to enable vendor availability markup, but you haven't defined the corresponding macros yet!"
#endif #endif
// Define availability attributes that depend on _LIBCPP_NO_EXCEPTIONS. // Define availability attributes that depend on _LIBCPP_HAS_NO_EXCEPTIONS.
// Those are defined in terms of the availability attributes above, and // Those are defined in terms of the availability attributes above, and
// should not be vendor-specific. // should not be vendor-specific.
#if defined(_LIBCPP_NO_EXCEPTIONS) #if defined(_LIBCPP_HAS_NO_EXCEPTIONS)
# define _LIBCPP_AVAILABILITY_FUTURE # define _LIBCPP_AVAILABILITY_FUTURE
# define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST # define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
# define _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS # define _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
# define _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS # define _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
#else #else
# define _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_AVAILABILITY_FUTURE_ERROR # define _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_AVAILABILITY_FUTURE_ERROR
# define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _LIBCPP_AVAILABILITY_BAD_ANY_CAST # define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _LIBCPP_AVAILABILITY_BAD_ANY_CAST
# define _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS # define _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
# define _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS # define _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS
#endif #endif
#endif // _LIBCPP___AVAILABILITY #endif // _LIBCPP___AVAILABILITY

libcxx/include/__config

Show First 20 Lines • Show All 442 Lines • ▼ Show 20 Lines
# define _LIBCPP_CONSTEXPR # define _LIBCPP_CONSTEXPR
typedef __char16_t char16_t; typedef __char16_t char16_t;
typedef __char32_t char32_t; typedef __char32_t char32_t;
# endif # endif
# if !defined(__cpp_exceptions) || __cpp_exceptions < 199711L # if !defined(__cpp_exceptions) || __cpp_exceptions < 199711L
# define _LIBCPP_NO_EXCEPTIONS # define _LIBCPP_HAS_NO_EXCEPTIONS
# endif # endif
# define _LIBCPP_PREFERRED_ALIGNOF(_Tp) __alignof(_Tp) # define _LIBCPP_PREFERRED_ALIGNOF(_Tp) __alignof(_Tp)
# if defined(_LIBCPP_COMPILER_CLANG_BASED) # if defined(_LIBCPP_COMPILER_CLANG_BASED)
# if defined(__APPLE__) && !defined(__i386__) && !defined(__x86_64__) && (!defined(__arm__) || __ARM_ARCH_7K__ >= 2) # if defined(__APPLE__) && !defined(__i386__) && !defined(__x86_64__) && (!defined(__arm__) || __ARM_ARCH_7K__ >= 2)
# define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT # define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
▲ Show 20 Lines • Show All 805 Lines • Show Last 20 Lines

libcxx/include/__expected/expected.h

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
#if _LIBCPP_STD_VER >= 23 #if _LIBCPP_STD_VER >= 23
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
namespace __expected { namespace __expected {
template <class _Err, class _Arg> template <class _Err, class _Arg>
_LIBCPP_HIDE_FROM_ABI void __throw_bad_expected_access(_Arg&& __arg) { _LIBCPP_HIDE_FROM_ABI void __throw_bad_expected_access(_Arg&& __arg) {
# ifndef _LIBCPP_NO_EXCEPTIONS # ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw bad_expected_access<_Err>(std::forward<_Arg>(__arg)); throw bad_expected_access<_Err>(std::forward<_Arg>(__arg));
# else # else
(void)__arg; (void)__arg;
std::abort(); std::abort();
# endif # endif
} }
} // namespace __expected } // namespace __expected
▲ Show 20 Lines • Show All 899 Lines • Show Last 20 Lines

libcxx/include/__filesystem/filesystem_error.h

Show First 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
}; };
// TODO(ldionne): We need to pop the pragma and push it again after // TODO(ldionne): We need to pop the pragma and push it again after
// filesystem_error to work around PR41078. // filesystem_error to work around PR41078.
_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
template <class... _Args> template <class... _Args>
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
void __throw_filesystem_error(_Args&&... __args) { void __throw_filesystem_error(_Args&&... __args) {
throw filesystem_error(_VSTD::forward<_Args>(__args)...); throw filesystem_error(_VSTD::forward<_Args>(__args)...);
} }
#else #else
void __throw_filesystem_error(_Args&&...) { void __throw_filesystem_error(_Args&&...) {
_VSTD::abort(); _VSTD::abort();
} }
#endif #endif
_LIBCPP_AVAILABILITY_FILESYSTEM_POP _LIBCPP_AVAILABILITY_FILESYSTEM_POP
_LIBCPP_END_NAMESPACE_FILESYSTEM _LIBCPP_END_NAMESPACE_FILESYSTEM
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
#endif // _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H #endif // _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H

libcxx/include/__format/format_error.h

Show All 34 Lines# ifndef _LIBCPP_INLINE_FORMAT_ERROR_DTOR
~format_error() noexcept override; ~format_error() noexcept override;
# else # else
~format_error() noexcept override {} ~format_error() noexcept override {}
# endif # endif
}; };
_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void _LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void
__throw_format_error(const char* __s) { __throw_format_error(const char* __s) {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw format_error(__s); throw format_error(__s);
#else #else
(void)__s; (void)__s;
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
#endif //_LIBCPP_STD_VER >= 20 #endif //_LIBCPP_STD_VER >= 20
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___FORMAT_FORMAT_ERROR_H #endif // _LIBCPP___FORMAT_FORMAT_ERROR_H

libcxx/include/__functional/function.h

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines#ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_GOOD_WHAT_MESSAGE
const char* what() const _NOEXCEPT override; const char* what() const _NOEXCEPT override;
#endif #endif
}; };
_LIBCPP_DIAGNOSTIC_POP _LIBCPP_DIAGNOSTIC_POP
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
void __throw_bad_function_call() void __throw_bad_function_call()
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw bad_function_call(); throw bad_function_call();
#else #else
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
template<class _Fp> class _LIBCPP_TEMPLATE_VIS function; // undefined template<class _Fp> class _LIBCPP_TEMPLATE_VIS function; // undefined
▲ Show 20 Lines • Show All 1,137 Lines • Show Last 20 Lines

libcxx/include/__hash_table

Show First 20 Lines • Show All 1,591 Lines • ▼ Show 20 Lines__hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
else else
{ {
hash_function() = _VSTD::move(__u.hash_function()); hash_function() = _VSTD::move(__u.hash_function());
key_eq() = _VSTD::move(__u.key_eq()); key_eq() = _VSTD::move(__u.key_eq());
max_load_factor() = __u.max_load_factor(); max_load_factor() = __u.max_load_factor();
if (bucket_count() != 0) if (bucket_count() != 0)
{ {
__next_pointer __cache = __detach(); __next_pointer __cache = __detach();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
const_iterator __i = __u.begin(); const_iterator __i = __u.begin();
while (__cache != nullptr && __u.size() != 0) while (__cache != nullptr && __u.size() != 0)
{ {
__cache->__upcast()->__value_ = __cache->__upcast()->__value_ =
_VSTD::move(__u.remove(__i++)->__value_); _VSTD::move(__u.remove(__i++)->__value_);
__next_pointer __next = __cache->__next_; __next_pointer __next = __cache->__next_;
__node_insert_multi(__cache->__upcast()); __node_insert_multi(__cache->__upcast());
__cache = __next; __cache = __next;
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__deallocate_node(__cache); __deallocate_node(__cache);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__deallocate_node(__cache); __deallocate_node(__cache);
} }
const_iterator __i = __u.begin(); const_iterator __i = __u.begin();
while (__u.size() != 0) while (__u.size() != 0)
{ {
__node_holder __h = __construct_node(_NodeTypes::__move(__u.remove(__i++)->__value_)); __node_holder __h = __construct_node(_NodeTypes::__move(__u.remove(__i++)->__value_));
__node_insert_multi(__h.get()); __node_insert_multi(__h.get());
__h.release(); __h.release();
Show All 25 Lines__hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_unique(_InputIterator __first,
typedef iterator_traits<_InputIterator> _ITraits; typedef iterator_traits<_InputIterator> _ITraits;
typedef typename _ITraits::value_type _ItValueType; typedef typename _ITraits::value_type _ItValueType;
static_assert((is_same<_ItValueType, __container_value_type>::value), static_assert((is_same<_ItValueType, __container_value_type>::value),
"__assign_unique may only be called with the containers value type"); "__assign_unique may only be called with the containers value type");
if (bucket_count() != 0) if (bucket_count() != 0)
{ {
__next_pointer __cache = __detach(); __next_pointer __cache = __detach();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (; __cache != nullptr && __first != __last; ++__first) for (; __cache != nullptr && __first != __last; ++__first)
{ {
__cache->__upcast()->__value_ = *__first; __cache->__upcast()->__value_ = *__first;
__next_pointer __next = __cache->__next_; __next_pointer __next = __cache->__next_;
__node_insert_unique(__cache->__upcast()); __node_insert_unique(__cache->__upcast());
__cache = __next; __cache = __next;
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__deallocate_node(__cache); __deallocate_node(__cache);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__deallocate_node(__cache); __deallocate_node(__cache);
} }
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
__insert_unique(*__first); __insert_unique(*__first);
} }
template <class _Tp, class _Hash, class _Equal, class _Alloc> template <class _Tp, class _Hash, class _Equal, class _Alloc>
template <class _InputIterator> template <class _InputIterator>
void void
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first, __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first,
_InputIterator __last) _InputIterator __last)
{ {
typedef iterator_traits<_InputIterator> _ITraits; typedef iterator_traits<_InputIterator> _ITraits;
typedef typename _ITraits::value_type _ItValueType; typedef typename _ITraits::value_type _ItValueType;
static_assert((is_same<_ItValueType, __container_value_type>::value || static_assert((is_same<_ItValueType, __container_value_type>::value ||
is_same<_ItValueType, __node_value_type>::value), is_same<_ItValueType, __node_value_type>::value),
"__assign_multi may only be called with the containers value type" "__assign_multi may only be called with the containers value type"
" or the nodes value type"); " or the nodes value type");
if (bucket_count() != 0) if (bucket_count() != 0)
{ {
__next_pointer __cache = __detach(); __next_pointer __cache = __detach();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (; __cache != nullptr && __first != __last; ++__first) for (; __cache != nullptr && __first != __last; ++__first)
{ {
__cache->__upcast()->__value_ = *__first; __cache->__upcast()->__value_ = *__first;
__next_pointer __next = __cache->__next_; __next_pointer __next = __cache->__next_;
__node_insert_multi(__cache->__upcast()); __node_insert_multi(__cache->__upcast());
__cache = __next; __cache = __next;
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__deallocate_node(__cache); __deallocate_node(__cache);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__deallocate_node(__cache); __deallocate_node(__cache);
} }
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
__insert_multi(_NodeTypes::__get_value(*__first)); __insert_multi(_NodeTypes::__get_value(*__first));
} }
template <class _Tp, class _Hash, class _Equal, class _Alloc> template <class _Tp, class _Hash, class _Equal, class _Alloc>
inline inline
▲ Show 20 Lines • Show All 987 Lines • Show Last 20 Lines

libcxx/include/__iterator/counted_iterator.h

Show First 20 Lines • Show All 137 Lines • ▼ Show 20 Lines constexpr counted_iterator& operator++() {
--__count_; --__count_;
return *this; return *this;
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
decltype(auto) operator++(int) { decltype(auto) operator++(int) {
_LIBCPP_ASSERT(__count_ > 0, "Iterator already at or past end."); _LIBCPP_ASSERT(__count_ > 0, "Iterator already at or past end.");
--__count_; --__count_;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try { return __current_++; } try { return __current_++; }
catch(...) { ++__count_; throw; } catch(...) { ++__count_; throw; }
#else #else
return __current_++; return __current_++;
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
constexpr counted_iterator operator++(int) constexpr counted_iterator operator++(int)
requires forward_iterator<_Iter> requires forward_iterator<_Iter>
{ {
_LIBCPP_ASSERT(__count_ > 0, "Iterator already at or past end."); _LIBCPP_ASSERT(__count_ > 0, "Iterator already at or past end.");
counted_iterator __tmp = *this; counted_iterator __tmp = *this;
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

libcxx/include/__memory/shared_ptr.h

Show First 20 Lines • Show All 112 Lines • ▼ Show 20 Linespublic:
bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPT = default; bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPT = default;
~bad_weak_ptr() _NOEXCEPT override; ~bad_weak_ptr() _NOEXCEPT override;
const char* what() const _NOEXCEPT override; const char* what() const _NOEXCEPT override;
}; };
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
void __throw_bad_weak_ptr() void __throw_bad_weak_ptr()
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw bad_weak_ptr(); throw bad_weak_ptr();
#else #else
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
template<class _Tp> class _LIBCPP_TEMPLATE_VIS weak_ptr; template<class _Tp> class _LIBCPP_TEMPLATE_VIS weak_ptr;
▲ Show 20 Lines • Show All 373 Lines • ▼ Show 20 Lines explicit shared_ptr(_Yp* __p) : __ptr_(__p) {
__enable_weak_this(__p, __p); __enable_weak_this(__p, __p);
} }
template<class _Yp, class _Dp, class = __enable_if_t<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value> > template<class _Yp, class _Dp, class = __enable_if_t<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
shared_ptr(_Yp* __p, _Dp __d) shared_ptr(_Yp* __p, _Dp __d)
: __ptr_(__p) : __ptr_(__p)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT; typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT> _CntrlBlk; typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT> _CntrlBlk;
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
__cntrl_ = new _CntrlBlk(__p, _VSTD::move(__d), _AllocT()); __cntrl_ = new _CntrlBlk(__p, _VSTD::move(__d), _AllocT());
#else #else
__cntrl_ = new _CntrlBlk(__p, __d, _AllocT()); __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
#endif // not _LIBCPP_CXX03_LANG #endif // not _LIBCPP_CXX03_LANG
__enable_weak_this(__p, __p); __enable_weak_this(__p, __p);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__d(__p); __d(__p);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template<class _Yp, class _Dp, class _Alloc, class = __enable_if_t<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value> > template<class _Yp, class _Dp, class _Alloc, class = __enable_if_t<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value> >
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
shared_ptr(_Yp* __p, _Dp __d, _Alloc __a) shared_ptr(_Yp* __p, _Dp __d, _Alloc __a)
: __ptr_(__p) : __ptr_(__p)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk; typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk;
typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2; typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
typedef __allocator_destructor<_A2> _D2; typedef __allocator_destructor<_A2> _D2;
_A2 __a2(__a); _A2 __a2(__a);
unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
::new ((void*)_VSTD::addressof(*__hold2.get())) ::new ((void*)_VSTD::addressof(*__hold2.get()))
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_CntrlBlk(__p, _VSTD::move(__d), __a); _CntrlBlk(__p, _VSTD::move(__d), __a);
#else #else
_CntrlBlk(__p, __d, __a); _CntrlBlk(__p, __d, __a);
#endif // not _LIBCPP_CXX03_LANG #endif // not _LIBCPP_CXX03_LANG
__cntrl_ = _VSTD::addressof(*__hold2.release()); __cntrl_ = _VSTD::addressof(*__hold2.release());
__enable_weak_this(__p, __p); __enable_weak_this(__p, __p);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__d(__p); __d(__p);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template<class _Dp> template<class _Dp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
shared_ptr(nullptr_t __p, _Dp __d) shared_ptr(nullptr_t __p, _Dp __d)
: __ptr_(nullptr) : __ptr_(nullptr)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT; typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT;
typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT> _CntrlBlk; typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT> _CntrlBlk;
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
__cntrl_ = new _CntrlBlk(__p, _VSTD::move(__d), _AllocT()); __cntrl_ = new _CntrlBlk(__p, _VSTD::move(__d), _AllocT());
#else #else
__cntrl_ = new _CntrlBlk(__p, __d, _AllocT()); __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
#endif // not _LIBCPP_CXX03_LANG #endif // not _LIBCPP_CXX03_LANG
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__d(__p); __d(__p);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template<class _Dp, class _Alloc> template<class _Dp, class _Alloc>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a) shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a)
: __ptr_(nullptr) : __ptr_(nullptr)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk; typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk;
typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2; typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
typedef __allocator_destructor<_A2> _D2; typedef __allocator_destructor<_A2> _D2;
_A2 __a2(__a); _A2 __a2(__a);
unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1)); unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
::new ((void*)_VSTD::addressof(*__hold2.get())) ::new ((void*)_VSTD::addressof(*__hold2.get()))
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
_CntrlBlk(__p, _VSTD::move(__d), __a); _CntrlBlk(__p, _VSTD::move(__d), __a);
#else #else
_CntrlBlk(__p, __d, __a); _CntrlBlk(__p, __d, __a);
#endif // not _LIBCPP_CXX03_LANG #endif // not _LIBCPP_CXX03_LANG
__cntrl_ = _VSTD::addressof(*__hold2.release()); __cntrl_ = _VSTD::addressof(*__hold2.release());
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__d(__p); __d(__p);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template<class _Yp> template<class _Yp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI
shared_ptr(const shared_ptr<_Yp>& __r, element_type *__p) _NOEXCEPT shared_ptr(const shared_ptr<_Yp>& __r, element_type *__p) _NOEXCEPT
: __ptr_(__p), : __ptr_(__p),
__cntrl_(__r.__cntrl_) __cntrl_(__r.__cntrl_)
{ {
▲ Show 20 Lines • Show All 1,447 Lines • Show Last 20 Lines

libcxx/include/__memory/uninitialized_algorithms.h

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
// uninitialized_copy // uninitialized_copy
template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _Sentinel2> template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _Sentinel2>
inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator> inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
__uninitialized_copy(_InputIterator __ifirst, _Sentinel1 __ilast, __uninitialized_copy(_InputIterator __ifirst, _Sentinel1 __ilast,
_ForwardIterator __ofirst, _Sentinel2 __olast) { _ForwardIterator __ofirst, _Sentinel2 __olast) {
_ForwardIterator __idx = __ofirst; _ForwardIterator __idx = __ofirst;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try { try {
#endif #endif
for (; __ifirst != __ilast && __idx != __olast; ++__ifirst, (void)++__idx) for (; __ifirst != __ilast && __idx != __olast; ++__ifirst, (void)++__idx)
::new (_VSTD::__voidify(*__idx)) _ValueType(*__ifirst); ::new (_VSTD::__voidify(*__idx)) _ValueType(*__ifirst);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) { } catch (...) {
_VSTD::__destroy(__ofirst, __idx); _VSTD::__destroy(__ofirst, __idx);
throw; throw;
} }
#endif #endif
return pair<_InputIterator, _ForwardIterator>(_VSTD::move(__ifirst), _VSTD::move(__idx)); return pair<_InputIterator, _ForwardIterator>(_VSTD::move(__ifirst), _VSTD::move(__idx));
} }
Show All 10 Lines
// uninitialized_copy_n // uninitialized_copy_n
template <class _ValueType, class _InputIterator, class _Size, class _ForwardIterator, class _Sentinel> template <class _ValueType, class _InputIterator, class _Size, class _ForwardIterator, class _Sentinel>
inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator> inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
__uninitialized_copy_n(_InputIterator __ifirst, _Size __n, __uninitialized_copy_n(_InputIterator __ifirst, _Size __n,
_ForwardIterator __ofirst, _Sentinel __olast) { _ForwardIterator __ofirst, _Sentinel __olast) {
_ForwardIterator __idx = __ofirst; _ForwardIterator __idx = __ofirst;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try { try {
#endif #endif
for (; __n > 0 && __idx != __olast; ++__ifirst, (void)++__idx, (void)--__n) for (; __n > 0 && __idx != __olast; ++__ifirst, (void)++__idx, (void)--__n)
::new (_VSTD::__voidify(*__idx)) _ValueType(*__ifirst); ::new (_VSTD::__voidify(*__idx)) _ValueType(*__ifirst);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) { } catch (...) {
_VSTD::__destroy(__ofirst, __idx); _VSTD::__destroy(__ofirst, __idx);
throw; throw;
} }
#endif #endif
return pair<_InputIterator, _ForwardIterator>(_VSTD::move(__ifirst), _VSTD::move(__idx)); return pair<_InputIterator, _ForwardIterator>(_VSTD::move(__ifirst), _VSTD::move(__idx));
} }
Show All 9 Lines
// uninitialized_fill // uninitialized_fill
template <class _ValueType, class _ForwardIterator, class _Sentinel, class _Tp> template <class _ValueType, class _ForwardIterator, class _Sentinel, class _Tp>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
_ForwardIterator __uninitialized_fill(_ForwardIterator __first, _Sentinel __last, const _Tp& __x) _ForwardIterator __uninitialized_fill(_ForwardIterator __first, _Sentinel __last, const _Tp& __x)
{ {
_ForwardIterator __idx = __first; _ForwardIterator __idx = __first;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif #endif
for (; __idx != __last; ++__idx) for (; __idx != __last; ++__idx)
::new (_VSTD::__voidify(*__idx)) _ValueType(__x); ::new (_VSTD::__voidify(*__idx)) _ValueType(__x);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
_VSTD::__destroy(__first, __idx); _VSTD::__destroy(__first, __idx);
throw; throw;
} }
#endif #endif
Show All 10 Lines
// uninitialized_fill_n // uninitialized_fill_n
template <class _ValueType, class _ForwardIterator, class _Size, class _Tp> template <class _ValueType, class _ForwardIterator, class _Size, class _Tp>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
_ForwardIterator __uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) _ForwardIterator __uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
{ {
_ForwardIterator __idx = __first; _ForwardIterator __idx = __first;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif #endif
for (; __n > 0; ++__idx, (void) --__n) for (; __n > 0; ++__idx, (void) --__n)
::new (_VSTD::__voidify(*__idx)) _ValueType(__x); ::new (_VSTD::__voidify(*__idx)) _ValueType(__x);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
_VSTD::__destroy(__first, __idx); _VSTD::__destroy(__first, __idx);
throw; throw;
} }
#endif #endif
Show All 11 Lines
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
// uninitialized_default_construct // uninitialized_default_construct
template <class _ValueType, class _ForwardIterator, class _Sentinel> template <class _ValueType, class _ForwardIterator, class _Sentinel>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
_ForwardIterator __uninitialized_default_construct(_ForwardIterator __first, _Sentinel __last) { _ForwardIterator __uninitialized_default_construct(_ForwardIterator __first, _Sentinel __last) {
auto __idx = __first; auto __idx = __first;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try { try {
#endif #endif
for (; __idx != __last; ++__idx) for (; __idx != __last; ++__idx)
::new (_VSTD::__voidify(*__idx)) _ValueType; ::new (_VSTD::__voidify(*__idx)) _ValueType;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) { } catch (...) {
_VSTD::__destroy(__first, __idx); _VSTD::__destroy(__first, __idx);
throw; throw;
} }
#endif #endif
return __idx; return __idx;
} }
template <class _ForwardIterator> template <class _ForwardIterator>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
void uninitialized_default_construct(_ForwardIterator __first, _ForwardIterator __last) { void uninitialized_default_construct(_ForwardIterator __first, _ForwardIterator __last) {
using _ValueType = typename iterator_traits<_ForwardIterator>::value_type; using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
(void)_VSTD::__uninitialized_default_construct<_ValueType>( (void)_VSTD::__uninitialized_default_construct<_ValueType>(
_VSTD::move(__first), _VSTD::move(__last)); _VSTD::move(__first), _VSTD::move(__last));
} }
// uninitialized_default_construct_n // uninitialized_default_construct_n
template <class _ValueType, class _ForwardIterator, class _Size> template <class _ValueType, class _ForwardIterator, class _Size>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
_ForwardIterator __uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) { _ForwardIterator __uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) {
auto __idx = __first; auto __idx = __first;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try { try {
#endif #endif
for (; __n > 0; ++__idx, (void) --__n) for (; __n > 0; ++__idx, (void) --__n)
::new (_VSTD::__voidify(*__idx)) _ValueType; ::new (_VSTD::__voidify(*__idx)) _ValueType;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) { } catch (...) {
_VSTD::__destroy(__first, __idx); _VSTD::__destroy(__first, __idx);
throw; throw;
} }
#endif #endif
return __idx; return __idx;
} }
template <class _ForwardIterator, class _Size> template <class _ForwardIterator, class _Size>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
_ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) { _ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) {
using _ValueType = typename iterator_traits<_ForwardIterator>::value_type; using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
return _VSTD::__uninitialized_default_construct_n<_ValueType>(_VSTD::move(__first), __n); return _VSTD::__uninitialized_default_construct_n<_ValueType>(_VSTD::move(__first), __n);
} }
// uninitialized_value_construct // uninitialized_value_construct
template <class _ValueType, class _ForwardIterator, class _Sentinel> template <class _ValueType, class _ForwardIterator, class _Sentinel>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
_ForwardIterator __uninitialized_value_construct(_ForwardIterator __first, _Sentinel __last) { _ForwardIterator __uninitialized_value_construct(_ForwardIterator __first, _Sentinel __last) {
auto __idx = __first; auto __idx = __first;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try { try {
#endif #endif
for (; __idx != __last; ++__idx) for (; __idx != __last; ++__idx)
::new (_VSTD::__voidify(*__idx)) _ValueType(); ::new (_VSTD::__voidify(*__idx)) _ValueType();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) { } catch (...) {
_VSTD::__destroy(__first, __idx); _VSTD::__destroy(__first, __idx);
throw; throw;
} }
#endif #endif
return __idx; return __idx;
} }
template <class _ForwardIterator> template <class _ForwardIterator>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last) { void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last) {
using _ValueType = typename iterator_traits<_ForwardIterator>::value_type; using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
(void)_VSTD::__uninitialized_value_construct<_ValueType>( (void)_VSTD::__uninitialized_value_construct<_ValueType>(
_VSTD::move(__first), _VSTD::move(__last)); _VSTD::move(__first), _VSTD::move(__last));
} }
// uninitialized_value_construct_n // uninitialized_value_construct_n
template <class _ValueType, class _ForwardIterator, class _Size> template <class _ValueType, class _ForwardIterator, class _Size>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
_ForwardIterator __uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) { _ForwardIterator __uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
auto __idx = __first; auto __idx = __first;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try { try {
#endif #endif
for (; __n > 0; ++__idx, (void) --__n) for (; __n > 0; ++__idx, (void) --__n)
::new (_VSTD::__voidify(*__idx)) _ValueType(); ::new (_VSTD::__voidify(*__idx)) _ValueType();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) { } catch (...) {
_VSTD::__destroy(__first, __idx); _VSTD::__destroy(__first, __idx);
throw; throw;
} }
#endif #endif
return __idx; return __idx;
} }
template <class _ForwardIterator, class _Size> template <class _ForwardIterator, class _Size>
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
_ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) { _ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
using _ValueType = typename iterator_traits<_ForwardIterator>::value_type; using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
return std::__uninitialized_value_construct_n<_ValueType>(_VSTD::move(__first), __n); return std::__uninitialized_value_construct_n<_ValueType>(_VSTD::move(__first), __n);
} }
// uninitialized_move // uninitialized_move
template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _Sentinel2, template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _Sentinel2,
class _IterMove> class _IterMove>
inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator> inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
__uninitialized_move(_InputIterator __ifirst, _Sentinel1 __ilast, __uninitialized_move(_InputIterator __ifirst, _Sentinel1 __ilast,
_ForwardIterator __ofirst, _Sentinel2 __olast, _IterMove __iter_move) { _ForwardIterator __ofirst, _Sentinel2 __olast, _IterMove __iter_move) {
auto __idx = __ofirst; auto __idx = __ofirst;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try { try {
#endif #endif
for (; __ifirst != __ilast && __idx != __olast; ++__idx, (void)++__ifirst) { for (; __ifirst != __ilast && __idx != __olast; ++__idx, (void)++__ifirst) {
::new (_VSTD::__voidify(*__idx)) _ValueType(__iter_move(__ifirst)); ::new (_VSTD::__voidify(*__idx)) _ValueType(__iter_move(__ifirst));
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) { } catch (...) {
_VSTD::__destroy(__ofirst, __idx); _VSTD::__destroy(__ofirst, __idx);
throw; throw;
} }
#endif #endif
return {_VSTD::move(__ifirst), _VSTD::move(__idx)}; return {_VSTD::move(__ifirst), _VSTD::move(__idx)};
} }
Show All 11 Lines
// uninitialized_move_n // uninitialized_move_n
template <class _ValueType, class _InputIterator, class _Size, class _ForwardIterator, class _Sentinel, class _IterMove> template <class _ValueType, class _InputIterator, class _Size, class _ForwardIterator, class _Sentinel, class _IterMove>
inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator> inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
__uninitialized_move_n(_InputIterator __ifirst, _Size __n, __uninitialized_move_n(_InputIterator __ifirst, _Size __n,
_ForwardIterator __ofirst, _Sentinel __olast, _IterMove __iter_move) { _ForwardIterator __ofirst, _Sentinel __olast, _IterMove __iter_move) {
auto __idx = __ofirst; auto __idx = __ofirst;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try { try {
#endif #endif
for (; __n > 0 && __idx != __olast; ++__idx, (void)++__ifirst, --__n) for (; __n > 0 && __idx != __olast; ++__idx, (void)++__ifirst, --__n)
::new (_VSTD::__voidify(*__idx)) _ValueType(__iter_move(__ifirst)); ::new (_VSTD::__voidify(*__idx)) _ValueType(__iter_move(__ifirst));
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) { } catch (...) {
_VSTD::__destroy(__ofirst, __idx); _VSTD::__destroy(__ofirst, __idx);
throw; throw;
} }
#endif #endif
return {_VSTD::move(__ifirst), _VSTD::move(__idx)}; return {_VSTD::move(__ifirst), _VSTD::move(__idx)};
} }
▲ Show 20 Lines • Show All 240 Lines • ▼ Show 20 Lines
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Iter2 __uninitialized_allocator_move_if_noexcept( _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Iter2 __uninitialized_allocator_move_if_noexcept(
_Alloc& __alloc, _Iter1 __first1, _Sent1 __last1, _Iter2 __first2) { _Alloc& __alloc, _Iter1 __first1, _Sent1 __last1, _Iter2 __first2) {
static_assert(__is_cpp17_move_insertable<_Alloc>::value, static_assert(__is_cpp17_move_insertable<_Alloc>::value,
"The specified type does not meet the requirements of Cpp17MoveInsertable"); "The specified type does not meet the requirements of Cpp17MoveInsertable");
auto __destruct_first = __first2; auto __destruct_first = __first2;
auto __guard = auto __guard =
std::__make_exception_guard(_AllocatorDestroyRangeReverse<_Alloc, _Iter2>(__alloc, __destruct_first, __first2)); std::__make_exception_guard(_AllocatorDestroyRangeReverse<_Alloc, _Iter2>(__alloc, __destruct_first, __first2));
while (__first1 != __last1) { while (__first1 != __last1) {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__first2), std::move_if_noexcept(*__first1)); allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__first2), std::move_if_noexcept(*__first1));
#else #else
allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__first2), std::move(*__first1)); allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__first2), std::move(*__first1));
#endif #endif
++__first1; ++__first1;
++__first2; ++__first2;
} }
__guard.__complete(); __guard.__complete();
Show All 35 Lines

libcxx/include/__split_buffer

Show First 20 Lines • Show All 457 Lines • ▼ Show 20 Lines
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
void void
__split_buffer<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT __split_buffer<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
{ {
if (capacity() > size()) if (capacity() > size())
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__split_buffer<value_type, __alloc_rr&> __t(size(), 0, __alloc()); __split_buffer<value_type, __alloc_rr&> __t(size(), 0, __alloc());
__t.__construct_at_end(move_iterator<pointer>(__begin_), __t.__construct_at_end(move_iterator<pointer>(__begin_),
move_iterator<pointer>(__end_)); move_iterator<pointer>(__end_));
__t.__end_ = __t.__begin_ + (__end_ - __begin_); __t.__end_ = __t.__begin_ + (__end_ - __begin_);
_VSTD::swap(__first_, __t.__first_); _VSTD::swap(__first_, __t.__first_);
_VSTD::swap(__begin_, __t.__begin_); _VSTD::swap(__begin_, __t.__begin_);
_VSTD::swap(__end_, __t.__end_); _VSTD::swap(__end_, __t.__end_);
_VSTD::swap(__end_cap(), __t.__end_cap()); _VSTD::swap(__end_cap(), __t.__end_cap());
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
void void
__split_buffer<_Tp, _Allocator>::push_front(const_reference __x) __split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
{ {
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

libcxx/include/__utility/exception_guard.h

Show All 35 Lines
// code with exceptions disabled, so even if we wanted to provide the strong exception guarantees // code with exceptions disabled, so even if we wanted to provide the strong exception guarantees
// we couldn't. This is also only relevant for constructs with a stack of // we couldn't. This is also only relevant for constructs with a stack of
// -fexceptions > -fno-exceptions > -fexceptions code, since the exception can't be caught where // -fexceptions > -fno-exceptions > -fexceptions code, since the exception can't be caught where
// exceptions are disabled. While -fexceptions > -fno-exceptions is quite common // exceptions are disabled. While -fexceptions > -fno-exceptions is quite common
// (e.g. libc++.dylib > -fno-exceptions), having another layer with exceptions enabled seems a lot // (e.g. libc++.dylib > -fno-exceptions), having another layer with exceptions enabled seems a lot
// less common, especially one that tries to catch an exception through -fno-exceptions code. // less common, especially one that tries to catch an exception through -fno-exceptions code.
// //
// __exception_guard can help greatly simplify code that would normally be cluttered by // __exception_guard can help greatly simplify code that would normally be cluttered by
// `#if _LIBCPP_NO_EXCEPTIONS`. For example: // `#if _LIBCPP_HAS_NO_EXCEPTIONS`. For example:
// //
// template <class Iterator, class Size, class OutputIterator> // template <class Iterator, class Size, class OutputIterator>
// Iterator uninitialized_copy_n(Iterator iter, Size n, OutputIterator out) { // Iterator uninitialized_copy_n(Iterator iter, Size n, OutputIterator out) {
// typedef typename iterator_traits<Iterator>::value_type value_type; // typedef typename iterator_traits<Iterator>::value_type value_type;
// __exception_guard guard([start=out, &out] { // __exception_guard guard([start=out, &out] {
// std::destroy(start, out); // std::destroy(start, out);
// }); // });
// //
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Linesstruct __exception_guard_noexceptions {
} }
private: private:
bool __completed_ = false; bool __completed_ = false;
}; };
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(__exception_guard_noexceptions); _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(__exception_guard_noexceptions);
#ifdef _LIBCPP_NO_EXCEPTIONS #ifdef _LIBCPP_HAS_NO_EXCEPTIONS
template <class _Rollback> template <class _Rollback>
using __exception_guard = __exception_guard_noexceptions<_Rollback>; using __exception_guard = __exception_guard_noexceptions<_Rollback>;
#else #else
template <class _Rollback> template <class _Rollback>
using __exception_guard = __exception_guard_exceptions<_Rollback>; using __exception_guard = __exception_guard_exceptions<_Rollback>;
#endif #endif
template <class _Rollback> template <class _Rollback>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __exception_guard<_Rollback> __make_exception_guard(_Rollback __rollback) { _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __exception_guard<_Rollback> __make_exception_guard(_Rollback __rollback) {
return __exception_guard<_Rollback>(std::move(__rollback)); return __exception_guard<_Rollback>(std::move(__rollback));
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___UTILITY_TRANSACTION_H #endif // _LIBCPP___UTILITY_TRANSACTION_H

libcxx/include/any

Show First 20 Lines • Show All 111 Lines • ▼ Show 20 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
void __throw_bad_any_cast() void __throw_bad_any_cast()
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw bad_any_cast(); throw bad_any_cast();
#else #else
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
// Forward declarations // Forward declarations
class _LIBCPP_TEMPLATE_VIS any; class _LIBCPP_TEMPLATE_VIS any;
▲ Show 20 Lines • Show All 584 Lines • Show Last 20 Lines

libcxx/include/deque

Show First 20 Lines • Show All 1,873 Lines • ▼ Show 20 Linesdeque<_Tp, _Allocator>::__add_front_capacity(size_type __n)
// Else need to allocate __nb buffers, *and* we need to reallocate __map_. // Else need to allocate __nb buffers, *and* we need to reallocate __map_.
else else
{ {
size_type __ds = (__nb + __back_capacity) * __block_size - __map_.empty(); size_type __ds = (__nb + __back_capacity) * __block_size - __map_.empty();
__split_buffer<pointer, __pointer_allocator&> __split_buffer<pointer, __pointer_allocator&>
__buf(std::max<size_type>(2* __map_.capacity(), __buf(std::max<size_type>(2* __map_.capacity(),
__nb + __map_.size()), __nb + __map_.size()),
0, __map_.__alloc()); 0, __map_.__alloc());
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (; __nb > 0; --__nb) for (; __nb > 0; --__nb)
__buf.push_back(__alloc_traits::allocate(__a, __block_size)); __buf.push_back(__alloc_traits::allocate(__a, __block_size));
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
for (__map_pointer __i = __buf.begin(); for (__map_pointer __i = __buf.begin();
__i != __buf.end(); ++__i) __i != __buf.end(); ++__i)
__alloc_traits::deallocate(__a, *__i, __block_size); __alloc_traits::deallocate(__a, *__i, __block_size);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (; __back_capacity > 0; --__back_capacity) for (; __back_capacity > 0; --__back_capacity)
{ {
__buf.push_back(__map_.back()); __buf.push_back(__map_.back());
__map_.pop_back(); __map_.pop_back();
} }
for (__map_pointer __i = __map_.begin(); for (__map_pointer __i = __map_.begin();
__i != __map_.end(); ++__i) __i != __map_.end(); ++__i)
__buf.push_back(*__i); __buf.push_back(*__i);
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Linesdeque<_Tp, _Allocator>::__add_back_capacity(size_type __n)
else else
{ {
size_type __ds = __front_capacity * __block_size; size_type __ds = __front_capacity * __block_size;
__split_buffer<pointer, __pointer_allocator&> __split_buffer<pointer, __pointer_allocator&>
__buf(std::max<size_type>(2* __map_.capacity(), __buf(std::max<size_type>(2* __map_.capacity(),
__nb + __map_.size()), __nb + __map_.size()),
__map_.size() - __front_capacity, __map_.size() - __front_capacity,
__map_.__alloc()); __map_.__alloc());
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (; __nb > 0; --__nb) for (; __nb > 0; --__nb)
__buf.push_back(__alloc_traits::allocate(__a, __block_size)); __buf.push_back(__alloc_traits::allocate(__a, __block_size));
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
for (__map_pointer __i = __buf.begin(); for (__map_pointer __i = __buf.begin();
__i != __buf.end(); ++__i) __i != __buf.end(); ++__i)
__alloc_traits::deallocate(__a, *__i, __block_size); __alloc_traits::deallocate(__a, *__i, __block_size);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (; __front_capacity > 0; --__front_capacity) for (; __front_capacity > 0; --__front_capacity)
{ {
__buf.push_back(__map_.front()); __buf.push_back(__map_.front());
__map_.pop_front(); __map_.pop_front();
} }
for (__map_pointer __i = __map_.end(); for (__map_pointer __i = __map_.end();
__i != __map_.begin();) __i != __map_.begin();)
__buf.push_front(*--__i); __buf.push_front(*--__i);
▲ Show 20 Lines • Show All 396 Lines • Show Last 20 Lines

libcxx/include/exception

Show First 20 Lines • Show All 215 Lines • ▼ Show 20 Linespublic:
friend _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT; friend _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
friend _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr); friend _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
}; };
template<class _Ep> template<class _Ep>
_LIBCPP_INLINE_VISIBILITY exception_ptr _LIBCPP_INLINE_VISIBILITY exception_ptr
make_exception_ptr(_Ep __e) _NOEXCEPT make_exception_ptr(_Ep __e) _NOEXCEPT
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
throw __e; throw __e;
} }
catch (...) catch (...)
{ {
return current_exception(); return current_exception();
} }
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
template <class _Tp> template <class _Tp>
struct __nested struct __nested
: public _Tp, : public _Tp,
public nested_exception public nested_exception
{ {
_LIBCPP_INLINE_VISIBILITY explicit __nested(const _Tp& __t) : _Tp(__t) {} _LIBCPP_INLINE_VISIBILITY explicit __nested(const _Tp& __t) : _Tp(__t) {}
}; };
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
template <class _Tp, class _Up, bool> template <class _Tp, class _Up, bool>
struct __throw_with_nested; struct __throw_with_nested;
template <class _Tp, class _Up> template <class _Tp, class _Up>
struct __throw_with_nested<_Tp, _Up, true> { struct __throw_with_nested<_Tp, _Up, true> {
_LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void
__do_throw(_Tp&& __t) __do_throw(_Tp&& __t)
{ {
Show All 15 Lines
}; };
#endif #endif
template <class _Tp> template <class _Tp>
_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
void void
throw_with_nested(_Tp&& __t) throw_with_nested(_Tp&& __t)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
typedef typename decay<_Tp>::type _Up; typedef typename decay<_Tp>::type _Up;
static_assert( is_copy_constructible<_Up>::value, "type thrown must be CopyConstructible"); static_assert( is_copy_constructible<_Up>::value, "type thrown must be CopyConstructible");
__throw_with_nested<_Tp, _Up, __throw_with_nested<_Tp, _Up,
is_class<_Up>::value && is_class<_Up>::value &&
!is_base_of<nested_exception, _Up>::value && !is_base_of<nested_exception, _Up>::value &&
!__libcpp_is_final<_Up>::value>:: !__libcpp_is_final<_Up>::value>::
__do_throw(static_cast<_Tp&&>(__t)); __do_throw(static_cast<_Tp&&>(__t));
#else #else
Show All 37 Lines

libcxx/include/forward_list

Show First 20 Lines • Show All 1,231 Lines • ▼ Show 20 Linesforward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
if (__n > 0) if (__n > 0)
{ {
__node_allocator& __a = base::__alloc(); __node_allocator& __a = base::__alloc();
typedef __allocator_destructor<__node_allocator> _Dp; typedef __allocator_destructor<__node_allocator> _Dp;
unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1)); unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v); __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
__node_pointer __first = __h.release(); __node_pointer __first = __h.release();
__node_pointer __last = __first; __node_pointer __last = __first;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (--__n; __n != 0; --__n, __last = __last->__next_) for (--__n; __n != 0; --__n, __last = __last->__next_)
{ {
__h.reset(__node_traits::allocate(__a, 1)); __h.reset(__node_traits::allocate(__a, 1));
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v); __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
__last->__next_ = __h.release(); __last->__next_ = __h.release();
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
while (__first != nullptr) while (__first != nullptr)
{ {
__node_pointer __next = __first->__next_; __node_pointer __next = __first->__next_;
__node_traits::destroy(__a, _VSTD::addressof(__first->__value_)); __node_traits::destroy(__a, _VSTD::addressof(__first->__value_));
__node_traits::deallocate(__a, __first, 1); __node_traits::deallocate(__a, __first, 1);
__first = __next; __first = __next;
} }
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__last->__next_ = __r->__next_; __last->__next_ = __r->__next_;
__r->__next_ = __first; __r->__next_ = __first;
__r = static_cast<__begin_node_pointer>(__last); __r = static_cast<__begin_node_pointer>(__last);
} }
return iterator(__r); return iterator(__r);
} }
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
template <class _InputIterator> template <class _InputIterator>
__enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value, typename forward_list<_Tp, _Alloc>::iterator> __enable_if_t<__is_cpp17_input_iterator<_InputIterator>::value, typename forward_list<_Tp, _Alloc>::iterator>
forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
_InputIterator __f, _InputIterator __l) _InputIterator __f, _InputIterator __l)
{ {
__begin_node_pointer __r = __p.__get_begin(); __begin_node_pointer __r = __p.__get_begin();
if (__f != __l) if (__f != __l)
{ {
__node_allocator& __a = base::__alloc(); __node_allocator& __a = base::__alloc();
typedef __allocator_destructor<__node_allocator> _Dp; typedef __allocator_destructor<__node_allocator> _Dp;
unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1)); unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f); __node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f);
__node_pointer __first = __h.release(); __node_pointer __first = __h.release();
__node_pointer __last = __first; __node_pointer __last = __first;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (++__f; __f != __l; ++__f, ((void)(__last = __last->__next_))) for (++__f; __f != __l; ++__f, ((void)(__last = __last->__next_)))
{ {
__h.reset(__node_traits::allocate(__a, 1)); __h.reset(__node_traits::allocate(__a, 1));
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f); __node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f);
__last->__next_ = __h.release(); __last->__next_ = __h.release();
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
while (__first != nullptr) while (__first != nullptr)
{ {
__node_pointer __next = __first->__next_; __node_pointer __next = __first->__next_;
__node_traits::destroy(__a, _VSTD::addressof(__first->__value_)); __node_traits::destroy(__a, _VSTD::addressof(__first->__value_));
__node_traits::deallocate(__a, __first, 1); __node_traits::deallocate(__a, __first, 1);
__first = __next; __first = __next;
} }
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__last->__next_ = __r->__next_; __last->__next_ = __r->__next_;
__r->__next_ = __first; __r->__next_ = __first;
__r = static_cast<__begin_node_pointer>(__last); __r = static_cast<__begin_node_pointer>(__last);
} }
return iterator(__r); return iterator(__r);
} }
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
▲ Show 20 Lines • Show All 486 Lines • Show Last 20 Lines

libcxx/include/fstream

Show First 20 Lines • Show All 392 Lines • ▼ Show 20 Linesbasic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs)
close(); close();
swap(__rhs); swap(__rhs);
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_filebuf<_CharT, _Traits>::~basic_filebuf() basic_filebuf<_CharT, _Traits>::~basic_filebuf()
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
close(); close();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
if (__owns_eb_) if (__owns_eb_)
delete [] __extbuf_; delete [] __extbuf_;
if (__owns_ib_) if (__owns_ib_)
delete [] __intbuf_; delete [] __intbuf_;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
void void
▲ Show 20 Lines • Show All 1,344 Lines • Show Last 20 Lines

libcxx/include/future

Show First 20 Lines • Show All 514 Lines • ▼ Show 20 Linespublic:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
const error_code& code() const _NOEXCEPT {return __ec_;} const error_code& code() const _NOEXCEPT {return __ec_;}
future_error(const future_error&) _NOEXCEPT = default; future_error(const future_error&) _NOEXCEPT = default;
~future_error() _NOEXCEPT override; ~future_error() _NOEXCEPT override;
}; };
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
_LIBCPP_AVAILABILITY_FUTURE_ERROR _LIBCPP_AVAILABILITY_FUTURE_ERROR
#endif #endif
void __throw_future_error(future_errc __ev) void __throw_future_error(future_errc __ev)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw future_error(make_error_code(__ev)); throw future_error(make_error_code(__ev));
#else #else
((void)__ev); ((void)__ev);
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state
▲ Show 20 Lines • Show All 327 Lines • ▼ Show 20 Lines
{ {
this->__set_deferred(); this->__set_deferred();
} }
template <class _Rp, class _Fp> template <class _Rp, class _Fp>
void void
__deferred_assoc_state<_Rp, _Fp>::__execute() __deferred_assoc_state<_Rp, _Fp>::__execute()
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
this->set_value(__func_()); this->set_value(__func_());
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->set_exception(current_exception()); this->set_exception(current_exception());
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template <class _Fp> template <class _Fp>
class _LIBCPP_AVAILABILITY_FUTURE __deferred_assoc_state<void, _Fp> class _LIBCPP_AVAILABILITY_FUTURE __deferred_assoc_state<void, _Fp>
: public __assoc_sub_state : public __assoc_sub_state
{ {
typedef __assoc_sub_state base; typedef __assoc_sub_state base;
Show All 13 Lines
{ {
this->__set_deferred(); this->__set_deferred();
} }
template <class _Fp> template <class _Fp>
void void
__deferred_assoc_state<void, _Fp>::__execute() __deferred_assoc_state<void, _Fp>::__execute()
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__func_(); __func_();
this->set_value(); this->set_value();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->set_exception(current_exception()); this->set_exception(current_exception());
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template <class _Rp, class _Fp> template <class _Rp, class _Fp>
class _LIBCPP_AVAILABILITY_FUTURE __async_assoc_state class _LIBCPP_AVAILABILITY_FUTURE __async_assoc_state
: public __assoc_state<_Rp> : public __assoc_state<_Rp>
{ {
typedef __assoc_state<_Rp> base; typedef __assoc_state<_Rp> base;
Show All 13 Lines__async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f)
: __func_(_VSTD::forward<_Fp>(__f)) : __func_(_VSTD::forward<_Fp>(__f))
{ {
} }
template <class _Rp, class _Fp> template <class _Rp, class _Fp>
void void
__async_assoc_state<_Rp, _Fp>::__execute() __async_assoc_state<_Rp, _Fp>::__execute()
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
this->set_value(__func_()); this->set_value(__func_());
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->set_exception(current_exception()); this->set_exception(current_exception());
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template <class _Rp, class _Fp> template <class _Rp, class _Fp>
void void
__async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT __async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT
{ {
this->wait(); this->wait();
base::__on_zero_shared(); base::__on_zero_shared();
Show All 21 Lines__async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f)
: __func_(_VSTD::forward<_Fp>(__f)) : __func_(_VSTD::forward<_Fp>(__f))
{ {
} }
template <class _Fp> template <class _Fp>
void void
__async_assoc_state<void, _Fp>::__execute() __async_assoc_state<void, _Fp>::__execute()
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__func_(); __func_();
this->set_value(); this->set_value();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->set_exception(current_exception()); this->set_exception(current_exception());
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template <class _Fp> template <class _Fp>
void void
__async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT __async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT
{ {
this->wait(); this->wait();
base::__on_zero_shared(); base::__on_zero_shared();
▲ Show 20 Lines • Show All 920 Lines • ▼ Show 20 Lines
template<class _Rp, class ..._ArgTypes> template<class _Rp, class ..._ArgTypes>
void void
packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args) packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args)
{ {
if (__p_.__state_ == nullptr) if (__p_.__state_ == nullptr)
__throw_future_error(future_errc::no_state); __throw_future_error(future_errc::no_state);
if (__p_.__state_->__has_value()) if (__p_.__state_->__has_value())
__throw_future_error(future_errc::promise_already_satisfied); __throw_future_error(future_errc::promise_already_satisfied);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...)); __p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...));
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__p_.set_exception(current_exception()); __p_.set_exception(current_exception());
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template<class _Rp, class ..._ArgTypes> template<class _Rp, class ..._ArgTypes>
void void
packaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args) packaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
{ {
if (__p_.__state_ == nullptr) if (__p_.__state_ == nullptr)
__throw_future_error(future_errc::no_state); __throw_future_error(future_errc::no_state);
if (__p_.__state_->__has_value()) if (__p_.__state_->__has_value())
__throw_future_error(future_errc::promise_already_satisfied); __throw_future_error(future_errc::promise_already_satisfied);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...)); __p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...));
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__p_.set_exception_at_thread_exit(current_exception()); __p_.set_exception_at_thread_exit(current_exception());
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template<class _Rp, class ..._ArgTypes> template<class _Rp, class ..._ArgTypes>
void void
packaged_task<_Rp(_ArgTypes...)>::reset() packaged_task<_Rp(_ArgTypes...)>::reset()
{ {
if (!valid()) if (!valid())
__throw_future_error(future_errc::no_state); __throw_future_error(future_errc::no_state);
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
template<class ..._ArgTypes> template<class ..._ArgTypes>
void void
packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args) packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args)
{ {
if (__p_.__state_ == nullptr) if (__p_.__state_ == nullptr)
__throw_future_error(future_errc::no_state); __throw_future_error(future_errc::no_state);
if (__p_.__state_->__has_value()) if (__p_.__state_->__has_value())
__throw_future_error(future_errc::promise_already_satisfied); __throw_future_error(future_errc::promise_already_satisfied);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__f_(_VSTD::forward<_ArgTypes>(__args)...); __f_(_VSTD::forward<_ArgTypes>(__args)...);
__p_.set_value(); __p_.set_value();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__p_.set_exception(current_exception()); __p_.set_exception(current_exception());
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template<class ..._ArgTypes> template<class ..._ArgTypes>
void void
packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args) packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
{ {
if (__p_.__state_ == nullptr) if (__p_.__state_ == nullptr)
__throw_future_error(future_errc::no_state); __throw_future_error(future_errc::no_state);
if (__p_.__state_->__has_value()) if (__p_.__state_->__has_value())
__throw_future_error(future_errc::promise_already_satisfied); __throw_future_error(future_errc::promise_already_satisfied);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__f_(_VSTD::forward<_ArgTypes>(__args)...); __f_(_VSTD::forward<_ArgTypes>(__args)...);
__p_.set_value_at_thread_exit(); __p_.set_value_at_thread_exit();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__p_.set_exception_at_thread_exit(current_exception()); __p_.set_exception_at_thread_exit(current_exception());
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template<class ..._ArgTypes> template<class ..._ArgTypes>
void void
packaged_task<void(_ArgTypes...)>::reset() packaged_task<void(_ArgTypes...)>::reset()
{ {
if (!valid()) if (!valid())
__throw_future_error(future_errc::no_state); __throw_future_error(future_errc::no_state);
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
template <class _Fp, class... _Args> template <class _Fp, class... _Args>
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI
future<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type> future<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type>
async(launch __policy, _Fp&& __f, _Args&&... __args) async(launch __policy, _Fp&& __f, _Args&&... __args)
{ {
typedef __async_func<typename decay<_Fp>::type, typename decay<_Args>::type...> _BF; typedef __async_func<typename decay<_Fp>::type, typename decay<_Args>::type...> _BF;
typedef typename _BF::_Rp _Rp; typedef typename _BF::_Rp _Rp;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif #endif
if (__does_policy_contain(__policy, launch::async)) if (__does_policy_contain(__policy, launch::async))
return _VSTD::__make_async_assoc_state<_Rp>(_BF(_LIBCPP_AUTO_CAST(_VSTD::forward<_Fp>(__f)), return _VSTD::__make_async_assoc_state<_Rp>(_BF(_LIBCPP_AUTO_CAST(_VSTD::forward<_Fp>(__f)),
_LIBCPP_AUTO_CAST(_VSTD::forward<_Args>(__args))...)); _LIBCPP_AUTO_CAST(_VSTD::forward<_Args>(__args))...));
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch ( ... ) { if (__policy == launch::async) throw ; } catch ( ... ) { if (__policy == launch::async) throw ; }
#endif #endif
if (__does_policy_contain(__policy, launch::deferred)) if (__does_policy_contain(__policy, launch::deferred))
return _VSTD::__make_deferred_assoc_state<_Rp>(_BF(_LIBCPP_AUTO_CAST(_VSTD::forward<_Fp>(__f)), return _VSTD::__make_deferred_assoc_state<_Rp>(_BF(_LIBCPP_AUTO_CAST(_VSTD::forward<_Fp>(__f)),
_LIBCPP_AUTO_CAST(_VSTD::forward<_Args>(__args))...)); _LIBCPP_AUTO_CAST(_VSTD::forward<_Args>(__args))...));
return future<_Rp>{}; return future<_Rp>{};
▲ Show 20 Lines • Show All 244 Lines • Show Last 20 Lines

libcxx/include/iomanip

Show First 20 Lines • Show All 295 Lines • ▼ Show 20 Linespublic:
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_Mp>& __x); operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_Mp>& __x);
}; };
template <class _CharT, class _Traits, class _MoneyT> template <class _CharT, class _Traits, class _MoneyT>
_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x) operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typename basic_istream<_CharT, _Traits>::sentry __s(__is); typename basic_istream<_CharT, _Traits>::sentry __s(__is);
if (__s) if (__s)
{ {
typedef istreambuf_iterator<_CharT, _Traits> _Ip; typedef istreambuf_iterator<_CharT, _Traits> _Ip;
typedef money_get<_CharT, _Ip> _Fp; typedef money_get<_CharT, _Ip> _Fp;
ios_base::iostate __err = ios_base::goodbit; ios_base::iostate __err = ios_base::goodbit;
const _Fp& __mf = std::use_facet<_Fp>(__is.getloc()); const _Fp& __mf = std::use_facet<_Fp>(__is.getloc());
__mf.get(_Ip(__is), _Ip(), __x.__intl_, __is, __err, __x.__mon_); __mf.get(_Ip(__is), _Ip(), __x.__intl_, __is, __err, __x.__mon_);
__is.setstate(__err); __is.setstate(__err);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__is.__set_badbit_and_consider_rethrow(); __is.__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return __is; return __is;
} }
template <class _MoneyT> template <class _MoneyT>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
__iom_t7<_MoneyT> __iom_t7<_MoneyT>
get_money(_MoneyT& __mon, bool __intl = false) get_money(_MoneyT& __mon, bool __intl = false)
{ {
Show All 23 Linespublic:
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_Mp>& __x); operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_Mp>& __x);
}; };
template <class _CharT, class _Traits, class _MoneyT> template <class _CharT, class _Traits, class _MoneyT>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x) operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typename basic_ostream<_CharT, _Traits>::sentry __s(__os); typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
if (__s) if (__s)
{ {
typedef ostreambuf_iterator<_CharT, _Traits> _Op; typedef ostreambuf_iterator<_CharT, _Traits> _Op;
typedef money_put<_CharT, _Op> _Fp; typedef money_put<_CharT, _Op> _Fp;
const _Fp& __mf = std::use_facet<_Fp>(__os.getloc()); const _Fp& __mf = std::use_facet<_Fp>(__os.getloc());
if (__mf.put(_Op(__os), __x.__intl_, __os, __os.fill(), __x.__mon_).failed()) if (__mf.put(_Op(__os), __x.__intl_, __os, __os.fill(), __x.__mon_).failed())
__os.setstate(ios_base::badbit); __os.setstate(ios_base::badbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__os.__set_badbit_and_consider_rethrow(); __os.__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return __os; return __os;
} }
template <class _MoneyT> template <class _MoneyT>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
__iom_t8<_MoneyT> __iom_t8<_MoneyT>
put_money(const _MoneyT& __mon, bool __intl = false) put_money(const _MoneyT& __mon, bool __intl = false)
{ {
Show All 23 Linespublic:
basic_istream<_Cp, _Traits>& basic_istream<_Cp, _Traits>&
operator>>(basic_istream<_Cp, _Traits>& __is, const __iom_t9<_Cp>& __x); operator>>(basic_istream<_Cp, _Traits>& __is, const __iom_t9<_Cp>& __x);
}; };
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x) operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typename basic_istream<_CharT, _Traits>::sentry __s(__is); typename basic_istream<_CharT, _Traits>::sentry __s(__is);
if (__s) if (__s)
{ {
typedef istreambuf_iterator<_CharT, _Traits> _Ip; typedef istreambuf_iterator<_CharT, _Traits> _Ip;
typedef time_get<_CharT, _Ip> _Fp; typedef time_get<_CharT, _Ip> _Fp;
ios_base::iostate __err = ios_base::goodbit; ios_base::iostate __err = ios_base::goodbit;
const _Fp& __tf = std::use_facet<_Fp>(__is.getloc()); const _Fp& __tf = std::use_facet<_Fp>(__is.getloc());
__tf.get(_Ip(__is), _Ip(), __is, __err, __x.__tm_, __tf.get(_Ip(__is), _Ip(), __is, __err, __x.__tm_,
__x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_)); __x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_));
__is.setstate(__err); __is.setstate(__err);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__is.__set_badbit_and_consider_rethrow(); __is.__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return __is; return __is;
} }
template <class _CharT> template <class _CharT>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
__iom_t9<_CharT> __iom_t9<_CharT>
get_time(tm* __tm, const _CharT* __fmt) get_time(tm* __tm, const _CharT* __fmt)
{ {
Show All 23 Linespublic:
basic_ostream<_Cp, _Traits>& basic_ostream<_Cp, _Traits>&
operator<<(basic_ostream<_Cp, _Traits>& __os, const __iom_t10<_Cp>& __x); operator<<(basic_ostream<_Cp, _Traits>& __os, const __iom_t10<_Cp>& __x);
}; };
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x) operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typename basic_ostream<_CharT, _Traits>::sentry __s(__os); typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
if (__s) if (__s)
{ {
typedef ostreambuf_iterator<_CharT, _Traits> _Op; typedef ostreambuf_iterator<_CharT, _Traits> _Op;
typedef time_put<_CharT, _Op> _Fp; typedef time_put<_CharT, _Op> _Fp;
const _Fp& __tf = std::use_facet<_Fp>(__os.getloc()); const _Fp& __tf = std::use_facet<_Fp>(__os.getloc());
if (__tf.put(_Op(__os), __os, __os.fill(), __x.__tm_, if (__tf.put(_Op(__os), __os, __os.fill(), __x.__tm_,
__x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_)).failed()) __x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_)).failed())
__os.setstate(ios_base::badbit); __os.setstate(ios_base::badbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__os.__set_badbit_and_consider_rethrow(); __os.__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return __os; return __os;
} }
template <class _CharT> template <class _CharT>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
__iom_t10<_CharT> __iom_t10<_CharT>
put_time(const tm* __tm, const _CharT* __fmt) put_time(const tm* __tm, const _CharT* __fmt)
{ {
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

libcxx/include/ios

Show First 20 Lines • Show All 442 Lines • ▼ Show 20 Linespublic:
explicit failure(const string& __msg, const error_code& __ec = io_errc::stream); explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);
explicit failure(const char* __msg, const error_code& __ec = io_errc::stream); explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);
failure(const failure&) _NOEXCEPT = default; failure(const failure&) _NOEXCEPT = default;
~failure() _NOEXCEPT override; ~failure() _NOEXCEPT override;
}; };
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
void __throw_failure(char const* __msg) { void __throw_failure(char const* __msg) {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw ios_base::failure(__msg); throw ios_base::failure(__msg);
#else #else
((void)__msg); ((void)__msg);
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
class _LIBCPP_TYPE_VIS ios_base::Init class _LIBCPP_TYPE_VIS ios_base::Init
▲ Show 20 Lines • Show All 595 Lines • Show Last 20 Lines

libcxx/include/istream

Show First 20 Lines • Show All 354 Lines • ▼ Show 20 Lines
template <class _Tp, class _CharT, class _Traits> template <class _Tp, class _CharT, class _Traits>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
__input_arithmetic(basic_istream<_CharT, _Traits>& __is, _Tp& __n) { __input_arithmetic(basic_istream<_CharT, _Traits>& __is, _Tp& __n) {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
typename basic_istream<_CharT, _Traits>::sentry __s(__is); typename basic_istream<_CharT, _Traits>::sentry __s(__is);
if (__s) if (__s)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typedef istreambuf_iterator<_CharT, _Traits> _Ip; typedef istreambuf_iterator<_CharT, _Traits> _Ip;
typedef num_get<_CharT, _Ip> _Fp; typedef num_get<_CharT, _Ip> _Fp;
std::use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __n); std::use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __n);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
__is.__setstate_nothrow(__state); __is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit) if (__is.exceptions() & ios_base::badbit)
{ {
throw; throw;
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
template <class _Tp, class _CharT, class _Traits> template <class _Tp, class _CharT, class _Traits>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
__input_arithmetic_with_numeric_limits(basic_istream<_CharT, _Traits>& __is, _Tp& __n) { __input_arithmetic_with_numeric_limits(basic_istream<_CharT, _Traits>& __is, _Tp& __n) {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
typename basic_istream<_CharT, _Traits>::sentry __s(__is); typename basic_istream<_CharT, _Traits>::sentry __s(__is);
if (__s) if (__s)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typedef istreambuf_iterator<_CharT, _Traits> _Ip; typedef istreambuf_iterator<_CharT, _Traits> _Ip;
typedef num_get<_CharT, _Ip> _Fp; typedef num_get<_CharT, _Ip> _Fp;
long __temp; long __temp;
std::use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __temp); std::use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __temp);
if (__temp < numeric_limits<_Tp>::min()) if (__temp < numeric_limits<_Tp>::min())
{ {
__state |= ios_base::failbit; __state |= ios_base::failbit;
__n = numeric_limits<_Tp>::min(); __n = numeric_limits<_Tp>::min();
} }
else if (__temp > numeric_limits<_Tp>::max()) else if (__temp > numeric_limits<_Tp>::max())
{ {
__state |= ios_base::failbit; __state |= ios_base::failbit;
__n = numeric_limits<_Tp>::max(); __n = numeric_limits<_Tp>::max();
} }
else else
{ {
__n = static_cast<_Tp>(__temp); __n = static_cast<_Tp>(__temp);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
__is.__setstate_nothrow(__state); __is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit) if (__is.exceptions() & ios_base::badbit)
{ {
throw; throw;
} }
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__is.setstate(__state); __is.setstate(__state);
} }
return __is; return __is;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::operator>>(short& __n) basic_istream<_CharT, _Traits>::operator>>(short& __n)
Show All 12 Lines
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
__input_c_string(basic_istream<_CharT, _Traits>& __is, _CharT* __p, size_t __n) __input_c_string(basic_istream<_CharT, _Traits>& __is, _CharT* __p, size_t __n)
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
typename basic_istream<_CharT, _Traits>::sentry __sen(__is); typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif #endif
_CharT* __s = __p; _CharT* __s = __p;
const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc()); const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
while (__s != __p + (__n-1)) while (__s != __p + (__n-1))
{ {
typename _Traits::int_type __i = __is.rdbuf()->sgetc(); typename _Traits::int_type __i = __is.rdbuf()->sgetc();
if (_Traits::eq_int_type(__i, _Traits::eof())) if (_Traits::eq_int_type(__i, _Traits::eof()))
{ {
__state |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
_CharT __ch = _Traits::to_char_type(__i); _CharT __ch = _Traits::to_char_type(__i);
if (__ct.is(__ct.space, __ch)) if (__ct.is(__ct.space, __ch))
break; break;
*__s++ = __ch; *__s++ = __ch;
__is.rdbuf()->sbumpc(); __is.rdbuf()->sbumpc();
} }
*__s = _CharT(); *__s = _CharT();
__is.width(0); __is.width(0);
if (__s == __p) if (__s == __p)
__state |= ios_base::failbit; __state |= ios_base::failbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
__is.__setstate_nothrow(__state); __is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit) if (__is.exceptions() & ios_base::badbit)
{ {
throw; throw;
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c) operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c)
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
typename basic_istream<_CharT, _Traits>::sentry __sen(__is); typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif #endif
typename _Traits::int_type __i = __is.rdbuf()->sbumpc(); typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
if (_Traits::eq_int_type(__i, _Traits::eof())) if (_Traits::eq_int_type(__i, _Traits::eof()))
__state |= ios_base::eofbit | ios_base::failbit; __state |= ios_base::eofbit | ios_base::failbit;
else else
__c = _Traits::to_char_type(__i); __c = _Traits::to_char_type(__i);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
__is.__setstate_nothrow(__state); __is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit) if (__is.exceptions() & ios_base::badbit)
{ {
throw; throw;
Show All 27 Lines
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
sentry __s(*this, true); sentry __s(*this, true);
if (__s) if (__s)
{ {
if (__sb) if (__sb)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
while (true) while (true)
{ {
typename traits_type::int_type __i = this->rdbuf()->sgetc(); typename traits_type::int_type __i = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__i, _Traits::eof())) if (traits_type::eq_int_type(__i, _Traits::eof()))
{ {
__state |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
if (traits_type::eq_int_type( if (traits_type::eq_int_type(
__sb->sputc(traits_type::to_char_type(__i)), __sb->sputc(traits_type::to_char_type(__i)),
traits_type::eof())) traits_type::eof()))
break; break;
++__gc_; ++__gc_;
this->rdbuf()->sbumpc(); this->rdbuf()->sbumpc();
} }
if (__gc_ == 0) if (__gc_ == 0)
__state |= ios_base::failbit; __state |= ios_base::failbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
if (__gc_ == 0) if (__gc_ == 0)
__state |= ios_base::failbit; __state |= ios_base::failbit;
this->__setstate_nothrow(__state); this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::failbit || this->exceptions() & ios_base::badbit) if (this->exceptions() & ios_base::failbit || this->exceptions() & ios_base::badbit)
{ {
throw; throw;
} }
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
else else
{ {
__state |= ios_base::failbit; __state |= ios_base::failbit;
} }
this->setstate(__state); this->setstate(__state);
} }
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
typename basic_istream<_CharT, _Traits>::int_type typename basic_istream<_CharT, _Traits>::int_type
basic_istream<_CharT, _Traits>::get() basic_istream<_CharT, _Traits>::get()
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
int_type __r = traits_type::eof(); int_type __r = traits_type::eof();
sentry __s(*this, true); sentry __s(*this, true);
if (__s) if (__s)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif #endif
__r = this->rdbuf()->sbumpc(); __r = this->rdbuf()->sbumpc();
if (traits_type::eq_int_type(__r, traits_type::eof())) if (traits_type::eq_int_type(__r, traits_type::eof()))
__state |= ios_base::failbit | ios_base::eofbit; __state |= ios_base::failbit | ios_base::eofbit;
else else
__gc_ = 1; __gc_ = 1;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__setstate_nothrow(this->rdstate() | ios_base::badbit); this->__setstate_nothrow(this->rdstate() | ios_base::badbit);
if (this->exceptions() & ios_base::badbit) if (this->exceptions() & ios_base::badbit)
{ {
throw; throw;
} }
Show All 10 Lines
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
if (__n > 0) if (__n > 0)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif #endif
while (__gc_ < __n-1) while (__gc_ < __n-1)
{ {
int_type __i = this->rdbuf()->sgetc(); int_type __i = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__i, traits_type::eof())) if (traits_type::eq_int_type(__i, traits_type::eof()))
{ {
__state |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
char_type __ch = traits_type::to_char_type(__i); char_type __ch = traits_type::to_char_type(__i);
if (traits_type::eq(__ch, __dlm)) if (traits_type::eq(__ch, __dlm))
break; break;
*__s++ = __ch; *__s++ = __ch;
++__gc_; ++__gc_;
this->rdbuf()->sbumpc(); this->rdbuf()->sbumpc();
} }
if (__gc_ == 0) if (__gc_ == 0)
__state |= ios_base::failbit; __state |= ios_base::failbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
this->__setstate_nothrow(__state); this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit) if (this->exceptions() & ios_base::badbit)
{ {
if (__n > 0) if (__n > 0)
Show All 22 Lines
basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __sb, basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __sb,
char_type __dlm) char_type __dlm)
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
while (true) while (true)
{ {
typename traits_type::int_type __i = this->rdbuf()->sgetc(); typename traits_type::int_type __i = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__i, traits_type::eof())) if (traits_type::eq_int_type(__i, traits_type::eof()))
{ {
__state |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
char_type __ch = traits_type::to_char_type(__i); char_type __ch = traits_type::to_char_type(__i);
if (traits_type::eq(__ch, __dlm)) if (traits_type::eq(__ch, __dlm))
break; break;
if (traits_type::eq_int_type(__sb.sputc(__ch), traits_type::eof())) if (traits_type::eq_int_type(__sb.sputc(__ch), traits_type::eof()))
break; break;
++__gc_; ++__gc_;
this->rdbuf()->sbumpc(); this->rdbuf()->sbumpc();
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
// according to the spec, exceptions here are caught but not rethrown // according to the spec, exceptions here are caught but not rethrown
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
if (__gc_ == 0) if (__gc_ == 0)
__state |= ios_base::failbit; __state |= ios_base::failbit;
this->setstate(__state); this->setstate(__state);
} }
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_type __dlm) basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_type __dlm)
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
while (true) while (true)
{ {
typename traits_type::int_type __i = this->rdbuf()->sgetc(); typename traits_type::int_type __i = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__i, traits_type::eof())) if (traits_type::eq_int_type(__i, traits_type::eof()))
{ {
__state |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
char_type __ch = traits_type::to_char_type(__i); char_type __ch = traits_type::to_char_type(__i);
if (traits_type::eq(__ch, __dlm)) if (traits_type::eq(__ch, __dlm))
{ {
this->rdbuf()->sbumpc(); this->rdbuf()->sbumpc();
++__gc_; ++__gc_;
break; break;
} }
if (__gc_ >= __n-1) if (__gc_ >= __n-1)
{ {
__state |= ios_base::failbit; __state |= ios_base::failbit;
break; break;
} }
*__s++ = __ch; *__s++ = __ch;
this->rdbuf()->sbumpc(); this->rdbuf()->sbumpc();
++__gc_; ++__gc_;
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
this->__setstate_nothrow(__state); this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit) if (this->exceptions() & ios_base::badbit)
{ {
if (__n > 0) if (__n > 0)
*__s = char_type(); *__s = char_type();
if (__gc_ == 0) if (__gc_ == 0)
__state |= ios_base::failbit; __state |= ios_base::failbit;
throw; throw;
} }
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
if (__n > 0) if (__n > 0)
*__s = char_type(); *__s = char_type();
if (__gc_ == 0) if (__gc_ == 0)
__state |= ios_base::failbit; __state |= ios_base::failbit;
this->setstate(__state); this->setstate(__state);
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm) basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm)
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
if (__n == numeric_limits<streamsize>::max()) if (__n == numeric_limits<streamsize>::max())
{ {
while (true) while (true)
{ {
typename traits_type::int_type __i = this->rdbuf()->sbumpc(); typename traits_type::int_type __i = this->rdbuf()->sbumpc();
if (traits_type::eq_int_type(__i, traits_type::eof())) if (traits_type::eq_int_type(__i, traits_type::eof()))
{ {
__state |= ios_base::eofbit; __state |= ios_base::eofbit;
Show All 14 Lines#endif // _LIBCPP_HAS_NO_EXCEPTIONS
__state |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
++__gc_; ++__gc_;
if (traits_type::eq_int_type(__i, __dlm)) if (traits_type::eq_int_type(__i, __dlm))
break; break;
} }
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
this->__setstate_nothrow(__state); this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit) if (this->exceptions() & ios_base::badbit)
{ {
throw; throw;
} }
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
this->setstate(__state); this->setstate(__state);
} }
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
typename basic_istream<_CharT, _Traits>::int_type typename basic_istream<_CharT, _Traits>::int_type
basic_istream<_CharT, _Traits>::peek() basic_istream<_CharT, _Traits>::peek()
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
int_type __r = traits_type::eof(); int_type __r = traits_type::eof();
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__r = this->rdbuf()->sgetc(); __r = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__r, traits_type::eof())) if (traits_type::eq_int_type(__r, traits_type::eof()))
__state |= ios_base::eofbit; __state |= ios_base::eofbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
this->__setstate_nothrow(__state); this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit) if (this->exceptions() & ios_base::badbit)
{ {
throw; throw;
} }
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
this->setstate(__state); this->setstate(__state);
} }
return __r; return __r;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n) basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n)
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__gc_ = this->rdbuf()->sgetn(__s, __n); __gc_ = this->rdbuf()->sgetn(__s, __n);
if (__gc_ != __n) if (__gc_ != __n)
__state |= ios_base::failbit | ios_base::eofbit; __state |= ios_base::failbit | ios_base::eofbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
this->__setstate_nothrow(__state); this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit) if (this->exceptions() & ios_base::badbit)
{ {
throw; throw;
} }
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
else else
{ {
__state |= ios_base::failbit; __state |= ios_base::failbit;
} }
this->setstate(__state); this->setstate(__state);
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
streamsize streamsize
basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n) basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
__gc_ = 0; __gc_ = 0;
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
streamsize __c = this->rdbuf()->in_avail(); streamsize __c = this->rdbuf()->in_avail();
switch (__c) switch (__c)
{ {
case -1: case -1:
__state |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
case 0: case 0:
break; break;
default: default:
__n = _VSTD::min(__c, __n); __n = _VSTD::min(__c, __n);
__gc_ = this->rdbuf()->sgetn(__s, __n); __gc_ = this->rdbuf()->sgetn(__s, __n);
if (__gc_ != __n) if (__gc_ != __n)
__state |= ios_base::failbit | ios_base::eofbit; __state |= ios_base::failbit | ios_base::eofbit;
break; break;
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
this->__setstate_nothrow(__state); this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit) if (this->exceptions() & ios_base::badbit)
{ {
throw; throw;
} }
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
else else
{ {
__state |= ios_base::failbit; __state |= ios_base::failbit;
} }
this->setstate(__state); this->setstate(__state);
return __gc_; return __gc_;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::putback(char_type __c) basic_istream<_CharT, _Traits>::putback(char_type __c)
{ {
ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit; ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
__gc_ = 0; __gc_ = 0;
this->clear(__state); this->clear(__state);
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
if (this->rdbuf() == nullptr || this->rdbuf()->sputbackc(__c) == traits_type::eof()) if (this->rdbuf() == nullptr || this->rdbuf()->sputbackc(__c) == traits_type::eof())
__state |= ios_base::badbit; __state |= ios_base::badbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
this->__setstate_nothrow(__state); this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit) if (this->exceptions() & ios_base::badbit)
{ {
throw; throw;
} }
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
else else
{ {
__state |= ios_base::failbit; __state |= ios_base::failbit;
} }
this->setstate(__state); this->setstate(__state);
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::unget() basic_istream<_CharT, _Traits>::unget()
{ {
ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit; ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
__gc_ = 0; __gc_ = 0;
this->clear(__state); this->clear(__state);
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
if (this->rdbuf() == nullptr || this->rdbuf()->sungetc() == traits_type::eof()) if (this->rdbuf() == nullptr || this->rdbuf()->sungetc() == traits_type::eof())
__state |= ios_base::badbit; __state |= ios_base::badbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
this->__setstate_nothrow(__state); this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit) if (this->exceptions() & ios_base::badbit)
{ {
throw; throw;
} }
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
else else
{ {
__state |= ios_base::failbit; __state |= ios_base::failbit;
} }
this->setstate(__state); this->setstate(__state);
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
int int
basic_istream<_CharT, _Traits>::sync() basic_istream<_CharT, _Traits>::sync()
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
int __r = 0; int __r = 0;
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
if (this->rdbuf() == nullptr) if (this->rdbuf() == nullptr)
return -1; return -1;
if (this->rdbuf()->pubsync() == -1) if (this->rdbuf()->pubsync() == -1)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
return -1; return -1;
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
this->__setstate_nothrow(__state); this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit) if (this->exceptions() & ios_base::badbit)
{ {
throw; throw;
} }
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
this->setstate(__state); this->setstate(__state);
} }
return __r; return __r;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
typename basic_istream<_CharT, _Traits>::pos_type typename basic_istream<_CharT, _Traits>::pos_type
basic_istream<_CharT, _Traits>::tellg() basic_istream<_CharT, _Traits>::tellg()
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
pos_type __r(-1); pos_type __r(-1);
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__r = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in); __r = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
this->__setstate_nothrow(__state); this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit) if (this->exceptions() & ios_base::badbit)
{ {
throw; throw;
} }
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
this->setstate(__state); this->setstate(__state);
} }
return __r; return __r;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::seekg(pos_type __pos) basic_istream<_CharT, _Traits>::seekg(pos_type __pos)
{ {
ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit; ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
this->clear(__state); this->clear(__state);
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1)) if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1))
__state |= ios_base::failbit; __state |= ios_base::failbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
this->__setstate_nothrow(__state); this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit) if (this->exceptions() & ios_base::badbit)
{ {
throw; throw;
} }
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
this->setstate(__state); this->setstate(__state);
} }
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir) basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir)
{ {
ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit; ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
this->clear(__state); this->clear(__state);
sentry __sen(*this, true); sentry __sen(*this, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::in) == pos_type(-1)) if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::in) == pos_type(-1))
__state |= ios_base::failbit; __state |= ios_base::failbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
this->__setstate_nothrow(__state); this->__setstate_nothrow(__state);
if (this->exceptions() & ios_base::badbit) if (this->exceptions() & ios_base::badbit)
{ {
throw; throw;
} }
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
this->setstate(__state); this->setstate(__state);
} }
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
ws(basic_istream<_CharT, _Traits>& __is) ws(basic_istream<_CharT, _Traits>& __is)
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true); typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc()); const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
while (true) while (true)
{ {
typename _Traits::int_type __i = __is.rdbuf()->sgetc(); typename _Traits::int_type __i = __is.rdbuf()->sgetc();
if (_Traits::eq_int_type(__i, _Traits::eof())) if (_Traits::eq_int_type(__i, _Traits::eof()))
{ {
__state |= ios_base::eofbit; __state |= ios_base::eofbit;
break; break;
} }
if (!__ct.is(__ct.space, _Traits::to_char_type(__i))) if (!__ct.is(__ct.space, _Traits::to_char_type(__i)))
break; break;
__is.rdbuf()->sbumpc(); __is.rdbuf()->sbumpc();
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
__is.__setstate_nothrow(__state); __is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit) if (__is.exceptions() & ios_base::badbit)
{ {
throw; throw;
} }
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__is.setstate(__state); __is.setstate(__state);
} }
return __is; return __is;
} }
template <class _Stream, class _Tp, class = void> template <class _Stream, class _Tp, class = void>
struct __is_istreamable : false_type { }; struct __is_istreamable : false_type { };
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines
_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, operator>>(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Allocator>& __str) basic_string<_CharT, _Traits, _Allocator>& __str)
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
typename basic_istream<_CharT, _Traits>::sentry __sen(__is); typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif #endif
__str.clear(); __str.clear();
streamsize __n = __is.width(); streamsize __n = __is.width();
if (__n <= 0) if (__n <= 0)
__n = __str.max_size(); __n = __str.max_size();
if (__n <= 0) if (__n <= 0)
Show All 13 Lines#endif
break; break;
__str.push_back(__ch); __str.push_back(__ch);
++__c; ++__c;
__is.rdbuf()->sbumpc(); __is.rdbuf()->sbumpc();
} }
__is.width(0); __is.width(0);
if (__c == 0) if (__c == 0)
__state |= ios_base::failbit; __state |= ios_base::failbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
__is.__setstate_nothrow(__state); __is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit) if (__is.exceptions() & ios_base::badbit)
{ {
throw; throw;
Show All 9 Lines
_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is, getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm) basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true); typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif #endif
__str.clear(); __str.clear();
streamsize __extr = 0; streamsize __extr = 0;
while (true) while (true)
{ {
typename _Traits::int_type __i = __is.rdbuf()->sbumpc(); typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
Show All 10 Lines#endif
if (__str.size() == __str.max_size()) if (__str.size() == __str.max_size())
{ {
__state |= ios_base::failbit; __state |= ios_base::failbit;
break; break;
} }
} }
if (__extr == 0) if (__extr == 0)
__state |= ios_base::failbit; __state |= ios_base::failbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
__is.__setstate_nothrow(__state); __is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit) if (__is.exceptions() & ios_base::badbit)
{ {
throw; throw;
Show All 35 Lines
template <class _CharT, class _Traits, size_t _Size> template <class _CharT, class _Traits, size_t _Size>
_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x) operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
{ {
ios_base::iostate __state = ios_base::goodbit; ios_base::iostate __state = ios_base::goodbit;
typename basic_istream<_CharT, _Traits>::sentry __sen(__is); typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
if (__sen) if (__sen)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif #endif
basic_string<_CharT, _Traits> __str; basic_string<_CharT, _Traits> __str;
const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc()); const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
size_t __c = 0; size_t __c = 0;
_CharT __zero = __ct.widen('0'); _CharT __zero = __ct.widen('0');
_CharT __one = __ct.widen('1'); _CharT __one = __ct.widen('1');
Show All 10 Lines#endif
break; break;
__str.push_back(__ch); __str.push_back(__ch);
++__c; ++__c;
__is.rdbuf()->sbumpc(); __is.rdbuf()->sbumpc();
} }
__x = bitset<_Size>(__str); __x = bitset<_Size>(__str);
if (_Size > 0 && __c == 0) if (_Size > 0 && __c == 0)
__state |= ios_base::failbit; __state |= ios_base::failbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__state |= ios_base::badbit; __state |= ios_base::badbit;
__is.__setstate_nothrow(__state); __is.__setstate_nothrow(__state);
if (__is.exceptions() & ios_base::badbit) if (__is.exceptions() & ios_base::badbit)
{ {
throw; throw;
Show All 24 Lines

libcxx/include/list

Show First 20 Lines • Show All 1,417 Lines • ▼ Show 20 Lines if (__n > 0)
size_type __ds = 0; size_type __ds = 0;
__node_allocator& __na = base::__node_alloc(); __node_allocator& __na = base::__node_alloc();
__hold_pointer __hold = __allocate_node(__na); __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
++__ds; ++__ds;
__r = iterator(__hold->__as_link(), this); __r = iterator(__hold->__as_link(), this);
__hold.release(); __hold.release();
iterator __e = __r; iterator __e = __r;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (--__n; __n != 0; --__n, (void) ++__e, ++__ds) for (--__n; __n != 0; --__n, (void) ++__e, ++__ds)
{ {
__hold.reset(__node_alloc_traits::allocate(__na, 1)); __hold.reset(__node_alloc_traits::allocate(__na, 1));
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
__e.__ptr_->__next_ = __hold->__as_link(); __e.__ptr_->__next_ = __hold->__as_link();
__hold->__prev_ = __e.__ptr_; __hold->__prev_ = __e.__ptr_;
__hold.release(); __hold.release();
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
while (true) while (true)
{ {
__node_alloc_traits::destroy(__na, _VSTD::addressof(*__e)); __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
__link_pointer __prev = __e.__ptr_->__prev_; __link_pointer __prev = __e.__ptr_->__prev_;
__node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1); __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
if (__prev == 0) if (__prev == 0)
break; break;
__e = iterator(__prev, this); __e = iterator(__prev, this);
} }
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_); __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_);
base::__sz() += __ds; base::__sz() += __ds;
} }
return __r; return __r;
} }
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
template <class _InpIter> template <class _InpIter>
Show All 9 Lines if (__f != __l)
size_type __ds = 0; size_type __ds = 0;
__node_allocator& __na = base::__node_alloc(); __node_allocator& __na = base::__node_alloc();
__hold_pointer __hold = __allocate_node(__na); __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
++__ds; ++__ds;
__r = iterator(__hold.get()->__as_link(), this); __r = iterator(__hold.get()->__as_link(), this);
__hold.release(); __hold.release();
iterator __e = __r; iterator __e = __r;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (++__f; __f != __l; ++__f, (void) ++__e, ++__ds) for (++__f; __f != __l; ++__f, (void) ++__e, ++__ds)
{ {
__hold.reset(__node_alloc_traits::allocate(__na, 1)); __hold.reset(__node_alloc_traits::allocate(__na, 1));
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
__e.__ptr_->__next_ = __hold.get()->__as_link(); __e.__ptr_->__next_ = __hold.get()->__as_link();
__hold->__prev_ = __e.__ptr_; __hold->__prev_ = __e.__ptr_;
__hold.release(); __hold.release();
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
while (true) while (true)
{ {
__node_alloc_traits::destroy(__na, _VSTD::addressof(*__e)); __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
__link_pointer __prev = __e.__ptr_->__prev_; __link_pointer __prev = __e.__ptr_->__prev_;
__node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1); __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
if (__prev == 0) if (__prev == 0)
break; break;
__e = iterator(__prev, this); __e = iterator(__prev, this);
} }
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_); __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_);
base::__sz() += __ds; base::__sz() += __ds;
} }
return __r; return __r;
} }
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
void void
▲ Show 20 Lines • Show All 267 Lines • ▼ Show 20 Lines else if (__n > base::__sz())
__n -= base::__sz(); __n -= base::__sz();
size_type __ds = 0; size_type __ds = 0;
__node_allocator& __na = base::__node_alloc(); __node_allocator& __na = base::__node_alloc();
__hold_pointer __hold = __allocate_node(__na); __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_)); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
++__ds; ++__ds;
iterator __r = iterator(__hold.release()->__as_link(), this); iterator __r = iterator(__hold.release()->__as_link(), this);
iterator __e = __r; iterator __e = __r;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (--__n; __n != 0; --__n, (void) ++__e, ++__ds) for (--__n; __n != 0; --__n, (void) ++__e, ++__ds)
{ {
__hold.reset(__node_alloc_traits::allocate(__na, 1)); __hold.reset(__node_alloc_traits::allocate(__na, 1));
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_)); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
__e.__ptr_->__next_ = __hold.get()->__as_link(); __e.__ptr_->__next_ = __hold.get()->__as_link();
__hold->__prev_ = __e.__ptr_; __hold->__prev_ = __e.__ptr_;
__hold.release(); __hold.release();
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
while (true) while (true)
{ {
__node_alloc_traits::destroy(__na, _VSTD::addressof(*__e)); __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
__link_pointer __prev = __e.__ptr_->__prev_; __link_pointer __prev = __e.__ptr_->__prev_;
__node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1); __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
if (__prev == 0) if (__prev == 0)
break; break;
__e = iterator(__prev, this); __e = iterator(__prev, this);
} }
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__link_nodes_at_back(__r.__ptr_, __e.__ptr_); __link_nodes_at_back(__r.__ptr_, __e.__ptr_);
base::__sz() += __ds; base::__sz() += __ds;
} }
} }
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
void void
list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x) list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
{ {
if (__n < base::__sz()) if (__n < base::__sz())
erase(__iterator(__n), end()); erase(__iterator(__n), end());
else if (__n > base::__sz()) else if (__n > base::__sz())
{ {
__n -= base::__sz(); __n -= base::__sz();
size_type __ds = 0; size_type __ds = 0;
__node_allocator& __na = base::__node_alloc(); __node_allocator& __na = base::__node_alloc();
__hold_pointer __hold = __allocate_node(__na); __hold_pointer __hold = __allocate_node(__na);
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
++__ds; ++__ds;
__link_pointer __nl = __hold.release()->__as_link(); __link_pointer __nl = __hold.release()->__as_link();
iterator __r = iterator(__nl, this); iterator __r = iterator(__nl, this);
iterator __e = __r; iterator __e = __r;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (--__n; __n != 0; --__n, (void) ++__e, ++__ds) for (--__n; __n != 0; --__n, (void) ++__e, ++__ds)
{ {
__hold.reset(__node_alloc_traits::allocate(__na, 1)); __hold.reset(__node_alloc_traits::allocate(__na, 1));
__node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x); __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
__e.__ptr_->__next_ = __hold.get()->__as_link(); __e.__ptr_->__next_ = __hold.get()->__as_link();
__hold->__prev_ = __e.__ptr_; __hold->__prev_ = __e.__ptr_;
__hold.release(); __hold.release();
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
while (true) while (true)
{ {
__node_alloc_traits::destroy(__na, _VSTD::addressof(*__e)); __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
__link_pointer __prev = __e.__ptr_->__prev_; __link_pointer __prev = __e.__ptr_->__prev_;
__node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1); __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
if (__prev == 0) if (__prev == 0)
break; break;
__e = iterator(__prev, this); __e = iterator(__prev, this);
} }
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__link_nodes(base::__end_as_link(), __r.__ptr_, __e.__ptr_); __link_nodes(base::__end_as_link(), __r.__ptr_, __e.__ptr_);
base::__sz() += __ds; base::__sz() += __ds;
} }
} }
template <class _Tp, class _Alloc> template <class _Tp, class _Alloc>
void void
list<_Tp, _Alloc>::splice(const_iterator __p, list& __c) list<_Tp, _Alloc>::splice(const_iterator __p, list& __c)
▲ Show 20 Lines • Show All 511 Lines • Show Last 20 Lines

libcxx/include/new

Show First 20 Lines • Show All 167 Lines • ▼ Show 20 Lines
}; };
#endif // defined(_LIBCPP_ABI_VCRUNTIME) && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS == 0 #endif // defined(_LIBCPP_ABI_VCRUNTIME) && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS == 0
_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_bad_alloc(); // not in C++ spec _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_bad_alloc(); // not in C++ spec
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
void __throw_bad_array_new_length() void __throw_bad_array_new_length()
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw bad_array_new_length(); throw bad_array_new_length();
#else #else
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
#if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) && \ #if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) && \
!defined(_LIBCPP_ABI_VCRUNTIME) !defined(_LIBCPP_ABI_VCRUNTIME)
▲ Show 20 Lines • Show All 186 Lines • Show Last 20 Lines

libcxx/include/optional

Show First 20 Lines • Show All 202 Lines • ▼ Show 20 Lines
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
_LIBCPP_NORETURN _LIBCPP_NORETURN
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
void __throw_bad_optional_access() { void __throw_bad_optional_access() {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw bad_optional_access(); throw bad_optional_access();
#else #else
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
struct nullopt_t struct nullopt_t
{ {
▲ Show 20 Lines • Show All 1,372 Lines • Show Last 20 Lines

libcxx/include/ostream

Show First 20 Lines • Show All 308 Lines • ▼ Show 20 Lines
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>::sentry::~sentry() basic_ostream<_CharT, _Traits>::sentry::~sentry()
{ {
if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf) if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf)
&& !uncaught_exception()) && !uncaught_exception())
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
if (__os_.rdbuf()->pubsync() == -1) if (__os_.rdbuf()->pubsync() == -1)
__os_.setstate(ios_base::badbit); __os_.setstate(ios_base::badbit);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs) basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs)
{ {
this->move(__rhs); this->move(__rhs);
} }
Show All 10 Lines
basic_ostream<_CharT, _Traits>::~basic_ostream() basic_ostream<_CharT, _Traits>::~basic_ostream()
{ {
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb) basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
if (__sb) if (__sb)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typedef istreambuf_iterator<_CharT, _Traits> _Ip; typedef istreambuf_iterator<_CharT, _Traits> _Ip;
typedef ostreambuf_iterator<_CharT, _Traits> _Op; typedef ostreambuf_iterator<_CharT, _Traits> _Op;
_Ip __i(__sb); _Ip __i(__sb);
_Ip __eof; _Ip __eof;
_Op __o(*this); _Op __o(*this);
size_t __c = 0; size_t __c = 0;
for (; __i != __eof; ++__i, ++__o, ++__c) for (; __i != __eof; ++__i, ++__o, ++__c)
{ {
*__o = *__i; *__o = *__i;
if (__o.failed()) if (__o.failed())
break; break;
} }
if (__c == 0) if (__c == 0)
this->setstate(ios_base::failbit); this->setstate(ios_base::failbit);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_failbit_and_consider_rethrow(); this->__set_failbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
else else
this->setstate(ios_base::badbit); this->setstate(ios_base::badbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(bool __n) basic_ostream<_CharT, _Traits>::operator<<(bool __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
const _Fp& __f = std::use_facet<_Fp>(this->getloc()); const _Fp& __f = std::use_facet<_Fp>(this->getloc());
if (__f.put(*this, *this, this->fill(), __n).failed()) if (__f.put(*this, *this, this->fill(), __n).failed())
this->setstate(ios_base::badbit | ios_base::failbit); this->setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(short __n) basic_ostream<_CharT, _Traits>::operator<<(short __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield; ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
const _Fp& __f = std::use_facet<_Fp>(this->getloc()); const _Fp& __f = std::use_facet<_Fp>(this->getloc());
if (__f.put(*this, *this, this->fill(), if (__f.put(*this, *this, this->fill(),
__flags == ios_base::oct || __flags == ios_base::hex ? __flags == ios_base::oct || __flags == ios_base::hex ?
static_cast<long>(static_cast<unsigned short>(__n)) : static_cast<long>(static_cast<unsigned short>(__n)) :
static_cast<long>(__n)).failed()) static_cast<long>(__n)).failed())
this->setstate(ios_base::badbit | ios_base::failbit); this->setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n) basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
const _Fp& __f = std::use_facet<_Fp>(this->getloc()); const _Fp& __f = std::use_facet<_Fp>(this->getloc());
if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed()) if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
this->setstate(ios_base::badbit | ios_base::failbit); this->setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(int __n) basic_ostream<_CharT, _Traits>::operator<<(int __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield; ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
const _Fp& __f = std::use_facet<_Fp>(this->getloc()); const _Fp& __f = std::use_facet<_Fp>(this->getloc());
if (__f.put(*this, *this, this->fill(), if (__f.put(*this, *this, this->fill(),
__flags == ios_base::oct || __flags == ios_base::hex ? __flags == ios_base::oct || __flags == ios_base::hex ?
static_cast<long>(static_cast<unsigned int>(__n)) : static_cast<long>(static_cast<unsigned int>(__n)) :
static_cast<long>(__n)).failed()) static_cast<long>(__n)).failed())
this->setstate(ios_base::badbit | ios_base::failbit); this->setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n) basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
const _Fp& __f = std::use_facet<_Fp>(this->getloc()); const _Fp& __f = std::use_facet<_Fp>(this->getloc());
if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed()) if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
this->setstate(ios_base::badbit | ios_base::failbit); this->setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(long __n) basic_ostream<_CharT, _Traits>::operator<<(long __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
const _Fp& __f = std::use_facet<_Fp>(this->getloc()); const _Fp& __f = std::use_facet<_Fp>(this->getloc());
if (__f.put(*this, *this, this->fill(), __n).failed()) if (__f.put(*this, *this, this->fill(), __n).failed())
this->setstate(ios_base::badbit | ios_base::failbit); this->setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n) basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
const _Fp& __f = std::use_facet<_Fp>(this->getloc()); const _Fp& __f = std::use_facet<_Fp>(this->getloc());
if (__f.put(*this, *this, this->fill(), __n).failed()) if (__f.put(*this, *this, this->fill(), __n).failed())
this->setstate(ios_base::badbit | ios_base::failbit); this->setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(long long __n) basic_ostream<_CharT, _Traits>::operator<<(long long __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
const _Fp& __f = std::use_facet<_Fp>(this->getloc()); const _Fp& __f = std::use_facet<_Fp>(this->getloc());
if (__f.put(*this, *this, this->fill(), __n).failed()) if (__f.put(*this, *this, this->fill(), __n).failed())
this->setstate(ios_base::badbit | ios_base::failbit); this->setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n) basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
const _Fp& __f = std::use_facet<_Fp>(this->getloc()); const _Fp& __f = std::use_facet<_Fp>(this->getloc());
if (__f.put(*this, *this, this->fill(), __n).failed()) if (__f.put(*this, *this, this->fill(), __n).failed())
this->setstate(ios_base::badbit | ios_base::failbit); this->setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(float __n) basic_ostream<_CharT, _Traits>::operator<<(float __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
const _Fp& __f = std::use_facet<_Fp>(this->getloc()); const _Fp& __f = std::use_facet<_Fp>(this->getloc());
if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed()) if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed())
this->setstate(ios_base::badbit | ios_base::failbit); this->setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(double __n) basic_ostream<_CharT, _Traits>::operator<<(double __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
const _Fp& __f = std::use_facet<_Fp>(this->getloc()); const _Fp& __f = std::use_facet<_Fp>(this->getloc());
if (__f.put(*this, *this, this->fill(), __n).failed()) if (__f.put(*this, *this, this->fill(), __n).failed())
this->setstate(ios_base::badbit | ios_base::failbit); this->setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(long double __n) basic_ostream<_CharT, _Traits>::operator<<(long double __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
const _Fp& __f = std::use_facet<_Fp>(this->getloc()); const _Fp& __f = std::use_facet<_Fp>(this->getloc());
if (__f.put(*this, *this, this->fill(), __n).failed()) if (__f.put(*this, *this, this->fill(), __n).failed())
this->setstate(ios_base::badbit | ios_base::failbit); this->setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(const void* __n) basic_ostream<_CharT, _Traits>::operator<<(const void* __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
const _Fp& __f = std::use_facet<_Fp>(this->getloc()); const _Fp& __f = std::use_facet<_Fp>(this->getloc());
if (__f.put(*this, *this, this->fill(), __n).failed()) if (__f.put(*this, *this, this->fill(), __n).failed())
this->setstate(ios_base::badbit | ios_base::failbit); this->setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
__put_character_sequence(basic_ostream<_CharT, _Traits>& __os, __put_character_sequence(basic_ostream<_CharT, _Traits>& __os,
const _CharT* __str, size_t __len) const _CharT* __str, size_t __len)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typename basic_ostream<_CharT, _Traits>::sentry __s(__os); typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
if (__s) if (__s)
{ {
typedef ostreambuf_iterator<_CharT, _Traits> _Ip; typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
if (std::__pad_and_output(_Ip(__os), if (std::__pad_and_output(_Ip(__os),
__str, __str,
(__os.flags() & ios_base::adjustfield) == ios_base::left ? (__os.flags() & ios_base::adjustfield) == ios_base::left ?
__str + __len : __str + __len :
__str, __str,
__str + __len, __str + __len,
__os, __os,
__os.fill()).failed()) __os.fill()).failed())
__os.setstate(ios_base::badbit | ios_base::failbit); __os.setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__os.__set_badbit_and_consider_rethrow(); __os.__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return __os; return __os;
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c) operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c)
{ {
return _VSTD::__put_character_sequence(__os, &__c, 1); return _VSTD::__put_character_sequence(__os, &__c, 1);
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn) operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typename basic_ostream<_CharT, _Traits>::sentry __s(__os); typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
if (__s) if (__s)
{ {
_CharT __c = __os.widen(__cn); _CharT __c = __os.widen(__cn);
typedef ostreambuf_iterator<_CharT, _Traits> _Ip; typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
if (std::__pad_and_output(_Ip(__os), if (std::__pad_and_output(_Ip(__os),
&__c, &__c,
(__os.flags() & ios_base::adjustfield) == ios_base::left ? (__os.flags() & ios_base::adjustfield) == ios_base::left ?
&__c + 1 : &__c + 1 :
&__c, &__c,
&__c + 1, &__c + 1,
__os, __os,
__os.fill()).failed()) __os.fill()).failed())
__os.setstate(ios_base::badbit | ios_base::failbit); __os.setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__os.__set_badbit_and_consider_rethrow(); __os.__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return __os; return __os;
} }
template<class _Traits> template<class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __os, char __c) operator<<(basic_ostream<char, _Traits>& __os, char __c)
{ {
return _VSTD::__put_character_sequence(__os, &__c, 1); return _VSTD::__put_character_sequence(__os, &__c, 1);
Show All 19 Lines
{ {
return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str)); return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str));
} }
template<class _CharT, class _Traits> template<class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn) operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typename basic_ostream<_CharT, _Traits>::sentry __s(__os); typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
if (__s) if (__s)
{ {
typedef ostreambuf_iterator<_CharT, _Traits> _Ip; typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
size_t __len = char_traits<char>::length(__strn); size_t __len = char_traits<char>::length(__strn);
const int __bs = 100; const int __bs = 100;
_CharT __wbb[__bs]; _CharT __wbb[__bs];
_CharT* __wb = __wbb; _CharT* __wb = __wbb;
Show All 12 Lines#endif // _LIBCPP_HAS_NO_EXCEPTIONS
(__os.flags() & ios_base::adjustfield) == ios_base::left ? (__os.flags() & ios_base::adjustfield) == ios_base::left ?
__wb + __len : __wb + __len :
__wb, __wb,
__wb + __len, __wb + __len,
__os, __os,
__os.fill()).failed()) __os.fill()).failed())
__os.setstate(ios_base::badbit | ios_base::failbit); __os.setstate(ios_base::badbit | ios_base::failbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__os.__set_badbit_and_consider_rethrow(); __os.__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return __os; return __os;
} }
template<class _Traits> template<class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& _LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __os, const char* __str) operator<<(basic_ostream<char, _Traits>& __os, const char* __str)
{ {
return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str)); return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str));
Show All 14 Linesoperator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str)
const char *__s = (const char *) __str; const char *__s = (const char *) __str;
return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s)); return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s));
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::put(char_type __c) basic_ostream<_CharT, _Traits>::put(char_type __c)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
typedef ostreambuf_iterator<_CharT, _Traits> _Op; typedef ostreambuf_iterator<_CharT, _Traits> _Op;
_Op __o(*this); _Op __o(*this);
*__o = __c; *__o = __c;
if (__o.failed()) if (__o.failed())
this->setstate(ios_base::badbit); this->setstate(ios_base::badbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n) basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
sentry __sen(*this); sentry __sen(*this);
if (__sen && __n) if (__sen && __n)
{ {
if (this->rdbuf()->sputn(__s, __n) != __n) if (this->rdbuf()->sputn(__s, __n) != __n)
this->setstate(ios_base::badbit); this->setstate(ios_base::badbit);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::flush() basic_ostream<_CharT, _Traits>::flush()
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
if (this->rdbuf()) if (this->rdbuf())
{ {
sentry __s(*this); sentry __s(*this);
if (__s) if (__s)
{ {
if (this->rdbuf()->pubsync() == -1) if (this->rdbuf()->pubsync() == -1)
this->setstate(ios_base::badbit); this->setstate(ios_base::badbit);
} }
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
this->__set_badbit_and_consider_rethrow(); this->__set_badbit_and_consider_rethrow();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return *this; return *this;
} }
template <class _CharT, class _Traits> template <class _CharT, class _Traits>
typename basic_ostream<_CharT, _Traits>::pos_type typename basic_ostream<_CharT, _Traits>::pos_type
basic_ostream<_CharT, _Traits>::tellp() basic_ostream<_CharT, _Traits>::tellp()
{ {
if (this->fail()) if (this->fail())
▲ Show 20 Lines • Show All 195 Lines • Show Last 20 Lines

libcxx/include/regex

Show First 20 Lines • Show All 1,006 Lines • ▼ Show 20 Linespublic:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
regex_constants::error_type code() const {return __code_;} regex_constants::error_type code() const {return __code_;}
}; };
template <regex_constants::error_type _Ev> template <regex_constants::error_type _Ev>
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
void __throw_regex_error() void __throw_regex_error()
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw regex_error(_Ev); throw regex_error(_Ev);
#else #else
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
template <class _CharT> template <class _CharT>
struct _LIBCPP_TEMPLATE_VIS regex_traits struct _LIBCPP_TEMPLATE_VIS regex_traits
▲ Show 20 Lines • Show All 5,854 Lines • Show Last 20 Lines

libcxx/include/sstream

Show First 20 Lines • Show All 535 Lines • ▼ Show 20 Lines
{ {
if (!traits_type::eq_int_type(__c, traits_type::eof())) if (!traits_type::eq_int_type(__c, traits_type::eof()))
{ {
ptrdiff_t __ninp = this->gptr() - this->eback(); ptrdiff_t __ninp = this->gptr() - this->eback();
if (this->pptr() == this->epptr()) if (this->pptr() == this->epptr())
{ {
if (!(__mode_ & ios_base::out)) if (!(__mode_ & ios_base::out))
return traits_type::eof(); return traits_type::eof();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
ptrdiff_t __nout = this->pptr() - this->pbase(); ptrdiff_t __nout = this->pptr() - this->pbase();
ptrdiff_t __hm = __hm_ - this->pbase(); ptrdiff_t __hm = __hm_ - this->pbase();
__str_.push_back(char_type()); __str_.push_back(char_type());
__str_.resize(__str_.capacity()); __str_.resize(__str_.capacity());
char_type* __p = const_cast<char_type*>(__str_.data()); char_type* __p = const_cast<char_type*>(__str_.data());
this->setp(__p, __p + __str_.size()); this->setp(__p, __p + __str_.size());
this->__pbump(__nout); this->__pbump(__nout);
__hm_ = this->pbase() + __hm; __hm_ = this->pbase() + __hm;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
return traits_type::eof(); return traits_type::eof();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
__hm_ = _VSTD::max(this->pptr() + 1, __hm_); __hm_ = _VSTD::max(this->pptr() + 1, __hm_);
if (__mode_ & ios_base::in) if (__mode_ & ios_base::in)
{ {
char_type* __p = const_cast<char_type*>(__str_.data()); char_type* __p = const_cast<char_type*>(__str_.data());
this->setg(__p, __p + __ninp, __hm_); this->setg(__p, __p + __ninp, __hm_);
} }
return this->sputc(traits_type::to_char_type(__c)); return this->sputc(traits_type::to_char_type(__c));
▲ Show 20 Lines • Show All 313 Lines • Show Last 20 Lines

libcxx/include/stdexcept

Show First 20 Lines • Show All 214 Lines • ▼ Show 20 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
// in the dylib // in the dylib
_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*); _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
void __throw_logic_error(const char*__msg) void __throw_logic_error(const char*__msg)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw logic_error(__msg); throw logic_error(__msg);
#else #else
((void)__msg); ((void)__msg);
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
void __throw_domain_error(const char*__msg) void __throw_domain_error(const char*__msg)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw domain_error(__msg); throw domain_error(__msg);
#else #else
((void)__msg); ((void)__msg);
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
void __throw_invalid_argument(const char*__msg) void __throw_invalid_argument(const char*__msg)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw invalid_argument(__msg); throw invalid_argument(__msg);
#else #else
((void)__msg); ((void)__msg);
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
void __throw_length_error(const char*__msg) void __throw_length_error(const char*__msg)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw length_error(__msg); throw length_error(__msg);
#else #else
((void)__msg); ((void)__msg);
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
void __throw_out_of_range(const char*__msg) void __throw_out_of_range(const char*__msg)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw out_of_range(__msg); throw out_of_range(__msg);
#else #else
((void)__msg); ((void)__msg);
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
void __throw_range_error(const char*__msg) void __throw_range_error(const char*__msg)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw range_error(__msg); throw range_error(__msg);
#else #else
((void)__msg); ((void)__msg);
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
void __throw_overflow_error(const char*__msg) void __throw_overflow_error(const char*__msg)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw overflow_error(__msg); throw overflow_error(__msg);
#else #else
((void)__msg); ((void)__msg);
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
void __throw_underflow_error(const char*__msg) void __throw_underflow_error(const char*__msg)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw underflow_error(__msg); throw underflow_error(__msg);
#else #else
((void)__msg); ((void)__msg);
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_STDEXCEPT #endif // _LIBCPP_STDEXCEPT

libcxx/include/string

Show First 20 Lines • Show All 2,282 Lines • ▼ Show 20 Lines
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
__enable_if_t __enable_if_t
< <
__is_exactly_cpp17_input_iterator<_InputIterator>::value __is_exactly_cpp17_input_iterator<_InputIterator>::value
> >
basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last) basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)
{ {
__default_init(); __default_init();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
push_back(*__first); push_back(*__first);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
if (__is_long()) if (__is_long())
__alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
__enable_if_t __enable_if_t
< <
__is_cpp17_forward_iterator<_ForwardIterator>::value __is_cpp17_forward_iterator<_ForwardIterator>::value
Show All 16 Lines else
auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__sz) + 1); auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__sz) + 1);
__p = __allocation.ptr; __p = __allocation.ptr;
__begin_lifetime(__p, __allocation.count); __begin_lifetime(__p, __allocation.count);
__set_long_pointer(__p); __set_long_pointer(__p);
__set_long_cap(__allocation.count); __set_long_cap(__allocation.count);
__set_long_size(__sz); __set_long_size(__sz);
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (; __first != __last; ++__first, (void) ++__p) for (; __first != __last; ++__first, (void) ++__p)
traits_type::assign(*__p, *__first); traits_type::assign(*__p, *__first);
traits_type::assign(*__p, value_type()); traits_type::assign(*__p, value_type());
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
if (__is_long()) if (__is_long())
__alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template <class _CharT, class _Traits, class _Allocator> template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
basic_string<_CharT, _Traits, _Allocator>::~basic_string() basic_string<_CharT, _Traits, _Allocator>::~basic_string()
{ {
std::__debug_db_erase_c(this); std::__debug_db_erase_c(this);
if (__is_long()) if (__is_long())
▲ Show 20 Lines • Show All 998 Lines • ▼ Show 20 Linesbasic_string<_CharT, _Traits, _Allocator>::__shrink_or_extend(size_type __target_capacity)
{ {
if (__target_capacity > __cap) { if (__target_capacity > __cap) {
auto __allocation = std::__allocate_at_least(__alloc(), __target_capacity + 1); auto __allocation = std::__allocate_at_least(__alloc(), __target_capacity + 1);
__new_data = __allocation.ptr; __new_data = __allocation.ptr;
__target_capacity = __allocation.count - 1; __target_capacity = __allocation.count - 1;
} }
else else
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
auto __allocation = std::__allocate_at_least(__alloc(), __target_capacity + 1); auto __allocation = std::__allocate_at_least(__alloc(), __target_capacity + 1);
__new_data = __allocation.ptr; __new_data = __allocation.ptr;
__target_capacity = __allocation.count - 1; __target_capacity = __allocation.count - 1;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
return; return;
} }
#else // _LIBCPP_NO_EXCEPTIONS #else // _LIBCPP_HAS_NO_EXCEPTIONS
if (__new_data == nullptr) if (__new_data == nullptr)
return; return;
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
__begin_lifetime(__new_data, __target_capacity + 1); __begin_lifetime(__new_data, __target_capacity + 1);
__now_long = true; __now_long = true;
__was_long = __is_long(); __was_long = __is_long();
__p = __get_pointer(); __p = __get_pointer();
} }
traits_type::copy(std::__to_address(__new_data), traits_type::copy(std::__to_address(__new_data),
std::__to_address(__p), size()+1); std::__to_address(__p), size()+1);
▲ Show 20 Lines • Show All 1,241 Lines • Show Last 20 Lines

libcxx/include/typeinfo

Show First 20 Lines • Show All 400 Lines • ▼ Show 20 Lines
} // namespace std } // namespace std
#endif // defined(_LIBCPP_ABI_VCRUNTIME) && _HAS_EXCEPTIONS == 0 #endif // defined(_LIBCPP_ABI_VCRUNTIME) && _HAS_EXCEPTIONS == 0
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
void __throw_bad_cast() void __throw_bad_cast()
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw bad_cast(); throw bad_cast();
#else #else
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // __LIBCPP_TYPEINFO #endif // __LIBCPP_TYPEINFO

libcxx/include/valarray

Show First 20 Lines • Show All 2,812 Lines • ▼ Show 20 Lines
inline inline
valarray<_Tp>::valarray(size_t __n) valarray<_Tp>::valarray(size_t __n)
: __begin_(nullptr), : __begin_(nullptr),
__end_(nullptr) __end_(nullptr)
{ {
if (__n) if (__n)
{ {
__begin_ = __end_ = allocator<value_type>().allocate(__n); __begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (size_t __n_left = __n; __n_left; --__n_left, ++__end_) for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
::new ((void*)__end_) value_type(); ::new ((void*)__end_) value_type();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__clear(__n); __clear(__n);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
} }
template <class _Tp> template <class _Tp>
inline inline
valarray<_Tp>::valarray(const value_type& __x, size_t __n) valarray<_Tp>::valarray(const value_type& __x, size_t __n)
: __begin_(nullptr), : __begin_(nullptr),
__end_(nullptr) __end_(nullptr)
{ {
resize(__n, __x); resize(__n, __x);
} }
template <class _Tp> template <class _Tp>
valarray<_Tp>::valarray(const value_type* __p, size_t __n) valarray<_Tp>::valarray(const value_type* __p, size_t __n)
: __begin_(nullptr), : __begin_(nullptr),
__end_(nullptr) __end_(nullptr)
{ {
if (__n) if (__n)
{ {
__begin_ = __end_ = allocator<value_type>().allocate(__n); __begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left) for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left)
::new ((void*)__end_) value_type(*__p); ::new ((void*)__end_) value_type(*__p);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__clear(__n); __clear(__n);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
} }
template <class _Tp> template <class _Tp>
valarray<_Tp>::valarray(const valarray& __v) valarray<_Tp>::valarray(const valarray& __v)
: __begin_(nullptr), : __begin_(nullptr),
__end_(nullptr) __end_(nullptr)
{ {
if (__v.size()) if (__v.size())
{ {
__begin_ = __end_ = allocator<value_type>().allocate(__v.size()); __begin_ = __end_ = allocator<value_type>().allocate(__v.size());
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p) for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p)
::new ((void*)__end_) value_type(*__p); ::new ((void*)__end_) value_type(*__p);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__clear(__v.size()); __clear(__v.size());
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
} }
#ifndef _LIBCPP_CXX03_LANG #ifndef _LIBCPP_CXX03_LANG
template <class _Tp> template <class _Tp>
inline inline
valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT
: __begin_(__v.__begin_), : __begin_(__v.__begin_),
__end_(__v.__end_) __end_(__v.__end_)
{ {
__v.__begin_ = __v.__end_ = nullptr; __v.__begin_ = __v.__end_ = nullptr;
} }
template <class _Tp> template <class _Tp>
valarray<_Tp>::valarray(initializer_list<value_type> __il) valarray<_Tp>::valarray(initializer_list<value_type> __il)
: __begin_(nullptr), : __begin_(nullptr),
__end_(nullptr) __end_(nullptr)
{ {
const size_t __n = __il.size(); const size_t __n = __il.size();
if (__n) if (__n)
{ {
__begin_ = __end_ = allocator<value_type>().allocate(__n); __begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
size_t __n_left = __n; size_t __n_left = __n;
for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left) for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left)
::new ((void*)__end_) value_type(*__p); ::new ((void*)__end_) value_type(*__p);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__clear(__n); __clear(__n);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
} }
#endif // _LIBCPP_CXX03_LANG #endif // _LIBCPP_CXX03_LANG
template <class _Tp> template <class _Tp>
valarray<_Tp>::valarray(const slice_array<value_type>& __sa) valarray<_Tp>::valarray(const slice_array<value_type>& __sa)
: __begin_(nullptr), : __begin_(nullptr),
__end_(nullptr) __end_(nullptr)
{ {
const size_t __n = __sa.__size_; const size_t __n = __sa.__size_;
if (__n) if (__n)
{ {
__begin_ = __end_ = allocator<value_type>().allocate(__n); __begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
size_t __n_left = __n; size_t __n_left = __n;
for (const value_type* __p = __sa.__vp_; __n_left; ++__end_, __p += __sa.__stride_, --__n_left) for (const value_type* __p = __sa.__vp_; __n_left; ++__end_, __p += __sa.__stride_, --__n_left)
::new ((void*)__end_) value_type(*__p); ::new ((void*)__end_) value_type(*__p);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__clear(__n); __clear(__n);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
} }
template <class _Tp> template <class _Tp>
valarray<_Tp>::valarray(const gslice_array<value_type>& __ga) valarray<_Tp>::valarray(const gslice_array<value_type>& __ga)
: __begin_(nullptr), : __begin_(nullptr),
__end_(nullptr) __end_(nullptr)
{ {
const size_t __n = __ga.__1d_.size(); const size_t __n = __ga.__1d_.size();
if (__n) if (__n)
{ {
__begin_ = __end_ = allocator<value_type>().allocate(__n); __begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typedef const size_t* _Ip; typedef const size_t* _Ip;
const value_type* __s = __ga.__vp_; const value_type* __s = __ga.__vp_;
for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_;
__i != __e; ++__i, ++__end_) __i != __e; ++__i, ++__end_)
::new ((void*)__end_) value_type(__s[*__i]); ::new ((void*)__end_) value_type(__s[*__i]);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__clear(__n); __clear(__n);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
} }
template <class _Tp> template <class _Tp>
valarray<_Tp>::valarray(const mask_array<value_type>& __ma) valarray<_Tp>::valarray(const mask_array<value_type>& __ma)
: __begin_(nullptr), : __begin_(nullptr),
__end_(nullptr) __end_(nullptr)
{ {
const size_t __n = __ma.__1d_.size(); const size_t __n = __ma.__1d_.size();
if (__n) if (__n)
{ {
__begin_ = __end_ = allocator<value_type>().allocate(__n); __begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typedef const size_t* _Ip; typedef const size_t* _Ip;
const value_type* __s = __ma.__vp_; const value_type* __s = __ma.__vp_;
for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_;
__i != __e; ++__i, ++__end_) __i != __e; ++__i, ++__end_)
::new ((void*)__end_) value_type(__s[*__i]); ::new ((void*)__end_) value_type(__s[*__i]);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__clear(__n); __clear(__n);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
} }
template <class _Tp> template <class _Tp>
valarray<_Tp>::valarray(const indirect_array<value_type>& __ia) valarray<_Tp>::valarray(const indirect_array<value_type>& __ia)
: __begin_(nullptr), : __begin_(nullptr),
__end_(nullptr) __end_(nullptr)
{ {
const size_t __n = __ia.__1d_.size(); const size_t __n = __ia.__1d_.size();
if (__n) if (__n)
{ {
__begin_ = __end_ = allocator<value_type>().allocate(__n); __begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
typedef const size_t* _Ip; typedef const size_t* _Ip;
const value_type* __s = __ia.__vp_; const value_type* __s = __ia.__vp_;
for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_;
__i != __e; ++__i, ++__end_) __i != __e; ++__i, ++__end_)
::new ((void*)__end_) value_type(__s[*__i]); ::new ((void*)__end_) value_type(__s[*__i]);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__clear(__n); __clear(__n);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
} }
template <class _Tp> template <class _Tp>
inline inline
valarray<_Tp>::~valarray() valarray<_Tp>::~valarray()
{ {
__clear(size()); __clear(size());
▲ Show 20 Lines • Show All 692 Lines • ▼ Show 20 Lines
template <class _Tp> template <class _Tp>
void void
valarray<_Tp>::resize(size_t __n, value_type __x) valarray<_Tp>::resize(size_t __n, value_type __x)
{ {
__clear(size()); __clear(size());
if (__n) if (__n)
{ {
__begin_ = __end_ = allocator<value_type>().allocate(__n); __begin_ = __end_ = allocator<value_type>().allocate(__n);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (size_t __n_left = __n; __n_left; --__n_left, ++__end_) for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
::new ((void*)__end_) value_type(__x); ::new ((void*)__end_) value_type(__x);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__clear(__n); __clear(__n);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
} }
template<class _Tp> template<class _Tp>
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
void void
swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT
{ {
▲ Show 20 Lines • Show All 1,164 Lines • Show Last 20 Lines

libcxx/include/variant

Show First 20 Lines • Show All 279 Lines • ▼ Show 20 Lines const _Tp &operator[](size_t __n) const noexcept {
return __buf_[__n]; return __buf_[__n];
} }
}; };
_LIBCPP_NORETURN _LIBCPP_NORETURN
inline _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_HIDE_FROM_ABI
_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
void __throw_bad_variant_access() { void __throw_bad_variant_access() {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw bad_variant_access(); throw bad_variant_access();
#else #else
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
template <class... _Types> template <class... _Types>
class _LIBCPP_TEMPLATE_VIS variant; class _LIBCPP_TEMPLATE_VIS variant;
▲ Show 20 Lines • Show All 885 Lines • ▼ Show 20 Lines if (this->valueless_by_exception() && __that.valueless_by_exception()) {
__that); __that);
} else { } else {
__impl* __lhs = this; __impl* __lhs = this;
__impl* __rhs = _VSTD::addressof(__that); __impl* __rhs = _VSTD::addressof(__that);
if (__lhs->__move_nothrow() && !__rhs->__move_nothrow()) { if (__lhs->__move_nothrow() && !__rhs->__move_nothrow()) {
_VSTD::swap(__lhs, __rhs); _VSTD::swap(__lhs, __rhs);
} }
__impl __tmp(_VSTD::move(*__rhs)); __impl __tmp(_VSTD::move(*__rhs));
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
if constexpr (__all<is_nothrow_move_constructible_v<_Types>...>::value) { if constexpr (__all<is_nothrow_move_constructible_v<_Types>...>::value) {
this->__generic_construct(*__rhs, _VSTD::move(*__lhs)); this->__generic_construct(*__rhs, _VSTD::move(*__lhs));
} else { } else {
// EXTENSION: When the move construction of `__lhs` into `__rhs` throws // EXTENSION: When the move construction of `__lhs` into `__rhs` throws
// and `__tmp` is nothrow move constructible then we move `__tmp` back // and `__tmp` is nothrow move constructible then we move `__tmp` back
// into `__rhs` and provide the strong exception safety guarantee. // into `__rhs` and provide the strong exception safety guarantee.
try { try {
this->__generic_construct(*__rhs, _VSTD::move(*__lhs)); this->__generic_construct(*__rhs, _VSTD::move(*__lhs));
▲ Show 20 Lines • Show All 641 Lines • Show Last 20 Lines

libcxx/include/vector

Show First 20 Lines • Show All 1,506 Lines • ▼ Show 20 Lines
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
void void
vector<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT vector<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
{ {
if (capacity() > size()) if (capacity() > size())
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
allocator_type& __a = this->__alloc(); allocator_type& __a = this->__alloc();
__split_buffer<value_type, allocator_type&> __v(size(), size(), __a); __split_buffer<value_type, allocator_type&> __v(size(), size(), __a);
__swap_out_circular_buffer(__v); __swap_out_circular_buffer(__v);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
template <class _Up> template <class _Up>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
void void
vector<_Tp, _Allocator>::__push_back_slow_path(_Up&& __x) vector<_Tp, _Allocator>::__push_back_slow_path(_Up&& __x)
▲ Show 20 Lines • Show All 290 Lines • ▼ Show 20 Linesvector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
pointer __old_last = this->__end_; pointer __old_last = this->__end_;
for (; this->__end_ != this->__end_cap() && __first != __last; ++__first) for (; this->__end_ != this->__end_cap() && __first != __last; ++__first)
{ {
__construct_one_at_end(*__first); __construct_one_at_end(*__first);
} }
__split_buffer<value_type, allocator_type&> __v(__a); __split_buffer<value_type, allocator_type&> __v(__a);
if (__first != __last) if (__first != __last)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__v.__construct_at_end(__first, __last); __v.__construct_at_end(__first, __last);
difference_type __old_size = __old_last - this->__begin_; difference_type __old_size = __old_last - this->__begin_;
difference_type __old_p = __p - this->__begin_; difference_type __old_p = __p - this->__begin_;
reserve(__recommend(size() + __v.size())); reserve(__recommend(size() + __v.size()));
__p = this->__begin_ + __old_p; __p = this->__begin_ + __old_p;
__old_last = this->__begin_ + __old_size; __old_last = this->__begin_ + __old_size;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
erase(__make_iter(__old_last), end()); erase(__make_iter(__old_last), end());
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
__p = std::rotate(__p, __old_last, this->__end_); __p = std::rotate(__p, __old_last, this->__end_);
insert(__make_iter(__p), std::make_move_iterator(__v.begin()), insert(__make_iter(__p), std::make_move_iterator(__v.begin()),
std::make_move_iterator(__v.end())); std::make_move_iterator(__v.end()));
return begin() + __off; return begin() + __off;
} }
template <class _Tp, class _Allocator> template <class _Tp, class _Allocator>
▲ Show 20 Lines • Show All 738 Lines • ▼ Show 20 Lines
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type*) typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type*)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, __default_init_tag()) __cap_alloc_(0, __default_init_tag())
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
push_back(*__first); push_back(*__first);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
if (__begin_ != nullptr) if (__begin_ != nullptr)
__storage_traits::deallocate(__alloc(), __begin_, __cap()); __storage_traits::deallocate(__alloc(), __begin_, __cap());
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template <class _Allocator> template <class _Allocator>
template <class _InputIterator> template <class _InputIterator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a, vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type*) typename enable_if<__is_exactly_cpp17_input_iterator<_InputIterator>::value>::type*)
: __begin_(nullptr), : __begin_(nullptr),
__size_(0), __size_(0),
__cap_alloc_(0, static_cast<__storage_allocator>(__a)) __cap_alloc_(0, static_cast<__storage_allocator>(__a))
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
for (; __first != __last; ++__first) for (; __first != __last; ++__first)
push_back(*__first); push_back(*__first);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
if (__begin_ != nullptr) if (__begin_ != nullptr)
__storage_traits::deallocate(__alloc(), __begin_, __cap()); __storage_traits::deallocate(__alloc(), __begin_, __cap());
std::__debug_db_invalidate_all(this); std::__debug_db_invalidate_all(this);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template <class _Allocator> template <class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX20
vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last,
typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type*) typename enable_if<__is_cpp17_forward_iterator<_ForwardIterator>::value>::type*)
: __begin_(nullptr), : __begin_(nullptr),
▲ Show 20 Lines • Show All 261 Lines • ▼ Show 20 Lines
} }
template <class _Allocator> template <class _Allocator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 void _LIBCPP_CONSTEXPR_SINCE_CXX20 void
vector<bool, _Allocator>::shrink_to_fit() _NOEXCEPT vector<bool, _Allocator>::shrink_to_fit() _NOEXCEPT
{ {
if (__external_cap_to_internal(size()) > __cap()) if (__external_cap_to_internal(size()) > __cap())
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
vector(*this, allocator_type(__alloc())).swap(*this); vector(*this, allocator_type(__alloc())).swap(*this);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
} }
template <class _Allocator> template <class _Allocator>
typename vector<bool, _Allocator>::reference typename vector<bool, _Allocator>::reference
vector<bool, _Allocator>::at(size_type __n) vector<bool, _Allocator>::at(size_type __n)
{ {
if (__n >= size()) if (__n >= size())
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Linesvector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
for (; size() != capacity() && __first != __last; ++__first) for (; size() != capacity() && __first != __last; ++__first)
{ {
++this->__size_; ++this->__size_;
back() = *__first; back() = *__first;
} }
vector __v(get_allocator()); vector __v(get_allocator());
if (__first != __last) if (__first != __last)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__v.assign(__first, __last); __v.assign(__first, __last);
difference_type __old_size = static_cast<difference_type>(__old_end - begin()); difference_type __old_size = static_cast<difference_type>(__old_end - begin());
difference_type __old_p = __p - begin(); difference_type __old_p = __p - begin();
reserve(__recommend(size() + __v.size())); reserve(__recommend(size() + __v.size()));
__p = begin() + __old_p; __p = begin() + __old_p;
__old_end = begin() + __old_size; __old_end = begin() + __old_size;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
erase(__old_end, end()); erase(__old_end, end());
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
__p = std::rotate(__p, __old_end, end()); __p = std::rotate(__p, __old_end, end());
insert(__p, __v.begin(), __v.end()); insert(__p, __v.begin(), __v.end());
return begin() + __off; return begin() + __off;
} }
template <class _Allocator> template <class _Allocator>
template <class _ForwardIterator> template <class _ForwardIterator>
▲ Show 20 Lines • Show All 304 Lines • Show Last 20 Lines

libcxx/src/filesystem/filesystem_common.h

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Linesformat_string_impl(const char* msg, va_list ap) {
return result; return result;
} }
static _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 1, 2) string static _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 1, 2) string
format_string(const char* msg, ...) { format_string(const char* msg, ...) {
string ret; string ret;
va_list ap; va_list ap;
va_start(ap, msg); va_start(ap, msg);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try { try {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
ret = format_string_impl(msg, ap); ret = format_string_impl(msg, ap);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) { } catch (...) {
va_end(ap); va_end(ap);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
va_end(ap); va_end(ap);
return ret; return ret;
} }
error_code capture_errno() { error_code capture_errno() {
_LIBCPP_ASSERT(errno != 0, "Expected errno to be non-zero"); _LIBCPP_ASSERT(errno != 0, "Expected errno to be non-zero");
return error_code(errno, generic_category()); return error_code(errno, generic_category());
} }
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines void report_impl(const error_code& ec, const char* msg, va_list ap) const {
} }
__libcpp_unreachable(); __libcpp_unreachable();
} }
_LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4) _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4)
T report(const error_code& ec, const char* msg, ...) const { T report(const error_code& ec, const char* msg, ...) const {
va_list ap; va_list ap;
va_start(ap, msg); va_start(ap, msg);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try { try {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
report_impl(ec, msg, ap); report_impl(ec, msg, ap);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) { } catch (...) {
va_end(ap); va_end(ap);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
va_end(ap); va_end(ap);
return error_value<T>(); return error_value<T>();
} }
T report(errc const& err) const { T report(errc const& err) const {
return report(make_error_code(err)); return report(make_error_code(err));
} }
_LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4) _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4)
T report(errc const& err, const char* msg, ...) const { T report(errc const& err, const char* msg, ...) const {
va_list ap; va_list ap;
va_start(ap, msg); va_start(ap, msg);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try { try {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
report_impl(make_error_code(err), msg, ap); report_impl(make_error_code(err), msg, ap);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} catch (...) { } catch (...) {
va_end(ap); va_end(ap);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
va_end(ap); va_end(ap);
return error_value<T>(); return error_value<T>();
} }
private: private:
ErrorHandler(ErrorHandler const&) = delete; ErrorHandler(ErrorHandler const&) = delete;
ErrorHandler& operator=(ErrorHandler const&) = delete; ErrorHandler& operator=(ErrorHandler const&) = delete;
}; };
▲ Show 20 Lines • Show All 369 Lines • Show Last 20 Lines

libcxx/src/future.cpp

Show First 20 Lines • Show All 191 Lines • ▼ Show 20 Linespromise<void>::promise()
: __state_(new __assoc_sub_state) : __state_(new __assoc_sub_state)
{ {
} }
promise<void>::~promise() promise<void>::~promise()
{ {
if (__state_) if (__state_)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
if (!__state_->__has_value() && __state_->use_count() > 1) if (!__state_->__has_value() && __state_->use_count() > 1)
__state_->set_exception(make_exception_ptr( __state_->set_exception(make_exception_ptr(
future_error(make_error_code(future_errc::broken_promise)) future_error(make_error_code(future_errc::broken_promise))
)); ));
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__state_->__release_shared(); __state_->__release_shared();
} }
} }
future<void> future<void>
promise<void>::get_future() promise<void>::get_future()
{ {
if (__state_ == nullptr) if (__state_ == nullptr)
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

libcxx/src/ios.cpp

Show First 20 Lines • Show All 407 Lines • ▼ Show 20 Linesios_base::swap(ios_base& rhs) noexcept
_VSTD::swap(__parray_size_, rhs.__parray_size_); _VSTD::swap(__parray_size_, rhs.__parray_size_);
_VSTD::swap(__parray_cap_, rhs.__parray_cap_); _VSTD::swap(__parray_cap_, rhs.__parray_cap_);
} }
void void
ios_base::__set_badbit_and_consider_rethrow() ios_base::__set_badbit_and_consider_rethrow()
{ {
__rdstate_ |= badbit; __rdstate_ |= badbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
if (__exceptions_ & badbit) if (__exceptions_ & badbit)
throw; throw;
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
void void
ios_base::__set_failbit_and_consider_rethrow() ios_base::__set_failbit_and_consider_rethrow()
{ {
__rdstate_ |= failbit; __rdstate_ |= failbit;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
if (__exceptions_ & failbit) if (__exceptions_ & failbit)
throw; throw;
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
bool bool
ios_base::sync_with_stdio(bool sync) ios_base::sync_with_stdio(bool sync)
{ {
static bool previous_state = true; static bool previous_state = true;
bool r = previous_state; bool r = previous_state;
previous_state = sync; previous_state = sync;
return r; return r;
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS

libcxx/src/locale.cpp

Show First 20 Lines • Show All 112 Lines • ▼ Show 20 Lines
size_t size_t
countof(const T * const begin, const T * const end) countof(const T * const begin, const T * const end)
{ {
return static_cast<size_t>(end - begin); return static_cast<size_t>(end - begin);
} }
_LIBCPP_NORETURN static void __throw_runtime_error(const string &msg) _LIBCPP_NORETURN static void __throw_runtime_error(const string &msg)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw runtime_error(msg); throw runtime_error(msg);
#else #else
(void)msg; (void)msg;
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
} }
▲ Show 20 Lines • Show All 101 Lines • ▼ Show 20 Lines
#endif #endif
} }
locale::__imp::__imp(const string& name, size_t refs) locale::__imp::__imp(const string& name, size_t refs)
: facet(refs), : facet(refs),
facets_(N), facets_(N),
name_(name) name_(name)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
facets_ = locale::classic().__locale_->facets_; facets_ = locale::classic().__locale_->facets_;
for (unsigned i = 0; i < facets_.size(); ++i) for (unsigned i = 0; i < facets_.size(); ++i)
if (facets_[i]) if (facets_[i])
facets_[i]->__add_shared(); facets_[i]->__add_shared();
install(new collate_byname<char>(name_)); install(new collate_byname<char>(name_));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new collate_byname<wchar_t>(name_)); install(new collate_byname<wchar_t>(name_));
#endif #endif
Show All 30 Lines#endif
install(new time_put_byname<char>(name_)); install(new time_put_byname<char>(name_));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new time_put_byname<wchar_t>(name_)); install(new time_put_byname<wchar_t>(name_));
#endif #endif
install(new messages_byname<char>(name_)); install(new messages_byname<char>(name_));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new messages_byname<wchar_t>(name_)); install(new messages_byname<wchar_t>(name_));
#endif #endif
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
for (unsigned i = 0; i < facets_.size(); ++i) for (unsigned i = 0; i < facets_.size(); ++i)
if (facets_[i]) if (facets_[i])
facets_[i]->__release_shared(); facets_[i]->__release_shared();
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
locale::__imp::__imp(const __imp& other) locale::__imp::__imp(const __imp& other)
: facets_(max<size_t>(N, other.facets_.size())), : facets_(max<size_t>(N, other.facets_.size())),
name_(other.name_) name_(other.name_)
{ {
facets_ = other.facets_; facets_ = other.facets_;
for (unsigned i = 0; i < facets_.size(); ++i) for (unsigned i = 0; i < facets_.size(); ++i)
if (facets_[i]) if (facets_[i])
facets_[i]->__add_shared(); facets_[i]->__add_shared();
} }
locale::__imp::__imp(const __imp& other, const string& name, locale::category c) locale::__imp::__imp(const __imp& other, const string& name, locale::category c)
: facets_(N), : facets_(N),
name_("*") name_("*")
{ {
facets_ = other.facets_; facets_ = other.facets_;
for (unsigned i = 0; i < facets_.size(); ++i) for (unsigned i = 0; i < facets_.size(); ++i)
if (facets_[i]) if (facets_[i])
facets_[i]->__add_shared(); facets_[i]->__add_shared();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
if (c & locale::collate) if (c & locale::collate)
{ {
install(new collate_byname<char>(name)); install(new collate_byname<char>(name));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new collate_byname<wchar_t>(name)); install(new collate_byname<wchar_t>(name));
#endif #endif
} }
if (c & locale::ctype) if (c & locale::ctype)
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines#endif
} }
if (c & locale::messages) if (c & locale::messages)
{ {
install(new messages_byname<char>(name)); install(new messages_byname<char>(name));
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install(new messages_byname<wchar_t>(name)); install(new messages_byname<wchar_t>(name));
#endif #endif
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
for (unsigned i = 0; i < facets_.size(); ++i) for (unsigned i = 0; i < facets_.size(); ++i)
if (facets_[i]) if (facets_[i])
facets_[i]->__release_shared(); facets_[i]->__release_shared();
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
template<class F> template<class F>
inline inline
void void
locale::__imp::install_from(const locale::__imp& one) locale::__imp::install_from(const locale::__imp& one)
{ {
long id = F::id.__get(); long id = F::id.__get();
install(const_cast<F*>(static_cast<const F*>(one.use_facet(id))), id); install(const_cast<F*>(static_cast<const F*>(one.use_facet(id))), id);
} }
locale::__imp::__imp(const __imp& other, const __imp& one, locale::category c) locale::__imp::__imp(const __imp& other, const __imp& one, locale::category c)
: facets_(N), : facets_(N),
name_("*") name_("*")
{ {
facets_ = other.facets_; facets_ = other.facets_;
for (unsigned i = 0; i < facets_.size(); ++i) for (unsigned i = 0; i < facets_.size(); ++i)
if (facets_[i]) if (facets_[i])
facets_[i]->__add_shared(); facets_[i]->__add_shared();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
if (c & locale::collate) if (c & locale::collate)
{ {
install_from<_VSTD::collate<char> >(one); install_from<_VSTD::collate<char> >(one);
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install_from<_VSTD::collate<wchar_t> >(one); install_from<_VSTD::collate<wchar_t> >(one);
#endif #endif
} }
if (c & locale::ctype) if (c & locale::ctype)
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines#endif
} }
if (c & locale::messages) if (c & locale::messages)
{ {
install_from<_VSTD::messages<char> >(one); install_from<_VSTD::messages<char> >(one);
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
install_from<_VSTD::messages<wchar_t> >(one); install_from<_VSTD::messages<wchar_t> >(one);
#endif #endif
} }
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
for (unsigned i = 0; i < facets_.size(); ++i) for (unsigned i = 0; i < facets_.size(); ++i)
if (facets_[i]) if (facets_[i])
facets_[i]->__release_shared(); facets_[i]->__release_shared();
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
locale::__imp::__imp(const __imp& other, facet* f, long id) locale::__imp::__imp(const __imp& other, facet* f, long id)
: facets_(max<size_t>(N, other.facets_.size()+1)), : facets_(max<size_t>(N, other.facets_.size()+1)),
name_("*") name_("*")
{ {
f->__add_shared(); f->__add_shared();
unique_ptr<facet, release> hold(f); unique_ptr<facet, release> hold(f);
▲ Show 20 Lines • Show All 6,014 Lines • ▼ Show 20 Lines
#endif // !_LIBCPP_MSVCRT #endif // !_LIBCPP_MSVCRT
} }
#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
void __do_nothing(void*) {} void __do_nothing(void*) {}
void __throw_runtime_error(const char* msg) void __throw_runtime_error(const char* msg)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw runtime_error(msg); throw runtime_error(msg);
#else #else
(void)msg; (void)msg;
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<char>; template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<char>;
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

libcxx/src/mutex.cpp

Show First 20 Lines • Show All 205 Lines • ▼ Show 20 Lines
#endif #endif
void __call_once(volatile once_flag::_State_type& flag, void* arg, void __call_once(volatile once_flag::_State_type& flag, void* arg,
void (*func)(void*)) void (*func)(void*))
{ {
#if defined(_LIBCPP_HAS_NO_THREADS) #if defined(_LIBCPP_HAS_NO_THREADS)
if (flag == 0) if (flag == 0)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
flag = 1; flag = 1;
func(arg); func(arg);
flag = ~once_flag::_State_type(0); flag = ~once_flag::_State_type(0);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
flag = 0; flag = 0;
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
#else // !_LIBCPP_HAS_NO_THREADS #else // !_LIBCPP_HAS_NO_THREADS
__libcpp_mutex_lock(&mut); __libcpp_mutex_lock(&mut);
while (flag == 1) while (flag == 1)
__libcpp_condvar_wait(&cv, &mut); __libcpp_condvar_wait(&cv, &mut);
if (flag == 0) if (flag == 0)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
__libcpp_relaxed_store(&flag, once_flag::_State_type(1)); __libcpp_relaxed_store(&flag, once_flag::_State_type(1));
__libcpp_mutex_unlock(&mut); __libcpp_mutex_unlock(&mut);
func(arg); func(arg);
__libcpp_mutex_lock(&mut); __libcpp_mutex_lock(&mut);
__libcpp_atomic_store(&flag, ~once_flag::_State_type(0), __libcpp_atomic_store(&flag, ~once_flag::_State_type(0),
_AO_Release); _AO_Release);
__libcpp_mutex_unlock(&mut); __libcpp_mutex_unlock(&mut);
__libcpp_condvar_broadcast(&cv); __libcpp_condvar_broadcast(&cv);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
__libcpp_mutex_lock(&mut); __libcpp_mutex_lock(&mut);
__libcpp_relaxed_store(&flag, once_flag::_State_type(0)); __libcpp_relaxed_store(&flag, once_flag::_State_type(0));
__libcpp_mutex_unlock(&mut); __libcpp_mutex_unlock(&mut);
__libcpp_condvar_broadcast(&cv); __libcpp_condvar_broadcast(&cv);
throw; throw;
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
else else
__libcpp_mutex_unlock(&mut); __libcpp_mutex_unlock(&mut);
#endif // !_LIBCPP_HAS_NO_THREADS #endif // !_LIBCPP_HAS_NO_THREADS
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
_LIBCPP_POP_MACROS _LIBCPP_POP_MACROS

libcxx/src/new.cpp

Show All 33 Lines
const nothrow_t nothrow{}; const nothrow_t nothrow{};
#endif #endif
#ifndef LIBSTDCXX #ifndef LIBSTDCXX
void void
__throw_bad_alloc() __throw_bad_alloc()
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw bad_alloc(); throw bad_alloc();
#else #else
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
#endif // !LIBSTDCXX #endif // !LIBSTDCXX
Show All 17 Linesoperator new(std::size_t size) _THROW_BAD_ALLOC
while ((p = ::malloc(size)) == nullptr) while ((p = ::malloc(size)) == nullptr)
{ {
// If malloc fails and there is a new_handler, // If malloc fails and there is a new_handler,
// call it to try free up memory. // call it to try free up memory.
std::new_handler nh = std::get_new_handler(); std::new_handler nh = std::get_new_handler();
if (nh) if (nh)
nh(); nh();
else else
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw std::bad_alloc(); throw std::bad_alloc();
#else #else
break; break;
#endif #endif
} }
return p; return p;
} }
_LIBCPP_WEAK _LIBCPP_WEAK
void* void*
operator new(size_t size, const std::nothrow_t&) noexcept operator new(size_t size, const std::nothrow_t&) noexcept
{ {
void* p = nullptr; void* p = nullptr;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
p = ::operator new(size); p = ::operator new(size);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return p; return p;
} }
_LIBCPP_WEAK _LIBCPP_WEAK
void* void*
operator new[](size_t size) _THROW_BAD_ALLOC operator new[](size_t size) _THROW_BAD_ALLOC
{ {
return ::operator new(size); return ::operator new(size);
} }
_LIBCPP_WEAK _LIBCPP_WEAK
void* void*
operator new[](size_t size, const std::nothrow_t&) noexcept operator new[](size_t size, const std::nothrow_t&) noexcept
{ {
void* p = nullptr; void* p = nullptr;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
p = ::operator new[](size); p = ::operator new[](size);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return p; return p;
} }
_LIBCPP_WEAK _LIBCPP_WEAK
void void
operator delete(void* ptr) noexcept operator delete(void* ptr) noexcept
{ {
::free(ptr); ::free(ptr);
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Linesoperator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
// (or return nullptr if exceptions are disabled). // (or return nullptr if exceptions are disabled).
void* p; void* p;
while ((p = std::__libcpp_aligned_alloc(static_cast<std::size_t>(alignment), size)) == nullptr) while ((p = std::__libcpp_aligned_alloc(static_cast<std::size_t>(alignment), size)) == nullptr)
{ {
std::new_handler nh = std::get_new_handler(); std::new_handler nh = std::get_new_handler();
if (nh) if (nh)
nh(); nh();
else { else {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw std::bad_alloc(); throw std::bad_alloc();
#else #else
break; break;
#endif #endif
} }
} }
return p; return p;
} }
_LIBCPP_WEAK _LIBCPP_WEAK
void* void*
operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
{ {
void* p = nullptr; void* p = nullptr;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
p = ::operator new(size, alignment); p = ::operator new(size, alignment);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return p; return p;
} }
_LIBCPP_WEAK _LIBCPP_WEAK
void* void*
operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
{ {
return ::operator new(size, alignment); return ::operator new(size, alignment);
} }
_LIBCPP_WEAK _LIBCPP_WEAK
void* void*
operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
{ {
void* p = nullptr; void* p = nullptr;
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
p = ::operator new[](size, alignment); p = ::operator new[](size, alignment);
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
return p; return p;
} }
_LIBCPP_WEAK _LIBCPP_WEAK
void void
operator delete(void* ptr, std::align_val_t) noexcept operator delete(void* ptr, std::align_val_t) noexcept
{ {
std::__libcpp_aligned_free(ptr); std::__libcpp_aligned_free(ptr);
Show All 39 Lines

libcxx/src/string.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
template string operator+<char, char_traits<char>, allocator<char>>(char const*, string const&); template string operator+<char, char_traits<char>, allocator<char>>(char const*, string const&);
namespace namespace
{ {
template<typename T> template<typename T>
inline void throw_helper(const string& msg) { inline void throw_helper(const string& msg) {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw T(msg); throw T(msg);
#else #else
fprintf(stderr, "%s\n", msg.c_str()); fprintf(stderr, "%s\n", msg.c_str());
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
inline void throw_from_string_out_of_range(const string& func) { inline void throw_from_string_out_of_range(const string& func) {
▲ Show 20 Lines • Show All 318 Lines • Show Last 20 Lines

libcxx/src/support/runtime/exception_fallback.ipp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
{ {
return __libcpp_atomic_load(&__terminate_handler); return __libcpp_atomic_load(&__terminate_handler);
} }
_LIBCPP_NORETURN _LIBCPP_NORETURN
void void
terminate() noexcept terminate() noexcept
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
(*get_terminate())(); (*get_terminate())();
// handler should not return // handler should not return
fprintf(stderr, "terminate_handler unexpectedly returned\n"); fprintf(stderr, "terminate_handler unexpectedly returned\n");
::abort(); ::abort();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
// handler should not throw exception // handler should not throw exception
fprintf(stderr, "terminate_handler unexpectedly threw an exception\n"); fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
::abort(); ::abort();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; } bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; }
int uncaught_exceptions() noexcept int uncaught_exceptions() noexcept
{ {
#warning uncaught_exception not yet implemented #warning uncaught_exception not yet implemented
fprintf(stderr, "uncaught_exceptions not yet implemented\n"); fprintf(stderr, "uncaught_exceptions not yet implemented\n");
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

libcxx/src/support/runtime/exception_msvc.ipp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
terminate_handler get_terminate() noexcept { terminate_handler get_terminate() noexcept {
return ::_get_terminate(); return ::_get_terminate();
} }
_LIBCPP_NORETURN _LIBCPP_NORETURN
void terminate() noexcept void terminate() noexcept
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
try try
{ {
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
(*get_terminate())(); (*get_terminate())();
// handler should not return // handler should not return
fprintf(stderr, "terminate_handler unexpectedly returned\n"); fprintf(stderr, "terminate_handler unexpectedly returned\n");
::abort(); ::abort();
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
} }
catch (...) catch (...)
{ {
// handler should not throw exception // handler should not throw exception
fprintf(stderr, "terminate_handler unexpectedly threw an exception\n"); fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
::abort(); ::abort();
} }
#endif // _LIBCPP_NO_EXCEPTIONS #endif // _LIBCPP_HAS_NO_EXCEPTIONS
} }
bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; } bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; }
int uncaught_exceptions() noexcept { int uncaught_exceptions() noexcept {
return __uncaught_exceptions(); return __uncaught_exceptions();
} }
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

libcxx/src/system_error.cpp

Show First 20 Lines • Show All 280 Lines • ▼ Show 20 Lines
system_error::~system_error() noexcept system_error::~system_error() noexcept
{ {
} }
void void
__throw_system_error(int ev, const char* what_arg) __throw_system_error(int ev, const char* what_arg)
{ {
#ifndef _LIBCPP_NO_EXCEPTIONS #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
throw system_error(error_code(ev, system_category()), what_arg); throw system_error(error_code(ev, system_category()), what_arg);
#else #else
(void)ev; (void)ev;
(void)what_arg; (void)what_arg;
_VSTD::abort(); _VSTD::abort();
#endif #endif
} }
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD