Compare commits
1 Commits
release_32
...
svn-tags/l
| Author | SHA1 | Date | |
|---|---|---|---|
|
11f376d956 |
@@ -87,17 +87,17 @@ macro(append_if list condition var)
|
||||
endmacro()
|
||||
|
||||
# Get warning flags
|
||||
append_if(LIBCXX_CXX_WARNING_FLAGS LIBCXX_HAS_WALL_FLAG -Wall)
|
||||
append_if(LIBCXX_CXX_WARNING_FLAGS LIBCXX_HAS_W_FLAG -W)
|
||||
append_if(LIBCXX_CXX_WARNING_FLAGS LIBCXX_HAS_WNO_UNUSED_PARAMETER_FLAG -Wno-unused-parameter)
|
||||
append_if(LIBCXX_CXX_WARNING_FLAGS LIBCXX_HAS_WWRITE_STRINGS_FLAG -Wwrite-strings)
|
||||
append_if(LIBCXX_CXX_WARNING_FLAGS LIBCXX_HAS_WNO_LONG_LONG_FLAG -Wno-long-long)
|
||||
append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WALL_FLAG -Wall)
|
||||
append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_W_FLAG -W)
|
||||
append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WNO_UNUSED_PARAMETER_FLAG -Wno-unused-parameter)
|
||||
append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WWRITE_STRINGS_FLAG -Wwrite-strings)
|
||||
append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WNO_LONG_LONG_FLAG -Wno-long-long)
|
||||
if (LIBCXX_ENABLE_WERROR)
|
||||
append_if(LIBCXX_CXX_WARNING_FLAGS LIBCXX_HAS_WERROR_FLAG -Werror)
|
||||
append_if(LIBCXX_CXX_WARNING_FLAGS LIBCXX_HAS_WX_FLAG -WX)
|
||||
append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WERROR_FLAG -Werror)
|
||||
append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WX_FLAG -WX)
|
||||
endif()
|
||||
if (LIBCXX_ENABLE_PEDANTIC)
|
||||
append_if(LIBCXX_CXX_WARNING_FLAGS LIBCXX_HAS_PEDANTIC_FLAG -pedantic)
|
||||
append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_PEDANTIC_FLAG -pedantic)
|
||||
endif()
|
||||
|
||||
# Get feature flags.
|
||||
@@ -119,8 +119,7 @@ if (NOT LIBCXX_ENABLE_RTTI)
|
||||
append_if(LIBCXX_CXX_FEATURE_FLAGS LIBCXX_HAS_FNO_RTTI_FLAG -fno-rtti)
|
||||
endif()
|
||||
# Assert
|
||||
string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
|
||||
if (LIBCXX_ENABLE_ASSERTIONS)
|
||||
if (LLVM_ENABLE_ASSERTIONS)
|
||||
# MSVC doesn't like _DEBUG on release builds. See PR 4379.
|
||||
if (NOT MSVC)
|
||||
list(APPEND LIBCXX_CXX_FEATURE_FLAGS -D_DEBUG)
|
||||
|
||||
56
CREDITS.TXT
56
CREDITS.TXT
@@ -13,64 +13,10 @@ E: hhinnant@apple.com
|
||||
D: Architect and primary author of libc++
|
||||
|
||||
N: Marshall Clow
|
||||
E: mclow.lists@gmail.com
|
||||
E: marshall@idio.com
|
||||
E: mclow@qualcomm.com
|
||||
D: Minor patches and bug fixes.
|
||||
|
||||
N: Bjorn Reese
|
||||
E: breese@users.sourceforge.net
|
||||
D: Initial regex prototype
|
||||
|
||||
N: David Chisnall
|
||||
E: theraven at theravensnest dot org
|
||||
D: FreeBSD and Solaris ports, libcxxrt support, some atomics work.
|
||||
|
||||
N: Ruben Van Boxem
|
||||
E: vanboxem dot ruben at gmail dot com
|
||||
D: Initial Windows patches.
|
||||
|
||||
N: Arvid Picciani
|
||||
E: aep at exys dot org
|
||||
D: Minor patches and musl port.
|
||||
|
||||
N: Craig Silverstein
|
||||
E: csilvers@google.com
|
||||
D: Implemented Cityhash as the string hash function on 64-bit machines
|
||||
|
||||
N: Google Inc.
|
||||
D: Copyright owner and contributor of the CityHash algorithm
|
||||
|
||||
N: Jeffrey Yasskin
|
||||
E: jyasskin@gmail.com
|
||||
E: jyasskin@google.com
|
||||
D: Linux fixes.
|
||||
|
||||
N: Jonathan Sauer
|
||||
D: Minor patches, mostly related to constexpr
|
||||
|
||||
N: Richard Smith
|
||||
D: Minor patches.
|
||||
|
||||
N: Andrew Morrow
|
||||
E: andrew.c.morrow@gmail.com
|
||||
D: Minor patches and Linux fixes.
|
||||
|
||||
N: Hyeon-bin Jeong
|
||||
E: tuhertz@gmail.com
|
||||
D: Minor patches and bug fixes.
|
||||
|
||||
N: Michel Morin
|
||||
E: mimomorin@gmail.com
|
||||
D: Minor patches to is_convertible.
|
||||
|
||||
N: Dimitry Andric
|
||||
E: dimitry@andric.com
|
||||
D: Visibility fixes, minor FreeBSD portability patches.
|
||||
|
||||
N: Holger Arnold
|
||||
E: holgerar@gmail.com
|
||||
D: Minor fix.
|
||||
|
||||
N: Argyrios Kyrtzidis
|
||||
E: kyrtzidis@apple.com
|
||||
D: Bug fixes.
|
||||
|
||||
@@ -14,7 +14,7 @@ Full text of the relevant licenses is included below.
|
||||
University of Illinois/NCSA
|
||||
Open Source License
|
||||
|
||||
Copyright (c) 2009-2012 by the contributors listed in CREDITS.TXT
|
||||
Copyright (c) 2009-2010 by the contributors listed in CREDITS.TXT
|
||||
|
||||
All rights reserved.
|
||||
|
||||
@@ -55,7 +55,7 @@ SOFTWARE.
|
||||
|
||||
==============================================================================
|
||||
|
||||
Copyright (c) 2009-2012 by the contributors listed in CREDITS.TXT
|
||||
Copyright (c) 2009-2010 by the contributors listed in CREDITS.TXT
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
|
||||
36
Makefile
36
Makefile
@@ -14,12 +14,9 @@ ifeq (,$(RC_INDIGO))
|
||||
else
|
||||
INSTALL_PREFIX="$(SDKROOT)"
|
||||
endif
|
||||
INSTALL_DIR=$(DSTROOT)/$(INSTALL_PREFIX)
|
||||
|
||||
.PHONY: help installsrc clean installheaders install
|
||||
|
||||
help::
|
||||
@echo "Use make install DSTROOT=<destination>"
|
||||
echo Use make install DSTROOT=<destination>
|
||||
|
||||
installsrc:: $(SRCROOT)
|
||||
|
||||
@@ -30,24 +27,21 @@ installsrc:: $(SRCROOT)
|
||||
|
||||
clean::
|
||||
|
||||
# The installheaders target is used by clang's runtime/libcxx makefile.
|
||||
installheaders::
|
||||
mkdir -p $(HEADER_DIR)/c++/v1/ext
|
||||
rsync -r --exclude=".*" --exclude="support" $(SRCDIRS)/include/* \
|
||||
$(HEADER_DIR)/c++/v1/
|
||||
chown -R root:wheel $(HEADER_DIR)/c++
|
||||
chmod 755 $(HEADER_DIR)/c++/v1
|
||||
chmod 644 $(HEADER_DIR)/c++/v1/*
|
||||
chmod 755 $(HEADER_DIR)/c++/v1/ext
|
||||
chmod 644 $(HEADER_DIR)/c++/v1/ext/*
|
||||
installhdrs::
|
||||
|
||||
install::
|
||||
mkdir -p $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/ext
|
||||
rsync -r --exclude=".*" $(SRCDIRS)/include/* $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/
|
||||
chown -R root:wheel $(DSTROOT)/$(INSTALL_PREFIX)/usr/include
|
||||
chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1
|
||||
chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/*
|
||||
chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/ext
|
||||
chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/ext/*
|
||||
|
||||
install:: installhdrs $(DESTDIR)
|
||||
|
||||
cd lib && ./buildit
|
||||
ditto lib/libc++.1.dylib $(SYMROOT)/usr/lib/libc++.1.dylib
|
||||
cd lib && dsymutil -o $(SYMROOT)/libc++.1.dylib.dSYM \
|
||||
$(SYMROOT)/usr/lib/libc++.1.dylib
|
||||
mkdir -p $(INSTALL_DIR)/usr/lib
|
||||
strip -S -o $(INSTALL_DIR)/usr/lib/libc++.1.dylib \
|
||||
$(SYMROOT)/usr/lib/libc++.1.dylib
|
||||
cd $(INSTALL_DIR)/usr/lib && ln -s libc++.1.dylib libc++.dylib
|
||||
cd lib && dsymutil -o $(SYMROOT)/libc++.1.dylib.dSYM $(SYMROOT)/usr/lib/libc++.1.dylib
|
||||
mkdir -p $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib
|
||||
strip -S -o $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/libc++.1.dylib $(SYMROOT)/usr/lib/libc++.1.dylib
|
||||
cd $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib && ln -s libc++.1.dylib libc++.dylib
|
||||
|
||||
@@ -14,16 +14,12 @@
|
||||
#include <__config>
|
||||
#include <algorithm>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _Cp, bool _IsConst, typename _Cp::__storage_type = 0> class __bit_iterator;
|
||||
template <class _Cp> class __bit_const_reference;
|
||||
template <class _C, bool _IsConst> class __bit_iterator;
|
||||
template <class _C> class __bit_const_reference;
|
||||
|
||||
template <class _Tp>
|
||||
struct __has_storage_type
|
||||
@@ -31,22 +27,22 @@ struct __has_storage_type
|
||||
static const bool value = false;
|
||||
};
|
||||
|
||||
template <class _Cp, bool = __has_storage_type<_Cp>::value>
|
||||
template <class _C, bool = __has_storage_type<_C>::value>
|
||||
class __bit_reference
|
||||
{
|
||||
typedef typename _Cp::__storage_type __storage_type;
|
||||
typedef typename _Cp::__storage_pointer __storage_pointer;
|
||||
typedef typename _C::__storage_type __storage_type;
|
||||
typedef typename _C::__storage_pointer __storage_pointer;
|
||||
|
||||
__storage_pointer __seg_;
|
||||
__storage_type __mask_;
|
||||
|
||||
#if defined(__clang__)
|
||||
friend typename _Cp::__self;
|
||||
friend typename _C::__self;
|
||||
#else
|
||||
friend class _Cp::__self;
|
||||
friend class _C::__self;
|
||||
#endif
|
||||
friend class __bit_const_reference<_Cp>;
|
||||
friend class __bit_iterator<_Cp, false>;
|
||||
friend class __bit_const_reference<_C>;
|
||||
friend class __bit_iterator<_C, false>;
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY operator bool() const _NOEXCEPT
|
||||
{return static_cast<bool>(*__seg_ & __mask_);}
|
||||
@@ -68,77 +64,76 @@ public:
|
||||
{return operator=(static_cast<bool>(__x));}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY void flip() _NOEXCEPT {*__seg_ ^= __mask_;}
|
||||
_LIBCPP_INLINE_VISIBILITY __bit_iterator<_Cp, false> operator&() const _NOEXCEPT
|
||||
{return __bit_iterator<_Cp, false>(__seg_, static_cast<unsigned>(__ctz(__mask_)));}
|
||||
_LIBCPP_INLINE_VISIBILITY __bit_iterator<_C, false> operator&() const _NOEXCEPT
|
||||
{return __bit_iterator<_C, false>(__seg_, static_cast<unsigned>(__ctz(__mask_)));}
|
||||
private:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__bit_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
|
||||
: __seg_(__s), __mask_(__m) {}
|
||||
};
|
||||
|
||||
template <class _Cp>
|
||||
class __bit_reference<_Cp, false>
|
||||
template <class _C>
|
||||
class __bit_reference<_C, false>
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Cp, class _Dp>
|
||||
template <class _C, class _D>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
void
|
||||
swap(__bit_reference<_Cp> __x, __bit_reference<_Dp> __y) _NOEXCEPT
|
||||
swap(__bit_reference<_C> __x, __bit_reference<_D> __y) _NOEXCEPT
|
||||
{
|
||||
bool __t = __x;
|
||||
__x = __y;
|
||||
__y = __t;
|
||||
}
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
void
|
||||
swap(__bit_reference<_Cp> __x, bool& __y) _NOEXCEPT
|
||||
swap(__bit_reference<_C> __x, bool& __y) _NOEXCEPT
|
||||
{
|
||||
bool __t = __x;
|
||||
__x = __y;
|
||||
__y = __t;
|
||||
}
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
void
|
||||
swap(bool& __x, __bit_reference<_Cp> __y) _NOEXCEPT
|
||||
swap(bool& __x, __bit_reference<_C> __y) _NOEXCEPT
|
||||
{
|
||||
bool __t = __x;
|
||||
__x = __y;
|
||||
__y = __t;
|
||||
}
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
class __bit_const_reference
|
||||
{
|
||||
typedef typename _Cp::__storage_type __storage_type;
|
||||
typedef typename _Cp::__const_storage_pointer __storage_pointer;
|
||||
typedef typename _C::__storage_type __storage_type;
|
||||
typedef typename _C::__const_storage_pointer __storage_pointer;
|
||||
|
||||
__storage_pointer __seg_;
|
||||
__storage_type __mask_;
|
||||
|
||||
#if defined(__clang__)
|
||||
friend typename _Cp::__self;
|
||||
friend typename _C::__self;
|
||||
#else
|
||||
friend class _Cp::__self;
|
||||
friend class _C::__self;
|
||||
#endif
|
||||
friend class __bit_iterator<_Cp, true>;
|
||||
friend class __bit_iterator<_C, true>;
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__bit_const_reference(const __bit_reference<_Cp>& __x) _NOEXCEPT
|
||||
__bit_const_reference(const __bit_reference<_C>& __x) _NOEXCEPT
|
||||
: __seg_(__x.__seg_), __mask_(__x.__mask_) {}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR operator bool() const _NOEXCEPT
|
||||
_LIBCPP_INLINE_VISIBILITY operator bool() const _NOEXCEPT
|
||||
{return static_cast<bool>(*__seg_ & __mask_);}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY __bit_iterator<_Cp, true> operator&() const _NOEXCEPT
|
||||
{return __bit_iterator<_Cp, true>(__seg_, static_cast<unsigned>(__ctz(__mask_)));}
|
||||
_LIBCPP_INLINE_VISIBILITY __bit_iterator<_C, true> operator&() const _NOEXCEPT
|
||||
{return __bit_iterator<_C, true>(__seg_, static_cast<unsigned>(__ctz(__mask_)));}
|
||||
private:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
__bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
|
||||
: __seg_(__s), __mask_(__m) {}
|
||||
|
||||
@@ -147,11 +142,11 @@ private:
|
||||
|
||||
// find
|
||||
|
||||
template <class _Cp, bool _IsConst>
|
||||
__bit_iterator<_Cp, _IsConst>
|
||||
__find_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
|
||||
template <class _C>
|
||||
__bit_iterator<_C, false>
|
||||
__find_bool_true(__bit_iterator<_C, false> __first, typename _C::size_type __n)
|
||||
{
|
||||
typedef __bit_iterator<_Cp, _IsConst> _It;
|
||||
typedef __bit_iterator<_C, false> _It;
|
||||
typedef typename _It::__storage_type __storage_type;
|
||||
static const unsigned __bits_per_word = _It::__bits_per_word;
|
||||
// do first partial word
|
||||
@@ -181,11 +176,11 @@ __find_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type
|
||||
return _It(__first.__seg_, static_cast<unsigned>(__n));
|
||||
}
|
||||
|
||||
template <class _Cp, bool _IsConst>
|
||||
__bit_iterator<_Cp, _IsConst>
|
||||
__find_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
|
||||
template <class _C>
|
||||
__bit_iterator<_C, false>
|
||||
__find_bool_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
|
||||
{
|
||||
typedef __bit_iterator<_Cp, _IsConst> _It;
|
||||
typedef __bit_iterator<_C, false> _It;
|
||||
typedef typename _It::__storage_type __storage_type;
|
||||
static const unsigned __bits_per_word = _It::__bits_per_word;
|
||||
// do first partial word
|
||||
@@ -194,7 +189,7 @@ __find_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type
|
||||
__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
|
||||
__storage_type __dn = _VSTD::min(__clz_f, __n);
|
||||
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
|
||||
__storage_type __b = ~*__first.__seg_ & __m;
|
||||
__storage_type __b = ~(*__first.__seg_ & __m);
|
||||
if (__b)
|
||||
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
|
||||
__n -= __dn;
|
||||
@@ -211,30 +206,30 @@ __find_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type
|
||||
if (__n > 0)
|
||||
{
|
||||
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
|
||||
__storage_type __b = ~*__first.__seg_ & __m;
|
||||
__storage_type __b = ~(*__first.__seg_ & __m);
|
||||
if (__b)
|
||||
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
|
||||
}
|
||||
return _It(__first.__seg_, static_cast<unsigned>(__n));
|
||||
}
|
||||
|
||||
template <class _Cp, bool _IsConst, class _Tp>
|
||||
template <class _C, class _Tp>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
__bit_iterator<_Cp, _IsConst>
|
||||
find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_)
|
||||
__bit_iterator<_C, false>
|
||||
find(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __last, const _Tp& __value)
|
||||
{
|
||||
if (static_cast<bool>(__value_))
|
||||
return __find_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
|
||||
return __find_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
|
||||
if (static_cast<bool>(__value))
|
||||
return __find_bool_true(__first, static_cast<typename _C::size_type>(__last - __first));
|
||||
return __find_bool_false(__first, static_cast<typename _C::size_type>(__last - __first));
|
||||
}
|
||||
|
||||
// count
|
||||
|
||||
template <class _Cp, bool _IsConst>
|
||||
typename __bit_iterator<_Cp, _IsConst>::difference_type
|
||||
__count_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
|
||||
template <class _C>
|
||||
typename __bit_iterator<_C, false>::difference_type
|
||||
__count_bool_true(__bit_iterator<_C, false> __first, typename _C::size_type __n)
|
||||
{
|
||||
typedef __bit_iterator<_Cp, _IsConst> _It;
|
||||
typedef __bit_iterator<_C, false> _It;
|
||||
typedef typename _It::__storage_type __storage_type;
|
||||
typedef typename _It::difference_type difference_type;
|
||||
static const unsigned __bits_per_word = _It::__bits_per_word;
|
||||
@@ -261,11 +256,11 @@ __count_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type
|
||||
return __r;
|
||||
}
|
||||
|
||||
template <class _Cp, bool _IsConst>
|
||||
typename __bit_iterator<_Cp, _IsConst>::difference_type
|
||||
__count_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
|
||||
template <class _C>
|
||||
typename __bit_iterator<_C, false>::difference_type
|
||||
__count_bool_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
|
||||
{
|
||||
typedef __bit_iterator<_Cp, _IsConst> _It;
|
||||
typedef __bit_iterator<_C, false> _It;
|
||||
typedef typename _It::__storage_type __storage_type;
|
||||
typedef typename _It::difference_type difference_type;
|
||||
static const unsigned __bits_per_word = _It::__bits_per_word;
|
||||
@@ -276,7 +271,7 @@ __count_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_typ
|
||||
__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
|
||||
__storage_type __dn = _VSTD::min(__clz_f, __n);
|
||||
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
|
||||
__r = _VSTD::__pop_count(~*__first.__seg_ & __m);
|
||||
__r = _VSTD::__pop_count(~(*__first.__seg_ & __m));
|
||||
__n -= __dn;
|
||||
++__first.__seg_;
|
||||
}
|
||||
@@ -287,28 +282,28 @@ __count_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_typ
|
||||
if (__n > 0)
|
||||
{
|
||||
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
|
||||
__r += _VSTD::__pop_count(~*__first.__seg_ & __m);
|
||||
__r += _VSTD::__pop_count(~(*__first.__seg_ & __m));
|
||||
}
|
||||
return __r;
|
||||
}
|
||||
|
||||
template <class _Cp, bool _IsConst, class _Tp>
|
||||
template <class _C, class _Tp>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
typename __bit_iterator<_Cp, _IsConst>::difference_type
|
||||
count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_)
|
||||
typename __bit_iterator<_C, false>::difference_type
|
||||
count(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __last, const _Tp& __value)
|
||||
{
|
||||
if (static_cast<bool>(__value_))
|
||||
return __count_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
|
||||
return __count_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
|
||||
if (static_cast<bool>(__value))
|
||||
return __count_bool_true(__first, static_cast<typename _C::size_type>(__last - __first));
|
||||
return __count_bool_false(__first, static_cast<typename _C::size_type>(__last - __first));
|
||||
}
|
||||
|
||||
// fill_n
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
void
|
||||
__fill_n_false(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
|
||||
__fill_n_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
|
||||
{
|
||||
typedef __bit_iterator<_Cp, false> _It;
|
||||
typedef __bit_iterator<_C, false> _It;
|
||||
typedef typename _It::__storage_type __storage_type;
|
||||
static const unsigned __bits_per_word = _It::__bits_per_word;
|
||||
// do first partial word
|
||||
@@ -334,11 +329,11 @@ __fill_n_false(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
|
||||
}
|
||||
}
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
void
|
||||
__fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
|
||||
__fill_n_true(__bit_iterator<_C, false> __first, typename _C::size_type __n)
|
||||
{
|
||||
typedef __bit_iterator<_Cp, false> _It;
|
||||
typedef __bit_iterator<_C, false> _It;
|
||||
typedef typename _It::__storage_type __storage_type;
|
||||
static const unsigned __bits_per_word = _It::__bits_per_word;
|
||||
// do first partial word
|
||||
@@ -364,14 +359,14 @@ __fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
|
||||
}
|
||||
}
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
void
|
||||
fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __value_)
|
||||
fill_n(__bit_iterator<_C, false> __first, typename _C::size_type __n, bool __value)
|
||||
{
|
||||
if (__n > 0)
|
||||
{
|
||||
if (__value_)
|
||||
if (__value)
|
||||
__fill_n_true(__first, __n);
|
||||
else
|
||||
__fill_n_false(__first, __n);
|
||||
@@ -380,22 +375,22 @@ fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __v
|
||||
|
||||
// fill
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
void
|
||||
fill(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __last, bool __value_)
|
||||
fill(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __last, bool __value)
|
||||
{
|
||||
_VSTD::fill_n(__first, static_cast<typename _Cp::size_type>(__last - __first), __value_);
|
||||
_VSTD::fill_n(__first, static_cast<typename _C::size_type>(__last - __first), __value);
|
||||
}
|
||||
|
||||
// copy
|
||||
|
||||
template <class _Cp, bool _IsConst>
|
||||
__bit_iterator<_Cp, false>
|
||||
__copy_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
|
||||
__bit_iterator<_Cp, false> __result)
|
||||
template <class _C, bool _IsConst>
|
||||
__bit_iterator<_C, false>
|
||||
__copy_aligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last,
|
||||
__bit_iterator<_C, false> __result)
|
||||
{
|
||||
typedef __bit_iterator<_Cp, _IsConst> _In;
|
||||
typedef __bit_iterator<_C, _IsConst> _In;
|
||||
typedef typename _In::difference_type difference_type;
|
||||
typedef typename _In::__storage_type __storage_type;
|
||||
static const unsigned __bits_per_word = _In::__bits_per_word;
|
||||
@@ -437,12 +432,12 @@ __copy_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsCon
|
||||
return __result;
|
||||
}
|
||||
|
||||
template <class _Cp, bool _IsConst>
|
||||
__bit_iterator<_Cp, false>
|
||||
__copy_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
|
||||
__bit_iterator<_Cp, false> __result)
|
||||
template <class _C, bool _IsConst>
|
||||
__bit_iterator<_C, false>
|
||||
__copy_unaligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last,
|
||||
__bit_iterator<_C, false> __result)
|
||||
{
|
||||
typedef __bit_iterator<_Cp, _IsConst> _In;
|
||||
typedef __bit_iterator<_C, _IsConst> _In;
|
||||
typedef typename _In::difference_type difference_type;
|
||||
typedef typename _In::__storage_type __storage_type;
|
||||
static const unsigned __bits_per_word = _In::__bits_per_word;
|
||||
@@ -515,10 +510,10 @@ __copy_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsC
|
||||
return __result;
|
||||
}
|
||||
|
||||
template <class _Cp, bool _IsConst>
|
||||
template <class _C, bool _IsConst>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
__bit_iterator<_Cp, false>
|
||||
copy(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
|
||||
__bit_iterator<_C, false>
|
||||
copy(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last, __bit_iterator<_C, false> __result)
|
||||
{
|
||||
if (__first.__ctz_ == __result.__ctz_)
|
||||
return __copy_aligned(__first, __last, __result);
|
||||
@@ -527,12 +522,12 @@ copy(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last
|
||||
|
||||
// copy_backward
|
||||
|
||||
template <class _Cp, bool _IsConst>
|
||||
__bit_iterator<_Cp, false>
|
||||
__copy_backward_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
|
||||
__bit_iterator<_Cp, false> __result)
|
||||
template <class _C, bool _IsConst>
|
||||
__bit_iterator<_C, false>
|
||||
__copy_backward_aligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last,
|
||||
__bit_iterator<_C, false> __result)
|
||||
{
|
||||
typedef __bit_iterator<_Cp, _IsConst> _In;
|
||||
typedef __bit_iterator<_C, _IsConst> _In;
|
||||
typedef typename _In::difference_type difference_type;
|
||||
typedef typename _In::__storage_type __storage_type;
|
||||
static const unsigned __bits_per_word = _In::__bits_per_word;
|
||||
@@ -574,12 +569,12 @@ __copy_backward_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_C
|
||||
return __result;
|
||||
}
|
||||
|
||||
template <class _Cp, bool _IsConst>
|
||||
__bit_iterator<_Cp, false>
|
||||
__copy_backward_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
|
||||
__bit_iterator<_Cp, false> __result)
|
||||
template <class _C, bool _IsConst>
|
||||
__bit_iterator<_C, false>
|
||||
__copy_backward_unaligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last,
|
||||
__bit_iterator<_C, false> __result)
|
||||
{
|
||||
typedef __bit_iterator<_Cp, _IsConst> _In;
|
||||
typedef __bit_iterator<_C, _IsConst> _In;
|
||||
typedef typename _In::difference_type difference_type;
|
||||
typedef typename _In::__storage_type __storage_type;
|
||||
static const unsigned __bits_per_word = _In::__bits_per_word;
|
||||
@@ -638,7 +633,7 @@ __copy_backward_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<
|
||||
{
|
||||
__m = ~__storage_type(0) << (__bits_per_word - __n);
|
||||
__storage_type __b = *--__last.__seg_ & __m;
|
||||
__clz_r = __bits_per_word - __result.__ctz_;
|
||||
unsigned __clz_r = __bits_per_word - __result.__ctz_;
|
||||
__storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__result.__ctz_));
|
||||
__m = (~__storage_type(0) << (__result.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_r);
|
||||
*__result.__seg_ &= ~__m;
|
||||
@@ -660,10 +655,10 @@ __copy_backward_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<
|
||||
return __result;
|
||||
}
|
||||
|
||||
template <class _Cp, bool _IsConst>
|
||||
template <class _C, bool _IsConst>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
__bit_iterator<_Cp, false>
|
||||
copy_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
|
||||
__bit_iterator<_C, false>
|
||||
copy_backward(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last, __bit_iterator<_C, false> __result)
|
||||
{
|
||||
if (__last.__ctz_ == __result.__ctz_)
|
||||
return __copy_backward_aligned(__first, __last, __result);
|
||||
@@ -672,32 +667,32 @@ copy_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsCons
|
||||
|
||||
// move
|
||||
|
||||
template <class _Cp, bool _IsConst>
|
||||
template <class _C, bool _IsConst>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
__bit_iterator<_Cp, false>
|
||||
move(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
|
||||
__bit_iterator<_C, false>
|
||||
move(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last, __bit_iterator<_C, false> __result)
|
||||
{
|
||||
return _VSTD::copy(__first, __last, __result);
|
||||
}
|
||||
|
||||
// move_backward
|
||||
|
||||
template <class _Cp, bool _IsConst>
|
||||
template <class _C, bool _IsConst>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
__bit_iterator<_Cp, false>
|
||||
move_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
|
||||
__bit_iterator<_C, false>
|
||||
move_backward(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last, __bit_iterator<_C, false> __result)
|
||||
{
|
||||
return _VSTD::copy(__first, __last, __result);
|
||||
}
|
||||
|
||||
// swap_ranges
|
||||
|
||||
template <class __C1, class __C2>
|
||||
__bit_iterator<__C2, false>
|
||||
__swap_ranges_aligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,
|
||||
__bit_iterator<__C2, false> __result)
|
||||
template <class _C1, class _C2>
|
||||
__bit_iterator<_C2, false>
|
||||
__swap_ranges_aligned(__bit_iterator<_C1, false> __first, __bit_iterator<_C1, false> __last,
|
||||
__bit_iterator<_C2, false> __result)
|
||||
{
|
||||
typedef __bit_iterator<__C1, false> _I1;
|
||||
typedef __bit_iterator<_C1, false> _I1;
|
||||
typedef typename _I1::difference_type difference_type;
|
||||
typedef typename _I1::__storage_type __storage_type;
|
||||
static const unsigned __bits_per_word = _I1::__bits_per_word;
|
||||
@@ -742,12 +737,12 @@ __swap_ranges_aligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1,
|
||||
return __result;
|
||||
}
|
||||
|
||||
template <class __C1, class __C2>
|
||||
__bit_iterator<__C2, false>
|
||||
__swap_ranges_unaligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,
|
||||
__bit_iterator<__C2, false> __result)
|
||||
template <class _C1, class _C2>
|
||||
__bit_iterator<_C2, false>
|
||||
__swap_ranges_unaligned(__bit_iterator<_C1, false> __first, __bit_iterator<_C1, false> __last,
|
||||
__bit_iterator<_C2, false> __result)
|
||||
{
|
||||
typedef __bit_iterator<__C1, false> _I1;
|
||||
typedef __bit_iterator<_C1, false> _I1;
|
||||
typedef typename _I1::difference_type difference_type;
|
||||
typedef typename _I1::__storage_type __storage_type;
|
||||
static const unsigned __bits_per_word = _I1::__bits_per_word;
|
||||
@@ -842,11 +837,11 @@ __swap_ranges_unaligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1
|
||||
return __result;
|
||||
}
|
||||
|
||||
template <class __C1, class __C2>
|
||||
template <class _C1, class _C2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
__bit_iterator<__C2, false>
|
||||
swap_ranges(__bit_iterator<__C1, false> __first1, __bit_iterator<__C1, false> __last1,
|
||||
__bit_iterator<__C2, false> __first2)
|
||||
__bit_iterator<_C2, false>
|
||||
swap_ranges(__bit_iterator<_C1, false> __first1, __bit_iterator<_C1, false> __last1,
|
||||
__bit_iterator<_C2, false> __first2)
|
||||
{
|
||||
if (__first1.__ctz_ == __first2.__ctz_)
|
||||
return __swap_ranges_aligned(__first1, __last1, __first2);
|
||||
@@ -855,33 +850,34 @@ swap_ranges(__bit_iterator<__C1, false> __first1, __bit_iterator<__C1, false> __
|
||||
|
||||
// rotate
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
struct __bit_array
|
||||
{
|
||||
typedef typename _Cp::difference_type difference_type;
|
||||
typedef typename _Cp::__storage_type __storage_type;
|
||||
typedef typename _Cp::iterator iterator;
|
||||
static const unsigned __bits_per_word = _Cp::__bits_per_word;
|
||||
static const unsigned _Np = 4;
|
||||
typedef typename _C::difference_type difference_type;
|
||||
typedef typename _C::__storage_type __storage_type;
|
||||
typedef typename _C::iterator iterator;
|
||||
static const unsigned __bits_per_word = _C::__bits_per_word;
|
||||
static const unsigned _N = 4;
|
||||
|
||||
difference_type __size_;
|
||||
__storage_type __word_[_Np];
|
||||
__storage_type __word_[_N];
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY static difference_type capacity()
|
||||
{return static_cast<difference_type>(_Np * __bits_per_word);}
|
||||
{return static_cast<difference_type>(_N * __bits_per_word);}
|
||||
_LIBCPP_INLINE_VISIBILITY explicit __bit_array(difference_type __s) : __size_(__s) {}
|
||||
_LIBCPP_INLINE_VISIBILITY iterator begin() {return iterator(__word_, 0);}
|
||||
_LIBCPP_INLINE_VISIBILITY iterator end() {return iterator(__word_ + __size_ / __bits_per_word,
|
||||
static_cast<unsigned>(__size_ % __bits_per_word));}
|
||||
};
|
||||
|
||||
template <class _Cp>
|
||||
__bit_iterator<_Cp, false>
|
||||
rotate(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __middle, __bit_iterator<_Cp, false> __last)
|
||||
template <class _C>
|
||||
__bit_iterator<_C, false>
|
||||
rotate(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __middle, __bit_iterator<_C, false> __last)
|
||||
{
|
||||
typedef __bit_iterator<_Cp, false> _I1;
|
||||
typedef __bit_iterator<_C, false> _I1;
|
||||
typedef typename _I1::difference_type difference_type;
|
||||
typedef typename _I1::__storage_type __storage_type;
|
||||
static const unsigned __bits_per_word = _I1::__bits_per_word;
|
||||
difference_type __d1 = __middle - __first;
|
||||
difference_type __d2 = __last - __middle;
|
||||
_I1 __r = __first + __d2;
|
||||
@@ -889,16 +885,16 @@ rotate(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __middle,
|
||||
{
|
||||
if (__d1 <= __d2)
|
||||
{
|
||||
if (__d1 <= __bit_array<_Cp>::capacity())
|
||||
if (__d1 <= __bit_array<_C>::capacity())
|
||||
{
|
||||
__bit_array<_Cp> __b(__d1);
|
||||
__bit_array<_C> __b(__d1);
|
||||
_VSTD::copy(__first, __middle, __b.begin());
|
||||
_VSTD::copy(__b.begin(), __b.end(), _VSTD::copy(__middle, __last, __first));
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
__bit_iterator<_Cp, false> __mp = _VSTD::swap_ranges(__first, __middle, __middle);
|
||||
__bit_iterator<_C, false> __mp = _VSTD::swap_ranges(__first, __middle, __middle);
|
||||
__first = __middle;
|
||||
__middle = __mp;
|
||||
__d2 -= __d1;
|
||||
@@ -906,16 +902,16 @@ rotate(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __middle,
|
||||
}
|
||||
else
|
||||
{
|
||||
if (__d2 <= __bit_array<_Cp>::capacity())
|
||||
if (__d2 <= __bit_array<_C>::capacity())
|
||||
{
|
||||
__bit_array<_Cp> __b(__d2);
|
||||
__bit_array<_C> __b(__d2);
|
||||
_VSTD::copy(__middle, __last, __b.begin());
|
||||
_VSTD::copy_backward(__b.begin(), __b.end(), _VSTD::copy_backward(__first, __middle, __last));
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
__bit_iterator<_Cp, false> __mp = __first + __d2;
|
||||
__bit_iterator<_C, false> __mp = __first + __d2;
|
||||
_VSTD::swap_ranges(__first, __mp, __middle);
|
||||
__first = __mp;
|
||||
__d1 -= __d2;
|
||||
@@ -927,12 +923,12 @@ rotate(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __middle,
|
||||
|
||||
// equal
|
||||
|
||||
template <class _Cp, bool _IC1, bool _IC2>
|
||||
template <class _C>
|
||||
bool
|
||||
__equal_unaligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,
|
||||
__bit_iterator<_Cp, _IC2> __first2)
|
||||
__equal_unaligned(__bit_iterator<_C, true> __first1, __bit_iterator<_C, true> __last1,
|
||||
__bit_iterator<_C, true> __first2)
|
||||
{
|
||||
typedef __bit_iterator<_Cp, _IC1> _It;
|
||||
typedef __bit_iterator<_C, true> _It;
|
||||
typedef typename _It::difference_type difference_type;
|
||||
typedef typename _It::__storage_type __storage_type;
|
||||
static const unsigned __bits_per_word = _It::__bits_per_word;
|
||||
@@ -951,15 +947,11 @@ __equal_unaligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1>
|
||||
__storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r);
|
||||
__m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
|
||||
if (__first2.__ctz_ > __first1.__ctz_)
|
||||
{
|
||||
if ((*__first2.__seg_ & __m) != (__b << (__first2.__ctz_ - __first1.__ctz_)))
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ - __first2.__ctz_)))
|
||||
return false;
|
||||
}
|
||||
__first2.__seg_ += (__ddn + __first2.__ctz_) / __bits_per_word;
|
||||
__first2.__ctz_ = static_cast<unsigned>((__ddn + __first2.__ctz_) % __bits_per_word);
|
||||
__dn -= __ddn;
|
||||
@@ -1009,12 +1001,12 @@ __equal_unaligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1>
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class _Cp, bool _IC1, bool _IC2>
|
||||
template <class _C>
|
||||
bool
|
||||
__equal_aligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,
|
||||
__bit_iterator<_Cp, _IC2> __first2)
|
||||
__equal_aligned(__bit_iterator<_C, true> __first1, __bit_iterator<_C, true> __last1,
|
||||
__bit_iterator<_C, true> __first2)
|
||||
{
|
||||
typedef __bit_iterator<_Cp, _IC1> _It;
|
||||
typedef __bit_iterator<_C, true> _It;
|
||||
typedef typename _It::difference_type difference_type;
|
||||
typedef typename _It::__storage_type __storage_type;
|
||||
static const unsigned __bits_per_word = _It::__bits_per_word;
|
||||
@@ -1052,32 +1044,31 @@ __equal_aligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class _Cp, bool _IC1, bool _IC2>
|
||||
template <class _C, bool _IC1, bool _IC2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
equal(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __bit_iterator<_Cp, _IC2> __first2)
|
||||
equal(__bit_iterator<_C, _IC1> __first1, __bit_iterator<_C, _IC1> __last1, __bit_iterator<_C, _IC2> __first2)
|
||||
{
|
||||
if (__first1.__ctz_ == __first2.__ctz_)
|
||||
return __equal_aligned(__first1, __last1, __first2);
|
||||
return __equal_unaligned(__first1, __last1, __first2);
|
||||
}
|
||||
|
||||
template <class _Cp, bool _IsConst,
|
||||
typename _Cp::__storage_type>
|
||||
template <class _C, bool _IsConst>
|
||||
class __bit_iterator
|
||||
{
|
||||
public:
|
||||
typedef typename _Cp::difference_type difference_type;
|
||||
typedef typename _C::difference_type difference_type;
|
||||
typedef bool value_type;
|
||||
typedef __bit_iterator pointer;
|
||||
typedef typename conditional<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >::type reference;
|
||||
typedef typename conditional<_IsConst, __bit_const_reference<_C>, __bit_reference<_C> >::type reference;
|
||||
typedef random_access_iterator_tag iterator_category;
|
||||
|
||||
private:
|
||||
typedef typename _Cp::__storage_type __storage_type;
|
||||
typedef typename conditional<_IsConst, typename _Cp::__const_storage_pointer,
|
||||
typename _Cp::__storage_pointer>::type __storage_pointer;
|
||||
static const unsigned __bits_per_word = _Cp::__bits_per_word;
|
||||
typedef typename _C::__storage_type __storage_type;
|
||||
typedef typename conditional<_IsConst, typename _C::__const_storage_pointer,
|
||||
typename _C::__storage_pointer>::type __storage_pointer;
|
||||
static const unsigned __bits_per_word = _C::__bits_per_word;
|
||||
|
||||
__storage_pointer __seg_;
|
||||
unsigned __ctz_;
|
||||
@@ -1086,7 +1077,7 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY __bit_iterator() _NOEXCEPT {}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__bit_iterator(const __bit_iterator<_Cp, false>& __it) _NOEXCEPT
|
||||
__bit_iterator(const __bit_iterator<_C, false>& __it) _NOEXCEPT
|
||||
: __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT
|
||||
@@ -1194,63 +1185,59 @@ private:
|
||||
: __seg_(__s), __ctz_(__ctz) {}
|
||||
|
||||
#if defined(__clang__)
|
||||
friend typename _Cp::__self;
|
||||
friend typename _C::__self;
|
||||
#else
|
||||
friend class _Cp::__self;
|
||||
friend class _C::__self;
|
||||
#endif
|
||||
friend class __bit_reference<_Cp>;
|
||||
friend class __bit_const_reference<_Cp>;
|
||||
friend class __bit_iterator<_Cp, true>;
|
||||
template <class _Dp> friend struct __bit_array;
|
||||
template <class _Dp> friend void __fill_n_false(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
|
||||
template <class _Dp> friend void __fill_n_true(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
|
||||
template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_aligned(__bit_iterator<_Dp, _IC> __first,
|
||||
__bit_iterator<_Dp, _IC> __last,
|
||||
__bit_iterator<_Dp, false> __result);
|
||||
template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_unaligned(__bit_iterator<_Dp, _IC> __first,
|
||||
__bit_iterator<_Dp, _IC> __last,
|
||||
__bit_iterator<_Dp, false> __result);
|
||||
template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> copy(__bit_iterator<_Dp, _IC> __first,
|
||||
__bit_iterator<_Dp, _IC> __last,
|
||||
__bit_iterator<_Dp, false> __result);
|
||||
template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_backward_aligned(__bit_iterator<_Dp, _IC> __first,
|
||||
__bit_iterator<_Dp, _IC> __last,
|
||||
__bit_iterator<_Dp, false> __result);
|
||||
template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_backward_unaligned(__bit_iterator<_Dp, _IC> __first,
|
||||
__bit_iterator<_Dp, _IC> __last,
|
||||
__bit_iterator<_Dp, false> __result);
|
||||
template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> copy_backward(__bit_iterator<_Dp, _IC> __first,
|
||||
__bit_iterator<_Dp, _IC> __last,
|
||||
__bit_iterator<_Dp, false> __result);
|
||||
template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_aligned(__bit_iterator<__C1, false>,
|
||||
__bit_iterator<__C1, false>,
|
||||
__bit_iterator<__C2, false>);
|
||||
template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_unaligned(__bit_iterator<__C1, false>,
|
||||
__bit_iterator<__C1, false>,
|
||||
__bit_iterator<__C2, false>);
|
||||
template <class __C1, class __C2>friend __bit_iterator<__C2, false> swap_ranges(__bit_iterator<__C1, false>,
|
||||
__bit_iterator<__C1, false>,
|
||||
__bit_iterator<__C2, false>);
|
||||
template <class _Dp> friend __bit_iterator<_Dp, false> rotate(__bit_iterator<_Dp, false>,
|
||||
__bit_iterator<_Dp, false>,
|
||||
__bit_iterator<_Dp, false>);
|
||||
template <class _Dp, bool _IC1, bool _IC2> friend bool __equal_aligned(__bit_iterator<_Dp, _IC1>,
|
||||
__bit_iterator<_Dp, _IC1>,
|
||||
__bit_iterator<_Dp, _IC2>);
|
||||
template <class _Dp, bool _IC1, bool _IC2> friend bool __equal_unaligned(__bit_iterator<_Dp, _IC1>,
|
||||
__bit_iterator<_Dp, _IC1>,
|
||||
__bit_iterator<_Dp, _IC2>);
|
||||
template <class _Dp, bool _IC1, bool _IC2> friend bool equal(__bit_iterator<_Dp, _IC1>,
|
||||
__bit_iterator<_Dp, _IC1>,
|
||||
__bit_iterator<_Dp, _IC2>);
|
||||
template <class _Dp, bool _IC> friend __bit_iterator<_Dp, _IC> __find_bool_true(__bit_iterator<_Dp, _IC>,
|
||||
typename _Dp::size_type);
|
||||
template <class _Dp, bool _IC> friend __bit_iterator<_Dp, _IC> __find_bool_false(__bit_iterator<_Dp, _IC>,
|
||||
typename _Dp::size_type);
|
||||
template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type
|
||||
__count_bool_true(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
|
||||
template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type
|
||||
__count_bool_false(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
|
||||
friend class __bit_reference<_C>;
|
||||
friend class __bit_const_reference<_C>;
|
||||
friend class __bit_iterator<_C, true>;
|
||||
template <class _D> friend struct __bit_array;
|
||||
template <class _D> friend void __fill_n_false(__bit_iterator<_D, false> __first, typename _D::size_type __n);
|
||||
template <class _D> friend void __fill_n_true(__bit_iterator<_D, false> __first, typename _D::size_type __n);
|
||||
template <class _D, bool _IC> friend __bit_iterator<_D, false> __copy_aligned(__bit_iterator<_D, _IC> __first,
|
||||
__bit_iterator<_D, _IC> __last,
|
||||
__bit_iterator<_D, false> __result);
|
||||
template <class _D, bool _IC> friend __bit_iterator<_D, false> __copy_unaligned(__bit_iterator<_D, _IC> __first,
|
||||
__bit_iterator<_D, _IC> __last,
|
||||
__bit_iterator<_D, false> __result);
|
||||
template <class _D, bool _IC> friend __bit_iterator<_D, false> copy(__bit_iterator<_D, _IC> __first,
|
||||
__bit_iterator<_D, _IC> __last,
|
||||
__bit_iterator<_D, false> __result);
|
||||
template <class _D, bool _IC> friend __bit_iterator<_D, false> __copy_backward_aligned(__bit_iterator<_D, _IC> __first,
|
||||
__bit_iterator<_D, _IC> __last,
|
||||
__bit_iterator<_D, false> __result);
|
||||
template <class _D, bool _IC> friend __bit_iterator<_D, false> __copy_backward_unaligned(__bit_iterator<_D, _IC> __first,
|
||||
__bit_iterator<_D, _IC> __last,
|
||||
__bit_iterator<_D, false> __result);
|
||||
template <class _D, bool _IC> friend __bit_iterator<_D, false> copy_backward(__bit_iterator<_D, _IC> __first,
|
||||
__bit_iterator<_D, _IC> __last,
|
||||
__bit_iterator<_D, false> __result);
|
||||
template <class _C1, class _C2>friend __bit_iterator<_C2, false> __swap_ranges_aligned(__bit_iterator<_C1, false>,
|
||||
__bit_iterator<_C1, false>,
|
||||
__bit_iterator<_C2, false>);
|
||||
template <class _C1, class _C2>friend __bit_iterator<_C2, false> __swap_ranges_unaligned(__bit_iterator<_C1, false>,
|
||||
__bit_iterator<_C1, false>,
|
||||
__bit_iterator<_C2, false>);
|
||||
template <class _C1, class _C2>friend __bit_iterator<_C2, false> swap_ranges(__bit_iterator<_C1, false>,
|
||||
__bit_iterator<_C1, false>,
|
||||
__bit_iterator<_C2, false>);
|
||||
template <class _D> friend __bit_iterator<_D, false> rotate(__bit_iterator<_D, false>,
|
||||
__bit_iterator<_D, false>,
|
||||
__bit_iterator<_D, false>);
|
||||
template <class _D> friend bool __equal_aligned(__bit_iterator<_D, true>,
|
||||
__bit_iterator<_D, true>,
|
||||
__bit_iterator<_D, true>);
|
||||
template <class _D> friend bool __equal_unaligned(__bit_iterator<_D, true>,
|
||||
__bit_iterator<_D, true>,
|
||||
__bit_iterator<_D, true>);
|
||||
template <class _D, bool _IC1, bool _IC2> friend bool equal(__bit_iterator<_D, _IC1>,
|
||||
__bit_iterator<_D, _IC1>,
|
||||
__bit_iterator<_D, _IC2>);
|
||||
template <class _D> friend __bit_iterator<_D, false> __find_bool_true(__bit_iterator<_D, false>,
|
||||
typename _D::size_type);
|
||||
template <class _D> friend __bit_iterator<_D, false> __find_bool_false(__bit_iterator<_D, false>,
|
||||
typename _D::size_type);
|
||||
};
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
241
include/__config
241
include/__config
@@ -11,15 +11,9 @@
|
||||
#ifndef _LIBCPP_CONFIG
|
||||
#define _LIBCPP_CONFIG
|
||||
|
||||
#if !_MSC_VER // explicit macro necessary because it is only defined below in this file
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#ifdef __GNUC__
|
||||
#define _GNUC_VER (__GNUC__ * 100 + __GNUC_MINOR__)
|
||||
#endif
|
||||
|
||||
#define _LIBCPP_VERSION 1101
|
||||
#define _LIBCPP_VERSION 1000
|
||||
|
||||
#define _LIBCPP_ABI_VERSION 1
|
||||
|
||||
@@ -56,24 +50,8 @@
|
||||
#ifdef _WIN32
|
||||
# define _LIBCPP_LITTLE_ENDIAN 1
|
||||
# define _LIBCPP_BIG_ENDIAN 0
|
||||
// Compiler intrinsics (GCC or MSVC)
|
||||
# if (defined(_MSC_VER) && _MSC_VER >= 1400) \
|
||||
|| (defined(__GNUC__) && _GNUC_VER > 403)
|
||||
# define _LIBCP_HAS_IS_BASE_OF
|
||||
# endif
|
||||
#endif // _WIN32
|
||||
|
||||
#ifdef __sun__
|
||||
# include <sys/isa_defs.h>
|
||||
# ifdef _LITTLE_ENDIAN
|
||||
# define _LIBCPP_LITTLE_ENDIAN 1
|
||||
# define _LIBCPP_BIG_ENDIAN 0
|
||||
# else
|
||||
# define _LIBCPP_LITTLE_ENDIAN 0
|
||||
# define _LIBCPP_BIG_ENDIAN 1
|
||||
# endif
|
||||
#endif // __sun__
|
||||
|
||||
#if !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
|
||||
# include <endian.h>
|
||||
# if __BYTE_ORDER == __LITTLE_ENDIAN
|
||||
@@ -87,49 +65,17 @@
|
||||
# endif
|
||||
#endif // !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
|
||||
|
||||
#if _WIN32
|
||||
|
||||
// only really useful for a DLL
|
||||
#ifdef _LIBCPP_DLL // this should be a compiler builtin define ideally...
|
||||
# ifdef cxx_EXPORTS
|
||||
# define _LIBCPP_HIDDEN
|
||||
# define _LIBCPP_VISIBLE __declspec(dllexport)
|
||||
# else
|
||||
# define _LIBCPP_HIDDEN
|
||||
# define _LIBCPP_VISIBLE __declspec(dllimport)
|
||||
# endif
|
||||
#else
|
||||
# define _LIBCPP_HIDDEN
|
||||
# define _LIBCPP_VISIBLE
|
||||
#ifndef _LIBCPP_VISIBILITY_TAG
|
||||
#define _LIBCPP_VISIBILITY_TAG 1
|
||||
#endif
|
||||
|
||||
#ifndef _LIBCPP_INLINE_VISIBILITY
|
||||
# if _MSC_VER
|
||||
# define _LIBCPP_INLINE_VISIBILITY __forceinline
|
||||
# else // MinGW GCC and Clang
|
||||
# define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__always_inline__))
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef _LIBCPP_EXCEPTION_ABI
|
||||
#define _LIBCPP_EXCEPTION_ABI _LIBCPP_VISIBLE
|
||||
#endif
|
||||
|
||||
#ifndef _LIBCPP_ALWAYS_INLINE
|
||||
# if _MSC_VER
|
||||
# define _LIBCPP_ALWAYS_INLINE __forceinline
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#endif // _WIN32
|
||||
|
||||
#ifndef _LIBCPP_HIDDEN
|
||||
#if _LIBCPP_VISIBILITY_TAG
|
||||
#define _LIBCPP_HIDDEN __attribute__ ((__visibility__("hidden")))
|
||||
#endif
|
||||
|
||||
#ifndef _LIBCPP_VISIBLE
|
||||
#define _LIBCPP_VISIBLE __attribute__ ((__visibility__("default")))
|
||||
#endif
|
||||
#else // _LIBCPP_VISIBILITY_TAG
|
||||
#define _LIBCPP_HIDDEN
|
||||
#define _LIBCPP_VISIBLE
|
||||
#endif // _LIBCPP_VISIBILITY_TAG
|
||||
|
||||
#ifndef _LIBCPP_INLINE_VISIBILITY
|
||||
#define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__visibility__("hidden"), __always_inline__))
|
||||
@@ -139,24 +85,12 @@
|
||||
#define _LIBCPP_EXCEPTION_ABI __attribute__ ((__visibility__("default")))
|
||||
#endif
|
||||
|
||||
#ifndef _LIBCPP_CANTTHROW
|
||||
#define _LIBCPP_CANTTHROW __attribute__ ((__nothrow__))
|
||||
#endif
|
||||
|
||||
#ifndef _LIBCPP_ALWAYS_INLINE
|
||||
#define _LIBCPP_ALWAYS_INLINE __attribute__ ((__visibility__("hidden"), __always_inline__))
|
||||
#endif
|
||||
|
||||
#if defined(__clang__)
|
||||
|
||||
#if __has_feature(cxx_alignas)
|
||||
# define _ALIGNAS_TYPE(x) alignas(x)
|
||||
# define _ALIGNAS(x) alignas(x)
|
||||
#else
|
||||
# define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
|
||||
# define _ALIGNAS(x) __attribute__((__aligned__(x)))
|
||||
#endif
|
||||
|
||||
#if !__has_feature(cxx_alias_templates)
|
||||
#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
|
||||
#endif
|
||||
@@ -178,18 +112,14 @@ typedef __char32_t char32_t;
|
||||
#define _LIBCPP_NO_RTTI
|
||||
#endif
|
||||
|
||||
#if !(__has_feature(cxx_strong_enums))
|
||||
#define _LIBCPP_HAS_NO_STRONG_ENUMS
|
||||
#endif
|
||||
|
||||
#if !(__has_feature(cxx_decltype))
|
||||
#define _LIBCPP_HAS_NO_DECLTYPE
|
||||
#endif
|
||||
|
||||
#if __has_feature(cxx_attributes)
|
||||
# define _LIBCPP_NORETURN [[noreturn]]
|
||||
# define _ATTRIBUTE(x) [[x]]
|
||||
#else
|
||||
# define _LIBCPP_NORETURN __attribute__ ((noreturn))
|
||||
# define _ATTRIBUTE(x) __attribute__ ((x))
|
||||
#endif
|
||||
|
||||
#define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
|
||||
@@ -216,9 +146,6 @@ typedef __char32_t char32_t;
|
||||
|
||||
#if !(__has_feature(cxx_auto_type))
|
||||
#define _LIBCPP_HAS_NO_AUTO_TYPE
|
||||
#endif
|
||||
|
||||
#if !(__has_feature(cxx_access_control_sfinae)) || !__has_feature(cxx_trailing_return)
|
||||
#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
|
||||
#endif
|
||||
|
||||
@@ -230,14 +157,6 @@ typedef __char32_t char32_t;
|
||||
#define _LIBCPP_HAS_NO_TRAILING_RETURN
|
||||
#endif
|
||||
|
||||
#if !(__has_feature(cxx_generalized_initializers))
|
||||
#define _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
#endif
|
||||
|
||||
#if __has_feature(is_base_of)
|
||||
# define _LIBCP_HAS_IS_BASE_OF
|
||||
#endif
|
||||
|
||||
// Objective-C++ features (opt-in)
|
||||
#if __has_feature(objc_arc)
|
||||
#define _LIBCPP_HAS_OBJC_ARC
|
||||
@@ -245,28 +164,6 @@ typedef __char32_t char32_t;
|
||||
|
||||
#if __has_feature(objc_arc_weak)
|
||||
#define _LIBCPP_HAS_OBJC_ARC_WEAK
|
||||
#define _LIBCPP_HAS_NO_STRONG_ENUMS
|
||||
#endif
|
||||
|
||||
#if !(__has_feature(cxx_constexpr))
|
||||
#define _LIBCPP_HAS_NO_CONSTEXPR
|
||||
#endif
|
||||
|
||||
#if __FreeBSD__ && (__ISO_C_VISIBLE >= 2011 || __cplusplus >= 201103L)
|
||||
#define _LIBCPP_HAS_QUICK_EXIT
|
||||
#define _LIBCPP_HAS_C11_FEATURES
|
||||
#endif
|
||||
|
||||
#if (__has_feature(cxx_noexcept))
|
||||
# define _NOEXCEPT noexcept
|
||||
# define _NOEXCEPT_(x) noexcept(x)
|
||||
#else
|
||||
# define _NOEXCEPT throw()
|
||||
# define _NOEXCEPT_(x)
|
||||
#endif
|
||||
|
||||
#if __has_feature(underlying_type)
|
||||
# define _LIBCXX_UNDERLYING_TYPE(T) __underlying_type(T)
|
||||
#endif
|
||||
|
||||
// Inline namespaces are available in Clang regardless of C++ dialect.
|
||||
@@ -279,12 +176,23 @@ namespace std {
|
||||
}
|
||||
}
|
||||
|
||||
#if !(__has_feature(cxx_constexpr))
|
||||
#define _LIBCPP_HAS_NO_CONSTEXPR
|
||||
#endif
|
||||
|
||||
#if (__has_feature(cxx_noexcept))
|
||||
# define _NOEXCEPT noexcept
|
||||
# define _NOEXCEPT_(x) noexcept(x)
|
||||
#else
|
||||
# define _NOEXCEPT throw()
|
||||
# define _NOEXCEPT_(x)
|
||||
#endif
|
||||
|
||||
// end defined(__clang__)
|
||||
|
||||
#elif defined(__GNUC__)
|
||||
|
||||
#define _ALIGNAS(x) __attribute__((__aligned__(x)))
|
||||
#define _ALIGNAS_TYPE(x) __attribute__((__aligned__(__alignof(x))))
|
||||
|
||||
#define _LIBCPP_NORETURN __attribute__((noreturn))
|
||||
#define _ATTRIBUTE(x) __attribute__((x))
|
||||
|
||||
#if !__EXCEPTIONS
|
||||
#define _LIBCPP_NO_EXCEPTIONS
|
||||
@@ -314,25 +222,24 @@ namespace std {
|
||||
#define _LIBCPP_HAS_NO_TRAILING_RETURN
|
||||
#define _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
|
||||
|
||||
#if _GNUC_VER < 403
|
||||
#if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 3)
|
||||
#define _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#endif
|
||||
|
||||
#if _GNUC_VER < 403
|
||||
#if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 3)
|
||||
#define _LIBCPP_HAS_NO_STATIC_ASSERT
|
||||
#endif
|
||||
|
||||
#if _GNUC_VER < 404
|
||||
#if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 4)
|
||||
#define _LIBCPP_HAS_NO_ADVANCED_SFINAE
|
||||
#define _LIBCPP_HAS_NO_DECLTYPE
|
||||
#define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
|
||||
#define _LIBCPP_HAS_NO_DELETED_FUNCTIONS
|
||||
#define _LIBCPP_HAS_NO_UNICODE_CHARS
|
||||
#define _LIBCPP_HAS_NO_VARIADICS
|
||||
#define _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
#endif // _GNUC_VER < 404
|
||||
#endif // !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 4)
|
||||
|
||||
#if _GNUC_VER < 406
|
||||
#if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 6)
|
||||
#define _LIBCPP_HAS_NO_NULLPTR
|
||||
#endif
|
||||
|
||||
@@ -348,29 +255,7 @@ namespace _LIBCPP_NAMESPACE {
|
||||
using namespace _LIBCPP_NAMESPACE __attribute__((__strong__));
|
||||
}
|
||||
|
||||
#elif defined(_MSC_VER)
|
||||
|
||||
#define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
|
||||
#define _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
|
||||
#define _LIBCPP_HAS_NO_CONSTEXPR
|
||||
#define _LIBCPP_HAS_NO_UNICODE_CHARS
|
||||
#define _LIBCPP_HAS_NO_DELETED_FUNCTIONS
|
||||
#define __alignof__ __alignof
|
||||
#define _LIBCPP_NORETURN __declspec(noreturn)
|
||||
#define _ALIGNAS(x) __declspec(align(x))
|
||||
#define _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
#define _NOEXCEPT throw()
|
||||
#define _NOEXCEPT_(x)
|
||||
|
||||
#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {
|
||||
#define _LIBCPP_END_NAMESPACE_STD }
|
||||
#define _VSTD std
|
||||
|
||||
namespace std {
|
||||
}
|
||||
|
||||
#endif // __clang__ || __GNUC___ || _MSC_VER
|
||||
#endif // defined(__GNUC__)
|
||||
|
||||
#ifdef _LIBCPP_HAS_NO_UNICODE_CHARS
|
||||
typedef unsigned short char16_t;
|
||||
@@ -393,73 +278,11 @@ template <unsigned> struct __static_assert_check {};
|
||||
#endif
|
||||
|
||||
#ifdef _LIBCPP_HAS_NO_CONSTEXPR
|
||||
#define _LIBCPP_CONSTEXPR
|
||||
#else
|
||||
#define _LIBCPP_CONSTEXPR constexpr
|
||||
#endif
|
||||
|
||||
#ifdef __GNUC__
|
||||
#define _NOALIAS __attribute__((malloc))
|
||||
#else
|
||||
#define _NOALIAS
|
||||
#define constexpr const
|
||||
#endif
|
||||
|
||||
#ifndef __has_feature
|
||||
#define __has_feature(__x) 0
|
||||
#endif
|
||||
|
||||
#if __has_feature(cxx_explicit_conversions)
|
||||
# define _LIBCPP_EXPLICIT explicit
|
||||
#else
|
||||
# define _LIBCPP_EXPLICIT
|
||||
#endif
|
||||
|
||||
#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
|
||||
#define _LIBCPP_DECLARE_STRONG_ENUM(x) struct _LIBCPP_VISIBLE x { enum __lx
|
||||
#define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x) \
|
||||
__lx __v_; \
|
||||
_LIBCPP_ALWAYS_INLINE x(__lx __v) : __v_(__v) {} \
|
||||
_LIBCPP_ALWAYS_INLINE explicit x(int __v) : __v_(static_cast<__lx>(__v)) {} \
|
||||
_LIBCPP_ALWAYS_INLINE operator int() const {return __v_;} \
|
||||
};
|
||||
#else // _LIBCPP_HAS_NO_STRONG_ENUMS
|
||||
#define _LIBCPP_DECLARE_STRONG_ENUM(x) enum class _LIBCPP_VISIBLE x
|
||||
#define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x)
|
||||
#endif // _LIBCPP_HAS_NO_STRONG_ENUMS
|
||||
|
||||
#ifndef _LIBCPP_EXTERN_TEMPLATE
|
||||
#define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
|
||||
#endif
|
||||
|
||||
#if __APPLE__ || __FreeBSD__ || _WIN32 || __sun__
|
||||
#define _LIBCPP_LOCALE__L_EXTENSIONS 1
|
||||
#endif
|
||||
#if __FreeBSD__
|
||||
#define _DECLARE_C99_LDBL_MATH 1
|
||||
#endif
|
||||
|
||||
#if __APPLE__ || __FreeBSD__
|
||||
#define _LIBCPP_HAS_DEFAULTRUNELOCALE
|
||||
#endif
|
||||
|
||||
#if __APPLE__ || __FreeBSD__ || __sun__
|
||||
#define _LIBCPP_WCTYPE_IS_MASK
|
||||
#endif
|
||||
|
||||
#ifdef _LIBCPP_DEBUG2
|
||||
# if _LIBCPP_DEBUG2 == 0
|
||||
# define _LIBCPP_DEBUG_LEVEL 1
|
||||
# elif _LIBCPP_DEBUG2 == 1
|
||||
# define _LIBCPP_DEBUG_LEVEL 2
|
||||
# else
|
||||
# error Supported values for _LIBCPP_DEBUG2 are 0 and 1
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef _LIBCPP_DEBUG2
|
||||
# include <__debug>
|
||||
#else
|
||||
# define _LIBCPP_ASSERT(x, m) ((void)0)
|
||||
#endif
|
||||
|
||||
#endif // _LIBCPP_CONFIG
|
||||
|
||||
191
include/__debug
191
include/__debug
@@ -1,191 +0,0 @@
|
||||
// -*- C++ -*-
|
||||
//===--------------------------- __debug ----------------------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is dual licensed under the MIT and the University of Illinois Open
|
||||
// Source Licenses. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP_DEBUG_H
|
||||
#define _LIBCPP_DEBUG_H
|
||||
|
||||
#if _LIBCPP_DEBUG_LEVEL >= 1
|
||||
|
||||
# include <cstdlib>
|
||||
# include <cstdio>
|
||||
# include <cstddef>
|
||||
# define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (_VSTD::printf("%s\n", m), _VSTD::abort()))
|
||||
|
||||
#endif
|
||||
|
||||
#if _LIBCPP_DEBUG_LEVEL >= 2
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
struct _LIBCPP_VISIBLE __c_node;
|
||||
|
||||
struct _LIBCPP_VISIBLE __i_node
|
||||
{
|
||||
void* __i_;
|
||||
__i_node* __next_;
|
||||
__c_node* __c_;
|
||||
|
||||
__i_node(const __i_node&) = delete;
|
||||
__i_node& operator=(const __i_node&) = delete;
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__i_node(void* __i, __i_node* __next, __c_node* __c)
|
||||
: __i_(__i), __next_(__next), __c_(__c) {}
|
||||
~__i_node();
|
||||
};
|
||||
|
||||
struct _LIBCPP_VISIBLE __c_node
|
||||
{
|
||||
void* __c_;
|
||||
__c_node* __next_;
|
||||
__i_node** beg_;
|
||||
__i_node** end_;
|
||||
__i_node** cap_;
|
||||
|
||||
__c_node(const __c_node&) = delete;
|
||||
__c_node& operator=(const __c_node&) = delete;
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__c_node(void* __c, __c_node* __next)
|
||||
: __c_(__c), __next_(__next), beg_(nullptr), end_(nullptr), cap_(nullptr) {}
|
||||
virtual ~__c_node();
|
||||
|
||||
virtual bool __dereferenceable(const void*) const = 0;
|
||||
virtual bool __decrementable(const void*) const = 0;
|
||||
virtual bool __addable(const void*, ptrdiff_t) const = 0;
|
||||
virtual bool __subscriptable(const void*, ptrdiff_t) const = 0;
|
||||
|
||||
void __add(__i_node* __i);
|
||||
_LIBCPP_HIDDEN void __remove(__i_node* __i);
|
||||
};
|
||||
|
||||
template <class _Cont>
|
||||
struct _C_node
|
||||
: public __c_node
|
||||
{
|
||||
_C_node(void* __c, __c_node* __n)
|
||||
: __c_node(__c, __n) {}
|
||||
|
||||
virtual bool __dereferenceable(const void*) const;
|
||||
virtual bool __decrementable(const void*) const;
|
||||
virtual bool __addable(const void*, ptrdiff_t) const;
|
||||
virtual bool __subscriptable(const void*, ptrdiff_t) const;
|
||||
};
|
||||
|
||||
template <class _Cont>
|
||||
bool
|
||||
_C_node<_Cont>::__dereferenceable(const void* __i) const
|
||||
{
|
||||
typedef typename _Cont::const_iterator iterator;
|
||||
const iterator* __j = static_cast<const iterator*>(__i);
|
||||
_Cont* _Cp = static_cast<_Cont*>(__c_);
|
||||
return _Cp->__dereferenceable(__j);
|
||||
}
|
||||
|
||||
template <class _Cont>
|
||||
bool
|
||||
_C_node<_Cont>::__decrementable(const void* __i) const
|
||||
{
|
||||
typedef typename _Cont::const_iterator iterator;
|
||||
const iterator* __j = static_cast<const iterator*>(__i);
|
||||
_Cont* _Cp = static_cast<_Cont*>(__c_);
|
||||
return _Cp->__decrementable(__j);
|
||||
}
|
||||
|
||||
template <class _Cont>
|
||||
bool
|
||||
_C_node<_Cont>::__addable(const void* __i, ptrdiff_t __n) const
|
||||
{
|
||||
typedef typename _Cont::const_iterator iterator;
|
||||
const iterator* __j = static_cast<const iterator*>(__i);
|
||||
_Cont* _Cp = static_cast<_Cont*>(__c_);
|
||||
return _Cp->__addable(__j, __n);
|
||||
}
|
||||
|
||||
template <class _Cont>
|
||||
bool
|
||||
_C_node<_Cont>::__subscriptable(const void* __i, ptrdiff_t __n) const
|
||||
{
|
||||
typedef typename _Cont::const_iterator iterator;
|
||||
const iterator* __j = static_cast<const iterator*>(__i);
|
||||
_Cont* _Cp = static_cast<_Cont*>(__c_);
|
||||
return _Cp->__subscriptable(__j, __n);
|
||||
}
|
||||
|
||||
class _LIBCPP_VISIBLE __libcpp_db
|
||||
{
|
||||
__c_node** __cbeg_;
|
||||
__c_node** __cend_;
|
||||
size_t __csz_;
|
||||
__i_node** __ibeg_;
|
||||
__i_node** __iend_;
|
||||
size_t __isz_;
|
||||
|
||||
__libcpp_db();
|
||||
public:
|
||||
__libcpp_db(const __libcpp_db&) = delete;
|
||||
__libcpp_db& operator=(const __libcpp_db&) = delete;
|
||||
~__libcpp_db();
|
||||
|
||||
class __db_c_iterator;
|
||||
class __db_c_const_iterator;
|
||||
class __db_i_iterator;
|
||||
class __db_i_const_iterator;
|
||||
|
||||
__db_c_const_iterator __c_end() const;
|
||||
__db_i_const_iterator __i_end() const;
|
||||
|
||||
template <class _Cont>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __insert_c(_Cont* __c)
|
||||
{
|
||||
__c_node* __n = __insert_c(static_cast<void*>(__c));
|
||||
::new(__n) _C_node<_Cont>(__n->__c_, __n->__next_);
|
||||
}
|
||||
|
||||
void __insert_i(void* __i);
|
||||
__c_node* __insert_c(void* __c);
|
||||
void __erase_c(void* __c);
|
||||
|
||||
void __insert_ic(void* __i, const void* __c);
|
||||
void __iterator_copy(void* __i, const void* __i0);
|
||||
void __erase_i(void* __i);
|
||||
|
||||
void* __find_c_from_i(void* __i) const;
|
||||
void __invalidate_all(void* __c);
|
||||
__c_node* __find_c_and_lock(void* __c) const;
|
||||
__c_node* __find_c(void* __c) const;
|
||||
void unlock() const;
|
||||
|
||||
void swap(void* __c1, void* __c2);
|
||||
|
||||
|
||||
bool __dereferenceable(const void* __i) const;
|
||||
bool __decrementable(const void* __i) const;
|
||||
bool __addable(const void* __i, ptrdiff_t __n) const;
|
||||
bool __subscriptable(const void* __i, ptrdiff_t __n) const;
|
||||
bool __comparable(const void* __i, const void* __j) const;
|
||||
private:
|
||||
_LIBCPP_HIDDEN
|
||||
__i_node* __insert_iterator(void* __i);
|
||||
_LIBCPP_HIDDEN
|
||||
__i_node* __find_iterator(const void* __i) const;
|
||||
|
||||
friend _LIBCPP_VISIBLE __libcpp_db* __get_db();
|
||||
};
|
||||
|
||||
_LIBCPP_VISIBLE __libcpp_db* __get_db();
|
||||
_LIBCPP_VISIBLE const __libcpp_db* __get_const_db();
|
||||
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
#endif
|
||||
|
||||
#endif // _LIBCPP_DEBUG_H
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -16,9 +16,7 @@
|
||||
#include <typeinfo>
|
||||
#include <exception>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -43,20 +41,13 @@ template <class _Tp>
|
||||
struct __has_result_type
|
||||
{
|
||||
private:
|
||||
struct __two {char __lx; char __lxx;};
|
||||
struct __two {char _; char __;};
|
||||
template <class _Up> static __two __test(...);
|
||||
template <class _Up> static char __test(typename _Up::result_type* = 0);
|
||||
public:
|
||||
static const bool value = sizeof(__test<_Tp>(0)) == 1;
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
struct _LIBCPP_VISIBLE less : binary_function<_Tp, _Tp, bool>
|
||||
{
|
||||
_LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
|
||||
{return __x < __y;}
|
||||
};
|
||||
|
||||
#ifdef _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
#include <__functional_base_03>
|
||||
@@ -69,11 +60,11 @@ template <class _Tp>
|
||||
struct __derives_from_unary_function
|
||||
{
|
||||
private:
|
||||
struct __two {char __lx; char __lxx;};
|
||||
struct __two {char _; char __;};
|
||||
static __two __test(...);
|
||||
template <class _Ap, class _Rp>
|
||||
static unary_function<_Ap, _Rp>
|
||||
__test(const volatile unary_function<_Ap, _Rp>*);
|
||||
template <class _A, class _R>
|
||||
static unary_function<_A, _R>
|
||||
__test(const volatile unary_function<_A, _R>*);
|
||||
public:
|
||||
static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
|
||||
typedef decltype(__test((_Tp*)0)) type;
|
||||
@@ -83,11 +74,11 @@ template <class _Tp>
|
||||
struct __derives_from_binary_function
|
||||
{
|
||||
private:
|
||||
struct __two {char __lx; char __lxx;};
|
||||
struct __two {char _; char __;};
|
||||
static __two __test(...);
|
||||
template <class _A1, class _A2, class _Rp>
|
||||
static binary_function<_A1, _A2, _Rp>
|
||||
__test(const volatile binary_function<_A1, _A2, _Rp>*);
|
||||
template <class _A1, class _A2, class _R>
|
||||
static binary_function<_A1, _A2, _R>
|
||||
__test(const volatile binary_function<_A1, _A2, _R>*);
|
||||
public:
|
||||
static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
|
||||
typedef decltype(__test((_Tp*)0)) type;
|
||||
@@ -138,173 +129,173 @@ struct __weak_result_type
|
||||
|
||||
// 0 argument case
|
||||
|
||||
template <class _Rp>
|
||||
struct __weak_result_type<_Rp ()>
|
||||
template <class _R>
|
||||
struct __weak_result_type<_R ()>
|
||||
{
|
||||
typedef _Rp result_type;
|
||||
typedef _R result_type;
|
||||
};
|
||||
|
||||
template <class _Rp>
|
||||
struct __weak_result_type<_Rp (&)()>
|
||||
template <class _R>
|
||||
struct __weak_result_type<_R (&)()>
|
||||
{
|
||||
typedef _Rp result_type;
|
||||
typedef _R result_type;
|
||||
};
|
||||
|
||||
template <class _Rp>
|
||||
struct __weak_result_type<_Rp (*)()>
|
||||
template <class _R>
|
||||
struct __weak_result_type<_R (*)()>
|
||||
{
|
||||
typedef _Rp result_type;
|
||||
typedef _R result_type;
|
||||
};
|
||||
|
||||
// 1 argument case
|
||||
|
||||
template <class _Rp, class _A1>
|
||||
struct __weak_result_type<_Rp (_A1)>
|
||||
: public unary_function<_A1, _Rp>
|
||||
template <class _R, class _A1>
|
||||
struct __weak_result_type<_R (_A1)>
|
||||
: public unary_function<_A1, _R>
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Rp, class _A1>
|
||||
struct __weak_result_type<_Rp (&)(_A1)>
|
||||
: public unary_function<_A1, _Rp>
|
||||
template <class _R, class _A1>
|
||||
struct __weak_result_type<_R (&)(_A1)>
|
||||
: public unary_function<_A1, _R>
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Rp, class _A1>
|
||||
struct __weak_result_type<_Rp (*)(_A1)>
|
||||
: public unary_function<_A1, _Rp>
|
||||
template <class _R, class _A1>
|
||||
struct __weak_result_type<_R (*)(_A1)>
|
||||
: public unary_function<_A1, _R>
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Rp, class _Cp>
|
||||
struct __weak_result_type<_Rp (_Cp::*)()>
|
||||
: public unary_function<_Cp*, _Rp>
|
||||
template <class _R, class _C>
|
||||
struct __weak_result_type<_R (_C::*)()>
|
||||
: public unary_function<_C*, _R>
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Rp, class _Cp>
|
||||
struct __weak_result_type<_Rp (_Cp::*)() const>
|
||||
: public unary_function<const _Cp*, _Rp>
|
||||
template <class _R, class _C>
|
||||
struct __weak_result_type<_R (_C::*)() const>
|
||||
: public unary_function<const _C*, _R>
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Rp, class _Cp>
|
||||
struct __weak_result_type<_Rp (_Cp::*)() volatile>
|
||||
: public unary_function<volatile _Cp*, _Rp>
|
||||
template <class _R, class _C>
|
||||
struct __weak_result_type<_R (_C::*)() volatile>
|
||||
: public unary_function<volatile _C*, _R>
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Rp, class _Cp>
|
||||
struct __weak_result_type<_Rp (_Cp::*)() const volatile>
|
||||
: public unary_function<const volatile _Cp*, _Rp>
|
||||
template <class _R, class _C>
|
||||
struct __weak_result_type<_R (_C::*)() const volatile>
|
||||
: public unary_function<const volatile _C*, _R>
|
||||
{
|
||||
};
|
||||
|
||||
// 2 argument case
|
||||
|
||||
template <class _Rp, class _A1, class _A2>
|
||||
struct __weak_result_type<_Rp (_A1, _A2)>
|
||||
: public binary_function<_A1, _A2, _Rp>
|
||||
template <class _R, class _A1, class _A2>
|
||||
struct __weak_result_type<_R (_A1, _A2)>
|
||||
: public binary_function<_A1, _A2, _R>
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Rp, class _A1, class _A2>
|
||||
struct __weak_result_type<_Rp (*)(_A1, _A2)>
|
||||
: public binary_function<_A1, _A2, _Rp>
|
||||
template <class _R, class _A1, class _A2>
|
||||
struct __weak_result_type<_R (*)(_A1, _A2)>
|
||||
: public binary_function<_A1, _A2, _R>
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Rp, class _A1, class _A2>
|
||||
struct __weak_result_type<_Rp (&)(_A1, _A2)>
|
||||
: public binary_function<_A1, _A2, _Rp>
|
||||
template <class _R, class _A1, class _A2>
|
||||
struct __weak_result_type<_R (&)(_A1, _A2)>
|
||||
: public binary_function<_A1, _A2, _R>
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Rp, class _Cp, class _A1>
|
||||
struct __weak_result_type<_Rp (_Cp::*)(_A1)>
|
||||
: public binary_function<_Cp*, _A1, _Rp>
|
||||
template <class _R, class _C, class _A1>
|
||||
struct __weak_result_type<_R (_C::*)(_A1)>
|
||||
: public binary_function<_C*, _A1, _R>
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Rp, class _Cp, class _A1>
|
||||
struct __weak_result_type<_Rp (_Cp::*)(_A1) const>
|
||||
: public binary_function<const _Cp*, _A1, _Rp>
|
||||
template <class _R, class _C, class _A1>
|
||||
struct __weak_result_type<_R (_C::*)(_A1) const>
|
||||
: public binary_function<const _C*, _A1, _R>
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Rp, class _Cp, class _A1>
|
||||
struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile>
|
||||
: public binary_function<volatile _Cp*, _A1, _Rp>
|
||||
template <class _R, class _C, class _A1>
|
||||
struct __weak_result_type<_R (_C::*)(_A1) volatile>
|
||||
: public binary_function<volatile _C*, _A1, _R>
|
||||
{
|
||||
};
|
||||
|
||||
template <class _Rp, class _Cp, class _A1>
|
||||
struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile>
|
||||
: public binary_function<const volatile _Cp*, _A1, _Rp>
|
||||
template <class _R, class _C, class _A1>
|
||||
struct __weak_result_type<_R (_C::*)(_A1) const volatile>
|
||||
: public binary_function<const volatile _C*, _A1, _R>
|
||||
{
|
||||
};
|
||||
|
||||
// 3 or more arguments
|
||||
|
||||
template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
|
||||
struct __weak_result_type<_Rp (_A1, _A2, _A3, _A4...)>
|
||||
template <class _R, class _A1, class _A2, class _A3, class ..._A4>
|
||||
struct __weak_result_type<_R (_A1, _A2, _A3, _A4...)>
|
||||
{
|
||||
typedef _Rp result_type;
|
||||
typedef _R result_type;
|
||||
};
|
||||
|
||||
template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
|
||||
struct __weak_result_type<_Rp (&)(_A1, _A2, _A3, _A4...)>
|
||||
template <class _R, class _A1, class _A2, class _A3, class ..._A4>
|
||||
struct __weak_result_type<_R (&)(_A1, _A2, _A3, _A4...)>
|
||||
{
|
||||
typedef _Rp result_type;
|
||||
typedef _R result_type;
|
||||
};
|
||||
|
||||
template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
|
||||
struct __weak_result_type<_Rp (*)(_A1, _A2, _A3, _A4...)>
|
||||
template <class _R, class _A1, class _A2, class _A3, class ..._A4>
|
||||
struct __weak_result_type<_R (*)(_A1, _A2, _A3, _A4...)>
|
||||
{
|
||||
typedef _Rp result_type;
|
||||
typedef _R result_type;
|
||||
};
|
||||
|
||||
template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
|
||||
struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...)>
|
||||
template <class _R, class _C, class _A1, class _A2, class ..._A3>
|
||||
struct __weak_result_type<_R (_C::*)(_A1, _A2, _A3...)>
|
||||
{
|
||||
typedef _Rp result_type;
|
||||
typedef _R result_type;
|
||||
};
|
||||
|
||||
template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
|
||||
struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const>
|
||||
template <class _R, class _C, class _A1, class _A2, class ..._A3>
|
||||
struct __weak_result_type<_R (_C::*)(_A1, _A2, _A3...) const>
|
||||
{
|
||||
typedef _Rp result_type;
|
||||
typedef _R result_type;
|
||||
};
|
||||
|
||||
template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
|
||||
struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) volatile>
|
||||
template <class _R, class _C, class _A1, class _A2, class ..._A3>
|
||||
struct __weak_result_type<_R (_C::*)(_A1, _A2, _A3...) volatile>
|
||||
{
|
||||
typedef _Rp result_type;
|
||||
typedef _R result_type;
|
||||
};
|
||||
|
||||
template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
|
||||
struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const volatile>
|
||||
template <class _R, class _C, class _A1, class _A2, class ..._A3>
|
||||
struct __weak_result_type<_R (_C::*)(_A1, _A2, _A3...) const volatile>
|
||||
{
|
||||
typedef _Rp result_type;
|
||||
typedef _R result_type;
|
||||
};
|
||||
|
||||
// __invoke
|
||||
|
||||
// bullets 1 and 2
|
||||
|
||||
template <class _Fp, class _A0, class ..._Args>
|
||||
template <class _F, class _A0, class ..._Args>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
auto
|
||||
__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
|
||||
__invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
|
||||
-> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...))
|
||||
{
|
||||
return (_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...);
|
||||
}
|
||||
|
||||
template <class _Fp, class _A0, class ..._Args>
|
||||
template <class _F, class _A0, class ..._Args>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
auto
|
||||
__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
|
||||
__invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
|
||||
-> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...))
|
||||
{
|
||||
return ((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...);
|
||||
@@ -312,19 +303,19 @@ __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
|
||||
|
||||
// bullets 3 and 4
|
||||
|
||||
template <class _Fp, class _A0>
|
||||
template <class _F, class _A0>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
auto
|
||||
__invoke(_Fp&& __f, _A0&& __a0)
|
||||
__invoke(_F&& __f, _A0&& __a0)
|
||||
-> decltype(_VSTD::forward<_A0>(__a0).*__f)
|
||||
{
|
||||
return _VSTD::forward<_A0>(__a0).*__f;
|
||||
}
|
||||
|
||||
template <class _Fp, class _A0>
|
||||
template <class _F, class _A0>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
auto
|
||||
__invoke(_Fp&& __f, _A0&& __a0)
|
||||
__invoke(_F&& __f, _A0&& __a0)
|
||||
-> decltype((*_VSTD::forward<_A0>(__a0)).*__f)
|
||||
{
|
||||
return (*_VSTD::forward<_A0>(__a0)).*__f;
|
||||
@@ -332,13 +323,13 @@ __invoke(_Fp&& __f, _A0&& __a0)
|
||||
|
||||
// bullet 5
|
||||
|
||||
template <class _Fp, class ..._Args>
|
||||
template <class _F, class ..._Args>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
auto
|
||||
__invoke(_Fp&& __f, _Args&& ...__args)
|
||||
-> decltype(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...))
|
||||
__invoke(_F&& __f, _Args&& ...__args)
|
||||
-> decltype(_VSTD::forward<_F>(__f)(_VSTD::forward<_Args>(__args)...))
|
||||
{
|
||||
return _VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...);
|
||||
return _VSTD::forward<_F>(__f)(_VSTD::forward<_Args>(__args)...);
|
||||
}
|
||||
|
||||
template <class _Tp, class ..._Args>
|
||||
@@ -418,13 +409,13 @@ cref(reference_wrapper<_Tp> __t) _NOEXCEPT
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
|
||||
|
||||
template <class _Tp> void ref(const _Tp&&) = delete;
|
||||
template <class _Tp> void cref(const _Tp&&) = delete;
|
||||
template <class _Tp> void ref(const _Tp&& __t) = delete;
|
||||
template <class _Tp> void cref(const _Tp&& __t) = delete;
|
||||
|
||||
#else // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
|
||||
|
||||
template <class _Tp> void ref(const _Tp&&);// = delete;
|
||||
template <class _Tp> void cref(const _Tp&&);// = delete;
|
||||
template <class _Tp> void ref(const _Tp&& __t);// = delete;
|
||||
template <class _Tp> void cref(const _Tp&& __t);// = delete;
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -18,11 +18,7 @@
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -58,31 +54,10 @@ struct __hash_node
|
||||
value_type __value_;
|
||||
};
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
__is_power2(size_t __bc)
|
||||
{
|
||||
return __bc > 2 && !(__bc & (__bc - 1));
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
size_t
|
||||
__constrain_hash(size_t __h, size_t __bc)
|
||||
{
|
||||
return !(__bc & (__bc - 1)) ? __h & (__bc - 1) : __h % __bc;
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
size_t
|
||||
__next_pow2(size_t __n)
|
||||
{
|
||||
return size_t(1) << (std::numeric_limits<size_t>::digits - __clz(__n-1));
|
||||
}
|
||||
|
||||
template <class _Tp, class _Hash, class _Equal, class _Alloc> class __hash_table;
|
||||
template <class _ConstNodePtr> class _LIBCPP_VISIBLE __hash_const_iterator;
|
||||
template <class _HashIterator> class _LIBCPP_VISIBLE __hash_map_iterator;
|
||||
template <class _HashIterator> class _LIBCPP_VISIBLE __hash_map_const_iterator;
|
||||
template <class _ConstNodePtr> class __hash_const_iterator;
|
||||
template <class _HashIterator> class __hash_map_iterator;
|
||||
template <class _HashIterator> class __hash_map_const_iterator;
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
class _LIBCPP_VISIBLE unordered_map;
|
||||
|
||||
@@ -261,7 +236,7 @@ public:
|
||||
__hash_local_iterator& operator++()
|
||||
{
|
||||
__node_ = __node_->__next_;
|
||||
if (__node_ != nullptr && __constrain_hash(__node_->__hash_, __bucket_count_) != __bucket_)
|
||||
if (__node_ != nullptr && __node_->__hash_ % __bucket_count_ != __bucket_)
|
||||
__node_ = nullptr;
|
||||
return *this;
|
||||
}
|
||||
@@ -351,7 +326,7 @@ public:
|
||||
__hash_const_local_iterator& operator++()
|
||||
{
|
||||
__node_ = __node_->__next_;
|
||||
if (__node_ != nullptr && __constrain_hash(__node_->__hash_, __bucket_count_) != __bucket_)
|
||||
if (__node_ != nullptr && __node_->__hash_ % __bucket_count_ != __bucket_)
|
||||
__node_ = nullptr;
|
||||
return *this;
|
||||
}
|
||||
@@ -457,10 +432,9 @@ public:
|
||||
bool __value_constructed;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit __hash_node_destructor(allocator_type& __na,
|
||||
bool __constructed = false) _NOEXCEPT
|
||||
explicit __hash_node_destructor(allocator_type& __na) _NOEXCEPT
|
||||
: __na_(__na),
|
||||
__value_constructed(__constructed)
|
||||
__value_constructed(false)
|
||||
{}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -496,6 +470,7 @@ public:
|
||||
public:
|
||||
// Create __node
|
||||
typedef __hash_node<value_type, typename __alloc_traits::void_pointer> __node;
|
||||
typedef typename __node::__first_node __first_node;
|
||||
typedef typename __alloc_traits::template
|
||||
#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
|
||||
rebind_alloc<__node>
|
||||
@@ -506,7 +481,6 @@ public:
|
||||
typedef allocator_traits<__node_allocator> __node_traits;
|
||||
typedef typename __node_traits::pointer __node_pointer;
|
||||
typedef typename __node_traits::const_pointer __node_const_pointer;
|
||||
typedef __hash_node_base<__node_pointer> __first_node;
|
||||
|
||||
private:
|
||||
|
||||
@@ -625,15 +599,15 @@ public:
|
||||
pair<iterator, bool> __insert_unique(const value_type& __x);
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
template <class _Pp>
|
||||
pair<iterator, bool> __insert_unique(_Pp&& __x);
|
||||
template <class _P>
|
||||
pair<iterator, bool> __insert_unique(_P&& __x);
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
template <class _Pp>
|
||||
iterator __insert_multi(_Pp&& __x);
|
||||
template <class _Pp>
|
||||
iterator __insert_multi(const_iterator __p, _Pp&& __x);
|
||||
template <class _P>
|
||||
iterator __insert_multi(_P&& __x);
|
||||
template <class _P>
|
||||
iterator __insert_multi(const_iterator __p, _P&& __x);
|
||||
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
iterator __insert_multi(const value_type& __x);
|
||||
iterator __insert_multi(const_iterator __p, const value_type& __x);
|
||||
@@ -658,15 +632,15 @@ public:
|
||||
template <class _Key>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
size_type bucket(const _Key& __k) const
|
||||
{return __constrain_hash(hash_function()(__k), bucket_count());}
|
||||
{return hash_function()(__k) % bucket_count();}
|
||||
|
||||
template <class _Key>
|
||||
iterator find(const _Key& __x);
|
||||
template <class _Key>
|
||||
const_iterator find(const _Key& __x) const;
|
||||
|
||||
typedef __hash_node_destructor<__node_allocator> _Dp;
|
||||
typedef unique_ptr<__node, _Dp> __node_holder;
|
||||
typedef __hash_node_destructor<__node_allocator> _D;
|
||||
typedef unique_ptr<__node, _D> __node_holder;
|
||||
|
||||
iterator erase(const_iterator __p);
|
||||
iterator erase(const_iterator __first, const_iterator __last);
|
||||
@@ -744,7 +718,7 @@ private:
|
||||
__node_traits::propagate_on_container_copy_assignment::value>());}
|
||||
void __copy_assign_alloc(const __hash_table& __u, true_type);
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __copy_assign_alloc(const __hash_table&, false_type) {}
|
||||
void __copy_assign_alloc(const __hash_table& __u, false_type) {}
|
||||
|
||||
void __move_assign(__hash_table& __u, false_type);
|
||||
void __move_assign(__hash_table& __u, true_type)
|
||||
@@ -773,37 +747,37 @@ private:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {}
|
||||
|
||||
template <class _Ap>
|
||||
template <class _A>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static
|
||||
void
|
||||
__swap_alloc(_Ap& __x, _Ap& __y)
|
||||
__swap_alloc(_A& __x, _A& __y)
|
||||
_NOEXCEPT_(
|
||||
!allocator_traits<_Ap>::propagate_on_container_swap::value ||
|
||||
__is_nothrow_swappable<_Ap>::value)
|
||||
!allocator_traits<_A>::propagate_on_container_swap::value ||
|
||||
__is_nothrow_swappable<_A>::value)
|
||||
{
|
||||
__swap_alloc(__x, __y,
|
||||
integral_constant<bool,
|
||||
allocator_traits<_Ap>::propagate_on_container_swap::value
|
||||
allocator_traits<_A>::propagate_on_container_swap::value
|
||||
>());
|
||||
}
|
||||
|
||||
template <class _Ap>
|
||||
template <class _A>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static
|
||||
void
|
||||
__swap_alloc(_Ap& __x, _Ap& __y, true_type)
|
||||
_NOEXCEPT_(__is_nothrow_swappable<_Ap>::value)
|
||||
__swap_alloc(_A& __x, _A& __y, true_type)
|
||||
_NOEXCEPT_(__is_nothrow_swappable<_A>::value)
|
||||
{
|
||||
using _VSTD::swap;
|
||||
swap(__x, __y);
|
||||
}
|
||||
|
||||
template <class _Ap>
|
||||
template <class _A>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static
|
||||
void
|
||||
__swap_alloc(_Ap&, _Ap&, false_type) _NOEXCEPT {}
|
||||
__swap_alloc(_A& __x, _A& __y, false_type) _NOEXCEPT {}
|
||||
|
||||
void __deallocate(__node_pointer __np) _NOEXCEPT;
|
||||
__node_pointer __detach() _NOEXCEPT;
|
||||
@@ -892,7 +866,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u)
|
||||
{
|
||||
if (size() > 0)
|
||||
{
|
||||
__bucket_list_[__constrain_hash(__p1_.first().__next_->__hash_, bucket_count())] =
|
||||
__bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
|
||||
static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
|
||||
__u.__p1_.first().__next_ = nullptr;
|
||||
__u.size() = 0;
|
||||
@@ -916,7 +890,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,
|
||||
{
|
||||
__p1_.first().__next_ = __u.__p1_.first().__next_;
|
||||
__u.__p1_.first().__next_ = nullptr;
|
||||
__bucket_list_[__constrain_hash(__p1_.first().__next_->__hash_, bucket_count())] =
|
||||
__bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
|
||||
static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
|
||||
size() = __u.size();
|
||||
__u.size() = 0;
|
||||
@@ -1013,7 +987,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
|
||||
__p1_.first().__next_ = __u.__p1_.first().__next_;
|
||||
if (size() > 0)
|
||||
{
|
||||
__bucket_list_[__constrain_hash(__p1_.first().__next_->__hash_, bucket_count())] =
|
||||
__bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
|
||||
static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
|
||||
__u.__p1_.first().__next_ = nullptr;
|
||||
__u.size() = 0;
|
||||
@@ -1211,12 +1185,12 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __
|
||||
size_t __chash;
|
||||
if (__bc != 0)
|
||||
{
|
||||
__chash = __constrain_hash(__nd->__hash_, __bc);
|
||||
__chash = __nd->__hash_ % __bc;
|
||||
__ndptr = __bucket_list_[__chash];
|
||||
if (__ndptr != nullptr)
|
||||
{
|
||||
for (__ndptr = __ndptr->__next_; __ndptr != nullptr &&
|
||||
__constrain_hash(__ndptr->__hash_, __bc) == __chash;
|
||||
__ndptr->__hash_ % __bc == __chash;
|
||||
__ndptr = __ndptr->__next_)
|
||||
{
|
||||
if (key_eq()(__ndptr->__value_, __nd->__value_))
|
||||
@@ -1227,10 +1201,10 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __
|
||||
{
|
||||
if (size()+1 > __bc * max_load_factor() || __bc == 0)
|
||||
{
|
||||
rehash(_VSTD::max<size_type>(2 * __bc + !__is_power2(__bc),
|
||||
rehash(_VSTD::max<size_type>(2 * __bc + 1,
|
||||
size_type(ceil(float(size() + 1) / max_load_factor()))));
|
||||
__bc = bucket_count();
|
||||
__chash = __constrain_hash(__nd->__hash_, __bc);
|
||||
__chash = __nd->__hash_ % __bc;
|
||||
}
|
||||
// insert_after __bucket_list_[__chash], or __first_node if bucket is null
|
||||
__node_pointer __pn = __bucket_list_[__chash];
|
||||
@@ -1242,7 +1216,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __
|
||||
// fix up __bucket_list_
|
||||
__bucket_list_[__chash] = __pn;
|
||||
if (__nd->__next_ != nullptr)
|
||||
__bucket_list_[__constrain_hash(__nd->__next_->__hash_, __bc)] = __nd;
|
||||
__bucket_list_[__nd->__next_->__hash_ % __bc] = __nd;
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1266,11 +1240,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(__node_pointer __c
|
||||
size_type __bc = bucket_count();
|
||||
if (size()+1 > __bc * max_load_factor() || __bc == 0)
|
||||
{
|
||||
rehash(_VSTD::max<size_type>(2 * __bc + !__is_power2(__bc),
|
||||
rehash(_VSTD::max<size_type>(2 * __bc + 1,
|
||||
size_type(ceil(float(size() + 1) / max_load_factor()))));
|
||||
__bc = bucket_count();
|
||||
}
|
||||
size_t __chash = __constrain_hash(__cp->__hash_, __bc);
|
||||
size_t __chash = __cp->__hash_ % __bc;
|
||||
__node_pointer __pn = __bucket_list_[__chash];
|
||||
if (__pn == nullptr)
|
||||
{
|
||||
@@ -1280,12 +1254,12 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(__node_pointer __c
|
||||
// fix up __bucket_list_
|
||||
__bucket_list_[__chash] = __pn;
|
||||
if (__cp->__next_ != nullptr)
|
||||
__bucket_list_[__constrain_hash(__cp->__next_->__hash_, __bc)] = __cp;
|
||||
__bucket_list_[__cp->__next_->__hash_ % __bc] = __cp;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (bool __found = false; __pn->__next_ != nullptr &&
|
||||
__constrain_hash(__pn->__next_->__hash_, __bc) == __chash;
|
||||
__pn->__next_->__hash_ % __bc == __chash;
|
||||
__pn = __pn->__next_)
|
||||
{
|
||||
// __found key_eq() action
|
||||
@@ -1306,7 +1280,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(__node_pointer __c
|
||||
__pn->__next_ = __cp;
|
||||
if (__cp->__next_ != nullptr)
|
||||
{
|
||||
size_t __nhash = __constrain_hash(__cp->__next_->__hash_, __bc);
|
||||
size_t __nhash = __cp->__next_->__hash_ % __bc;
|
||||
if (__nhash != __chash)
|
||||
__bucket_list_[__nhash] = __cp;
|
||||
}
|
||||
@@ -1327,11 +1301,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(
|
||||
size_type __bc = bucket_count();
|
||||
if (size()+1 > __bc * max_load_factor() || __bc == 0)
|
||||
{
|
||||
rehash(_VSTD::max<size_type>(2 * __bc + !__is_power2(__bc),
|
||||
rehash(_VSTD::max<size_type>(2 * __bc + 1,
|
||||
size_type(ceil(float(size() + 1) / max_load_factor()))));
|
||||
__bc = bucket_count();
|
||||
}
|
||||
size_t __chash = __constrain_hash(__cp->__hash_, __bc);
|
||||
size_t __chash = __cp->__hash_ % __bc;
|
||||
__node_pointer __pp = __bucket_list_[__chash];
|
||||
while (__pp->__next_ != __np)
|
||||
__pp = __pp->__next_;
|
||||
@@ -1354,12 +1328,12 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(const value_type& __x)
|
||||
size_t __chash;
|
||||
if (__bc != 0)
|
||||
{
|
||||
__chash = __constrain_hash(__hash, __bc);
|
||||
__chash = __hash % __bc;
|
||||
__nd = __bucket_list_[__chash];
|
||||
if (__nd != nullptr)
|
||||
{
|
||||
for (__nd = __nd->__next_; __nd != nullptr &&
|
||||
__constrain_hash(__nd->__hash_, __bc) == __chash;
|
||||
__nd->__hash_ % __bc == __chash;
|
||||
__nd = __nd->__next_)
|
||||
{
|
||||
if (key_eq()(__nd->__value_, __x))
|
||||
@@ -1371,10 +1345,10 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(const value_type& __x)
|
||||
__node_holder __h = __construct_node(__x, __hash);
|
||||
if (size()+1 > __bc * max_load_factor() || __bc == 0)
|
||||
{
|
||||
rehash(_VSTD::max<size_type>(2 * __bc + !__is_power2(__bc),
|
||||
rehash(_VSTD::max<size_type>(2 * __bc + 1,
|
||||
size_type(ceil(float(size() + 1) / max_load_factor()))));
|
||||
__bc = bucket_count();
|
||||
__chash = __constrain_hash(__hash, __bc);
|
||||
__chash = __hash % __bc;
|
||||
}
|
||||
// insert_after __bucket_list_[__chash], or __first_node if bucket is null
|
||||
__node_pointer __pn = __bucket_list_[__chash];
|
||||
@@ -1386,7 +1360,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(const value_type& __x)
|
||||
// fix up __bucket_list_
|
||||
__bucket_list_[__chash] = __pn;
|
||||
if (__h->__next_ != nullptr)
|
||||
__bucket_list_[__constrain_hash(__h->__next_->__hash_, __bc)] = __h.get();
|
||||
__bucket_list_[__h->__next_->__hash_ % __bc] = __h.get();
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1443,11 +1417,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_hint_multi(
|
||||
#endif // _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class _Tp, class _Hash, class _Equal, class _Alloc>
|
||||
template <class _Pp>
|
||||
template <class _P>
|
||||
pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
|
||||
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(_Pp&& __x)
|
||||
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(_P&& __x)
|
||||
{
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_Pp>(__x));
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_P>(__x));
|
||||
pair<iterator, bool> __r = __node_insert_unique(__h.get());
|
||||
if (__r.second)
|
||||
__h.release();
|
||||
@@ -1459,23 +1433,23 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(_Pp&& __x)
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
template <class _Tp, class _Hash, class _Equal, class _Alloc>
|
||||
template <class _Pp>
|
||||
template <class _P>
|
||||
typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
|
||||
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(_Pp&& __x)
|
||||
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(_P&& __x)
|
||||
{
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_Pp>(__x));
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_P>(__x));
|
||||
iterator __r = __node_insert_multi(__h.get());
|
||||
__h.release();
|
||||
return __r;
|
||||
}
|
||||
|
||||
template <class _Tp, class _Hash, class _Equal, class _Alloc>
|
||||
template <class _Pp>
|
||||
template <class _P>
|
||||
typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
|
||||
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const_iterator __p,
|
||||
_Pp&& __x)
|
||||
_P&& __x)
|
||||
{
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_Pp>(__x));
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_P>(__x));
|
||||
iterator __r = __node_insert_multi(__p, __h.get());
|
||||
__h.release();
|
||||
return __r;
|
||||
@@ -1510,20 +1484,16 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc>
|
||||
void
|
||||
__hash_table<_Tp, _Hash, _Equal, _Alloc>::rehash(size_type __n)
|
||||
{
|
||||
if (__n == 1)
|
||||
__n = 2;
|
||||
else if (__n & (__n - 1))
|
||||
__n = __next_prime(__n);
|
||||
__n = __next_prime(_VSTD::max<size_type>(__n, size() > 0));
|
||||
size_type __bc = bucket_count();
|
||||
if (__n > __bc)
|
||||
__rehash(__n);
|
||||
else if (__n < __bc)
|
||||
else
|
||||
{
|
||||
__n = _VSTD::max<size_type>
|
||||
(
|
||||
__n,
|
||||
__is_power2(__bc) ? __next_pow2(size_t(ceil(float(size()) / max_load_factor()))) :
|
||||
__next_prime(size_t(ceil(float(size()) / max_load_factor())))
|
||||
__next_prime(size_t(ceil(float(size()) / max_load_factor())))
|
||||
);
|
||||
if (__n < __bc)
|
||||
__rehash(__n);
|
||||
@@ -1546,13 +1516,13 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__rehash(size_type __nbc)
|
||||
__node_pointer __cp = __pp->__next_;
|
||||
if (__cp != nullptr)
|
||||
{
|
||||
size_type __chash = __constrain_hash(__cp->__hash_, __nbc);
|
||||
size_type __chash = __cp->__hash_ % __nbc;
|
||||
__bucket_list_[__chash] = __pp;
|
||||
size_type __phash = __chash;
|
||||
for (__pp = __cp, __cp = __cp->__next_; __cp != nullptr;
|
||||
__cp = __pp->__next_)
|
||||
{
|
||||
__chash = __constrain_hash(__cp->__hash_, __nbc);
|
||||
__chash = __cp->__hash_ % __nbc;
|
||||
if (__chash == __phash)
|
||||
__pp = __cp;
|
||||
else
|
||||
@@ -1590,12 +1560,12 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::find(const _Key& __k)
|
||||
size_type __bc = bucket_count();
|
||||
if (__bc != 0)
|
||||
{
|
||||
size_t __chash = __constrain_hash(__hash, __bc);
|
||||
size_t __chash = __hash % __bc;
|
||||
__node_pointer __nd = __bucket_list_[__chash];
|
||||
if (__nd != nullptr)
|
||||
{
|
||||
for (__nd = __nd->__next_; __nd != nullptr &&
|
||||
__constrain_hash(__nd->__hash_, __bc) == __chash;
|
||||
__nd->__hash_ % __bc == __chash;
|
||||
__nd = __nd->__next_)
|
||||
{
|
||||
if (key_eq()(__nd->__value_, __k))
|
||||
@@ -1615,12 +1585,12 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::find(const _Key& __k) const
|
||||
size_type __bc = bucket_count();
|
||||
if (__bc != 0)
|
||||
{
|
||||
size_t __chash = __constrain_hash(__hash, __bc);
|
||||
size_t __chash = __hash % __bc;
|
||||
__node_const_pointer __nd = __bucket_list_[__chash];
|
||||
if (__nd != nullptr)
|
||||
{
|
||||
for (__nd = __nd->__next_; __nd != nullptr &&
|
||||
__constrain_hash(__nd->__hash_, __bc) == __chash;
|
||||
__nd->__hash_ % __bc == __chash;
|
||||
__nd = __nd->__next_)
|
||||
{
|
||||
if (key_eq()(__nd->__value_, __k))
|
||||
@@ -1641,7 +1611,7 @@ typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
|
||||
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(_Args&& ...__args)
|
||||
{
|
||||
__node_allocator& __na = __node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::forward<_Args>(__args)...);
|
||||
__h.get_deleter().__value_constructed = true;
|
||||
__h->__hash_ = hash_function()(__h->__value_);
|
||||
@@ -1657,7 +1627,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(value_type&& __v,
|
||||
size_t __hash)
|
||||
{
|
||||
__node_allocator& __na = __node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
|
||||
__h.get_deleter().__value_constructed = true;
|
||||
__h->__hash_ = __hash;
|
||||
@@ -1672,7 +1642,7 @@ typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
|
||||
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const value_type& __v)
|
||||
{
|
||||
__node_allocator& __na = __node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_), __v);
|
||||
__h.get_deleter().__value_constructed = true;
|
||||
__h->__hash_ = hash_function()(__h->__value_);
|
||||
@@ -1688,7 +1658,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const value_type& __v
|
||||
size_t __hash)
|
||||
{
|
||||
__node_allocator& __na = __node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_), __v);
|
||||
__h.get_deleter().__value_constructed = true;
|
||||
__h->__hash_ = __hash;
|
||||
@@ -1759,7 +1729,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p) _NOEXCEPT
|
||||
// current node
|
||||
__node_pointer __cn = const_cast<__node_pointer>(__p.__node_);
|
||||
size_type __bc = bucket_count();
|
||||
size_t __chash = __constrain_hash(__cn->__hash_, __bc);
|
||||
size_t __chash = __cn->__hash_ % __bc;
|
||||
// find previous node
|
||||
__node_pointer __pn = __bucket_list_[__chash];
|
||||
for (; __pn->__next_ != __cn; __pn = __pn->__next_)
|
||||
@@ -1767,15 +1737,15 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p) _NOEXCEPT
|
||||
// Fix up __bucket_list_
|
||||
// if __pn is not in same bucket (before begin is not in same bucket) &&
|
||||
// if __cn->__next_ is not in same bucket (nullptr is not in same bucket)
|
||||
if (__pn == _VSTD::addressof(__p1_.first()) || __constrain_hash(__pn->__hash_, __bc) != __chash)
|
||||
if (__pn == _VSTD::addressof(__p1_.first()) || __pn->__hash_ % __bc != __chash)
|
||||
{
|
||||
if (__cn->__next_ == nullptr || __constrain_hash(__cn->__next_->__hash_, __bc) != __chash)
|
||||
if (__cn->__next_ == nullptr || __cn->__next_->__hash_ % __bc != __chash)
|
||||
__bucket_list_[__chash] = nullptr;
|
||||
}
|
||||
// if __cn->__next_ is not in same bucket (nullptr is in same bucket)
|
||||
if (__cn->__next_ != nullptr)
|
||||
{
|
||||
size_t __nhash = __constrain_hash(__cn->__next_->__hash_, __bc);
|
||||
size_t __nhash = __cn->__next_->__hash_ % __bc;
|
||||
if (__nhash != __chash)
|
||||
__bucket_list_[__nhash] = __pn;
|
||||
}
|
||||
@@ -1783,7 +1753,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p) _NOEXCEPT
|
||||
__pn->__next_ = __cn->__next_;
|
||||
__cn->__next_ = nullptr;
|
||||
--size();
|
||||
return __node_holder(__cn, _Dp(__node_alloc(), true));
|
||||
return __node_holder(__cn, _D(__node_alloc()));
|
||||
}
|
||||
|
||||
template <class _Tp, class _Hash, class _Equal, class _Alloc>
|
||||
@@ -1906,10 +1876,10 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::swap(__hash_table& __u)
|
||||
__p2_.swap(__u.__p2_);
|
||||
__p3_.swap(__u.__p3_);
|
||||
if (size() > 0)
|
||||
__bucket_list_[__constrain_hash(__p1_.first().__next_->__hash_, bucket_count())] =
|
||||
__bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
|
||||
static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
|
||||
if (__u.size() > 0)
|
||||
__u.__bucket_list_[__constrain_hash(__u.__p1_.first().__next_->__hash_, __u.bucket_count())] =
|
||||
__u.__bucket_list_[__u.__p1_.first().__next_->__hash_ % __u.bucket_count()] =
|
||||
static_cast<__node_pointer>(_VSTD::addressof(__u.__p1_.first()));
|
||||
}
|
||||
|
||||
@@ -1923,7 +1893,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::bucket_size(size_type __n) const
|
||||
if (__np != nullptr)
|
||||
{
|
||||
for (__np = __np->__next_; __np != nullptr &&
|
||||
__constrain_hash(__np->__hash_, __bc) == __n;
|
||||
__np->__hash_ % __bc == __n;
|
||||
__np = __np->__next_, ++__r)
|
||||
;
|
||||
}
|
||||
|
||||
141
include/__locale
141
include/__locale
@@ -19,36 +19,23 @@
|
||||
#include <cstdint>
|
||||
#include <cctype>
|
||||
#include <locale.h>
|
||||
#if _WIN32
|
||||
# include <support/win32/locale_win32.h>
|
||||
#elif (__GLIBC__ || __APPLE__ || __FreeBSD__ || __sun__)
|
||||
# include <xlocale.h>
|
||||
#endif // _WIN32 || __GLIBC__ || __APPLE__ || __FreeBSD_
|
||||
#include <xlocale.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
class _LIBCPP_VISIBLE locale;
|
||||
class locale;
|
||||
|
||||
template <class _Facet>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
has_facet(const locale&) _NOEXCEPT;
|
||||
|
||||
template <class _Facet>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const _Facet&
|
||||
use_facet(const locale&);
|
||||
template <class _Facet> bool has_facet(const locale&) _NOEXCEPT;
|
||||
template <class _Facet> const _Facet& use_facet(const locale&);
|
||||
|
||||
class _LIBCPP_VISIBLE locale
|
||||
{
|
||||
public:
|
||||
// types:
|
||||
class _LIBCPP_VISIBLE facet;
|
||||
class _LIBCPP_VISIBLE id;
|
||||
class facet;
|
||||
class id;
|
||||
|
||||
typedef int category;
|
||||
static const category // values assigned here are for exposition only
|
||||
@@ -126,7 +113,7 @@ class _LIBCPP_VISIBLE locale::id
|
||||
|
||||
static int32_t __next_id;
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR id() :__id_(0) {}
|
||||
_LIBCPP_INLINE_VISIBILITY id() {}
|
||||
private:
|
||||
void __init();
|
||||
void operator=(const id&); // = delete;
|
||||
@@ -240,22 +227,22 @@ collate<_CharT>::do_compare(const char_type* __lo1, const char_type* __hi1,
|
||||
|
||||
template <class _CharT>
|
||||
long
|
||||
collate<_CharT>::do_hash(const char_type* __lo, const char_type* __hi) const
|
||||
collate<_CharT>::do_hash(const char_type* lo, const char_type* hi) const
|
||||
{
|
||||
size_t __h = 0;
|
||||
const size_t __sr = __CHAR_BIT__ * sizeof(size_t) - 8;
|
||||
const size_t __mask = size_t(0xF) << (__sr + 4);
|
||||
for(const char_type* __p = __lo; __p != __hi; ++__p)
|
||||
size_t h = 0;
|
||||
const size_t sr = __CHAR_BIT__ * sizeof(size_t) - 8;
|
||||
const size_t mask = size_t(0xF) << (sr + 4);
|
||||
for(const char_type* p = lo; p != hi; ++p)
|
||||
{
|
||||
__h = (__h << 4) + static_cast<size_t>(*__p);
|
||||
size_t __g = __h & __mask;
|
||||
__h ^= __g | (__g >> __sr);
|
||||
h = (h << 4) + *p;
|
||||
size_t g = h & mask;
|
||||
h ^= g | (g >> sr);
|
||||
}
|
||||
return static_cast<long>(__h);
|
||||
return static_cast<long>(h);
|
||||
}
|
||||
|
||||
_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_VISIBLE collate<char>)
|
||||
_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_VISIBLE collate<wchar_t>)
|
||||
extern template class _LIBCPP_VISIBLE collate<char>;
|
||||
extern template class _LIBCPP_VISIBLE collate<wchar_t>;
|
||||
|
||||
// template <class CharT> class collate_byname;
|
||||
|
||||
@@ -315,36 +302,9 @@ locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
|
||||
class _LIBCPP_VISIBLE ctype_base
|
||||
{
|
||||
public:
|
||||
#if __GLIBC__
|
||||
typedef unsigned short mask;
|
||||
static const mask space = _ISspace;
|
||||
static const mask print = _ISprint;
|
||||
static const mask cntrl = _IScntrl;
|
||||
static const mask upper = _ISupper;
|
||||
static const mask lower = _ISlower;
|
||||
static const mask alpha = _ISalpha;
|
||||
static const mask digit = _ISdigit;
|
||||
static const mask punct = _ISpunct;
|
||||
static const mask xdigit = _ISxdigit;
|
||||
static const mask blank = _ISblank;
|
||||
#elif _WIN32
|
||||
typedef unsigned short mask;
|
||||
static const mask space = _SPACE;
|
||||
static const mask print = _BLANK|_PUNCT|_ALPHA|_DIGIT;
|
||||
static const mask cntrl = _CONTROL;
|
||||
static const mask upper = _UPPER;
|
||||
static const mask lower = _LOWER;
|
||||
static const mask alpha = _ALPHA;
|
||||
static const mask digit = _DIGIT;
|
||||
static const mask punct = _PUNCT;
|
||||
static const mask xdigit = _HEX;
|
||||
static const mask blank = _BLANK;
|
||||
#elif (__APPLE__ || __FreeBSD__)
|
||||
#if __APPLE__
|
||||
typedef __uint32_t mask;
|
||||
#elif __FreeBSD__
|
||||
typedef unsigned long mask;
|
||||
#endif
|
||||
|
||||
#if __APPLE__
|
||||
static const mask space = _CTYPE_S;
|
||||
static const mask print = _CTYPE_R;
|
||||
static const mask cntrl = _CTYPE_C;
|
||||
@@ -355,31 +315,18 @@ public:
|
||||
static const mask punct = _CTYPE_P;
|
||||
static const mask xdigit = _CTYPE_X;
|
||||
static const mask blank = _CTYPE_B;
|
||||
#elif __sun__
|
||||
typedef unsigned int mask;
|
||||
static const mask space = _ISSPACE;
|
||||
static const mask print = _ISPRINT;
|
||||
static const mask cntrl = _ISCNTRL;
|
||||
static const mask upper = _ISUPPER;
|
||||
static const mask lower = _ISLOWER;
|
||||
static const mask alpha = _ISALPHA;
|
||||
static const mask digit = _ISDIGIT;
|
||||
static const mask punct = _ISPUNCT;
|
||||
static const mask xdigit = _ISXDIGIT;
|
||||
static const mask blank = _ISBLANK;
|
||||
#else // __GLIBC__ || _WIN32 || __APPLE__ || __FreeBSD__ || __sun__
|
||||
typedef unsigned long mask;
|
||||
static const mask space = 1<<0;
|
||||
static const mask print = 1<<1;
|
||||
static const mask cntrl = 1<<2;
|
||||
static const mask upper = 1<<3;
|
||||
static const mask lower = 1<<4;
|
||||
static const mask alpha = 1<<5;
|
||||
static const mask digit = 1<<6;
|
||||
static const mask punct = 1<<7;
|
||||
static const mask xdigit = 1<<8;
|
||||
static const mask blank = 1<<9;
|
||||
#endif // __GLIBC__ || _WIN32 || __APPLE__ || __FreeBSD__
|
||||
#else // __APPLE__
|
||||
static const mask space = _ISspace;
|
||||
static const mask print = _ISprint;
|
||||
static const mask cntrl = _IScntrl;
|
||||
static const mask upper = _ISupper;
|
||||
static const mask lower = _ISlower;
|
||||
static const mask alpha = _ISalpha;
|
||||
static const mask digit = _ISdigit;
|
||||
static const mask punct = _ISpunct;
|
||||
static const mask xdigit = _ISxdigit;
|
||||
static const mask blank = _ISblank;
|
||||
#endif // __APPLE__
|
||||
static const mask alnum = alpha | digit;
|
||||
static const mask graph = alnum | punct;
|
||||
|
||||
@@ -504,14 +451,14 @@ public:
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
bool is(mask __m, char_type __c) const
|
||||
{
|
||||
return isascii(__c) ? __tab_[static_cast<int>(__c)] & __m : false;
|
||||
return isascii(__c) ? __tab_[__c] & __m : false;
|
||||
}
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
const char_type* is(const char_type* __low, const char_type* __high, mask* __vec) const
|
||||
{
|
||||
for (; __low != __high; ++__low, ++__vec)
|
||||
*__vec = isascii(*__low) ? __tab_[static_cast<int>(*__low)] : 0;
|
||||
*__vec = isascii(*__low) ? __tab_[*__low] : 0;
|
||||
return __low;
|
||||
}
|
||||
|
||||
@@ -519,7 +466,7 @@ public:
|
||||
const char_type* scan_is (mask __m, const char_type* __low, const char_type* __high) const
|
||||
{
|
||||
for (; __low != __high; ++__low)
|
||||
if (isascii(*__low) && (__tab_[static_cast<int>(*__low)] & __m))
|
||||
if (isascii(*__low) && (__tab_[*__low] & __m))
|
||||
break;
|
||||
return __low;
|
||||
}
|
||||
@@ -528,7 +475,7 @@ public:
|
||||
const char_type* scan_not(mask __m, const char_type* __low, const char_type* __high) const
|
||||
{
|
||||
for (; __low != __high; ++__low)
|
||||
if (!(isascii(*__low) && (__tab_[static_cast<int>(*__low)] & __m)))
|
||||
if (!(isascii(*__low) && (__tab_[*__low] & __m)))
|
||||
break;
|
||||
return __low;
|
||||
}
|
||||
@@ -590,10 +537,6 @@ public:
|
||||
#endif
|
||||
_LIBCPP_ALWAYS_INLINE const mask* table() const _NOEXCEPT {return __tab_;}
|
||||
static const mask* classic_table() _NOEXCEPT;
|
||||
#if defined(__GLIBC__)
|
||||
static const int* __classic_upper_table() _NOEXCEPT;
|
||||
static const int* __classic_lower_table() _NOEXCEPT;
|
||||
#endif
|
||||
|
||||
protected:
|
||||
~ctype();
|
||||
@@ -1135,14 +1078,14 @@ codecvt_byname<_InternT, _ExternT, _StateT>::~codecvt_byname()
|
||||
{
|
||||
}
|
||||
|
||||
_LIBCPP_EXTERN_TEMPLATE(class codecvt_byname<char, char, mbstate_t>)
|
||||
_LIBCPP_EXTERN_TEMPLATE(class codecvt_byname<wchar_t, char, mbstate_t>)
|
||||
_LIBCPP_EXTERN_TEMPLATE(class codecvt_byname<char16_t, char, mbstate_t>)
|
||||
_LIBCPP_EXTERN_TEMPLATE(class codecvt_byname<char32_t, char, mbstate_t>)
|
||||
extern template class codecvt_byname<char, char, mbstate_t>;
|
||||
extern template class codecvt_byname<wchar_t, char, mbstate_t>;
|
||||
extern template class codecvt_byname<char16_t, char, mbstate_t>;
|
||||
extern template class codecvt_byname<char32_t, char, mbstate_t>;
|
||||
|
||||
_LIBCPP_VISIBLE void __throw_runtime_error(const char*);
|
||||
|
||||
template <size_t _Np>
|
||||
template <size_t _N>
|
||||
struct __narrow_to_utf8
|
||||
{
|
||||
template <class _OutputIterator, class _CharT>
|
||||
@@ -1232,7 +1175,7 @@ struct __narrow_to_utf8<32>
|
||||
}
|
||||
};
|
||||
|
||||
template <size_t _Np>
|
||||
template <size_t _N>
|
||||
struct __widen_from_utf8
|
||||
{
|
||||
template <class _OutputIterator>
|
||||
|
||||
@@ -16,9 +16,7 @@
|
||||
#include <system_error>
|
||||
#include <pthread.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#ifdef _LIBCPP_SHARED_LOCK
|
||||
|
||||
@@ -38,11 +36,7 @@ class _LIBCPP_VISIBLE mutex
|
||||
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
#ifndef _LIBCPP_HAS_NO_CONSTEXPR
|
||||
constexpr mutex() _NOEXCEPT : __m_(PTHREAD_MUTEX_INITIALIZER) {}
|
||||
#else
|
||||
mutex() _NOEXCEPT {__m_ = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;}
|
||||
#endif
|
||||
mutex() {__m_ = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;}
|
||||
~mutex();
|
||||
|
||||
private:
|
||||
@@ -51,8 +45,8 @@ private:
|
||||
|
||||
public:
|
||||
void lock();
|
||||
bool try_lock() _NOEXCEPT;
|
||||
void unlock() _NOEXCEPT;
|
||||
bool try_lock();
|
||||
void unlock();
|
||||
|
||||
typedef pthread_mutex_t* native_handle_type;
|
||||
_LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
|
||||
@@ -62,19 +56,17 @@ struct _LIBCPP_VISIBLE defer_lock_t {};
|
||||
struct _LIBCPP_VISIBLE try_to_lock_t {};
|
||||
struct _LIBCPP_VISIBLE adopt_lock_t {};
|
||||
|
||||
#if defined(_LIBCPP_HAS_NO_CONSTEXPR) || defined(_LIBCPP_BUILDING_MUTEX)
|
||||
//constexpr
|
||||
extern const
|
||||
defer_lock_t defer_lock;
|
||||
|
||||
extern const defer_lock_t defer_lock;
|
||||
extern const try_to_lock_t try_to_lock;
|
||||
extern const adopt_lock_t adopt_lock;
|
||||
//constexpr
|
||||
extern const
|
||||
try_to_lock_t try_to_lock;
|
||||
|
||||
#else
|
||||
|
||||
constexpr defer_lock_t defer_lock = defer_lock_t();
|
||||
constexpr try_to_lock_t try_to_lock = try_to_lock_t();
|
||||
constexpr adopt_lock_t adopt_lock = adopt_lock_t();
|
||||
|
||||
#endif
|
||||
//constexpr
|
||||
extern const
|
||||
adopt_lock_t adopt_lock;
|
||||
|
||||
template <class _Mutex>
|
||||
class _LIBCPP_VISIBLE lock_guard
|
||||
@@ -112,12 +104,12 @@ private:
|
||||
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
unique_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {}
|
||||
unique_lock() : __m_(nullptr), __owns_(false) {}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit unique_lock(mutex_type& __m)
|
||||
: __m_(&__m), __owns_(true) {__m_->lock();}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
unique_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
|
||||
unique_lock(mutex_type& __m, defer_lock_t)
|
||||
: __m_(&__m), __owns_(false) {}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
unique_lock(mutex_type& __m, try_to_lock_t)
|
||||
@@ -147,11 +139,11 @@ private:
|
||||
public:
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
unique_lock(unique_lock&& __u) _NOEXCEPT
|
||||
unique_lock(unique_lock&& __u)
|
||||
: __m_(__u.__m_), __owns_(__u.__owns_)
|
||||
{__u.__m_ = nullptr; __u.__owns_ = false;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
unique_lock& operator=(unique_lock&& __u) _NOEXCEPT
|
||||
unique_lock& operator=(unique_lock&& __u)
|
||||
{
|
||||
if (__owns_)
|
||||
__m_->unlock();
|
||||
@@ -196,13 +188,13 @@ public:
|
||||
void unlock();
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void swap(unique_lock& __u) _NOEXCEPT
|
||||
void swap(unique_lock& __u)
|
||||
{
|
||||
_VSTD::swap(__m_, __u.__m_);
|
||||
_VSTD::swap(__owns_, __u.__owns_);
|
||||
}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
mutex_type* release() _NOEXCEPT
|
||||
mutex_type* release()
|
||||
{
|
||||
mutex_type* __m = __m_;
|
||||
__m_ = nullptr;
|
||||
@@ -211,12 +203,12 @@ public:
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool owns_lock() const _NOEXCEPT {return __owns_;}
|
||||
bool owns_lock() const {return __owns_;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_EXPLICIT
|
||||
operator bool () const _NOEXCEPT {return __owns_;}
|
||||
// explicit
|
||||
operator bool () const {return __owns_;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
mutex_type* mutex() const _NOEXCEPT {return __m_;}
|
||||
mutex_type* mutex() const {return __m_;}
|
||||
};
|
||||
|
||||
template <class _Mutex>
|
||||
@@ -282,19 +274,18 @@ unique_lock<_Mutex>::unlock()
|
||||
template <class _Mutex>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
void
|
||||
swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) _NOEXCEPT
|
||||
{__x.swap(__y);}
|
||||
swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) {__x.swap(__y);}
|
||||
|
||||
struct _LIBCPP_VISIBLE cv_status
|
||||
{
|
||||
enum __lx {
|
||||
enum _ {
|
||||
no_timeout,
|
||||
timeout
|
||||
};
|
||||
|
||||
__lx __v_;
|
||||
_ __v_;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY cv_status(__lx __v) : __v_(__v) {}
|
||||
_LIBCPP_INLINE_VISIBILITY cv_status(_ __v) : __v_(__v) {}
|
||||
_LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;}
|
||||
|
||||
};
|
||||
@@ -304,11 +295,7 @@ class _LIBCPP_VISIBLE condition_variable
|
||||
pthread_cond_t __cv_;
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
#ifndef _LIBCPP_HAS_NO_CONSTEXPR
|
||||
constexpr condition_variable() : __cv_(PTHREAD_COND_INITIALIZER) {}
|
||||
#else
|
||||
condition_variable() {__cv_ = (pthread_cond_t)PTHREAD_COND_INITIALIZER;}
|
||||
#endif
|
||||
~condition_variable();
|
||||
|
||||
private:
|
||||
@@ -316,13 +303,18 @@ private:
|
||||
condition_variable& operator=(const condition_variable&); // = delete;
|
||||
|
||||
public:
|
||||
void notify_one() _NOEXCEPT;
|
||||
void notify_all() _NOEXCEPT;
|
||||
void notify_one();
|
||||
void notify_all();
|
||||
|
||||
void wait(unique_lock<mutex>& __lk);
|
||||
template <class _Predicate>
|
||||
void wait(unique_lock<mutex>& __lk, _Predicate __pred);
|
||||
|
||||
template <class _Duration>
|
||||
cv_status
|
||||
wait_until(unique_lock<mutex>& __lk,
|
||||
const chrono::time_point<chrono::system_clock, _Duration>& __t);
|
||||
|
||||
template <class _Clock, class _Duration>
|
||||
cv_status
|
||||
wait_until(unique_lock<mutex>& __lk,
|
||||
@@ -377,13 +369,28 @@ condition_variable::wait(unique_lock<mutex>& __lk, _Predicate __pred)
|
||||
wait(__lk);
|
||||
}
|
||||
|
||||
template <class _Duration>
|
||||
cv_status
|
||||
condition_variable::wait_until(unique_lock<mutex>& __lk,
|
||||
const chrono::time_point<chrono::system_clock, _Duration>& __t)
|
||||
{
|
||||
using namespace chrono;
|
||||
typedef time_point<system_clock, nanoseconds> __nano_sys_tmpt;
|
||||
__do_timed_wait(__lk,
|
||||
__nano_sys_tmpt(__ceil<nanoseconds>(__t.time_since_epoch())));
|
||||
return system_clock::now() < __t ? cv_status::no_timeout :
|
||||
cv_status::timeout;
|
||||
}
|
||||
|
||||
template <class _Clock, class _Duration>
|
||||
cv_status
|
||||
condition_variable::wait_until(unique_lock<mutex>& __lk,
|
||||
const chrono::time_point<_Clock, _Duration>& __t)
|
||||
{
|
||||
using namespace chrono;
|
||||
wait_for(__lk, __t - _Clock::now());
|
||||
system_clock::time_point __s_now = system_clock::now();
|
||||
typename _Clock::time_point __c_now = _Clock::now();
|
||||
__do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__t - __c_now));
|
||||
return _Clock::now() < __t ? cv_status::no_timeout : cv_status::timeout;
|
||||
}
|
||||
|
||||
@@ -407,17 +414,9 @@ condition_variable::wait_for(unique_lock<mutex>& __lk,
|
||||
const chrono::duration<_Rep, _Period>& __d)
|
||||
{
|
||||
using namespace chrono;
|
||||
if (__d <= __d.zero())
|
||||
return cv_status::timeout;
|
||||
typedef time_point<system_clock, duration<long double, nano> > __sys_tpf;
|
||||
typedef time_point<system_clock, nanoseconds> __sys_tpi;
|
||||
__sys_tpf _Max = __sys_tpi::max();
|
||||
system_clock::time_point __s_now = system_clock::now();
|
||||
steady_clock::time_point __c_now = steady_clock::now();
|
||||
if (_Max - __d > __s_now)
|
||||
__do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__d));
|
||||
else
|
||||
__do_timed_wait(__lk, __sys_tpi::max());
|
||||
__do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__d));
|
||||
return steady_clock::now() - __c_now < __d ? cv_status::no_timeout :
|
||||
cv_status::timeout;
|
||||
}
|
||||
|
||||
@@ -6,11 +6,7 @@
|
||||
#include <type_traits>
|
||||
#include <algorithm>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -95,7 +91,7 @@ public:
|
||||
void reserve(size_type __n);
|
||||
void shrink_to_fit() _NOEXCEPT;
|
||||
void push_front(const_reference __x);
|
||||
_LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
|
||||
void push_back(const_reference __x);
|
||||
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
|
||||
void push_front(value_type&& __x);
|
||||
void push_back(value_type&& __x);
|
||||
@@ -133,10 +129,8 @@ public:
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __destruct_at_end(pointer __new_last) _NOEXCEPT
|
||||
{__destruct_at_end(__new_last, false_type());}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
{__destruct_at_end(__new_last, is_trivially_destructible<value_type>());}
|
||||
void __destruct_at_end(pointer __new_last, false_type) _NOEXCEPT;
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __destruct_at_end(pointer __new_last, true_type) _NOEXCEPT;
|
||||
|
||||
void swap(__split_buffer& __x)
|
||||
@@ -147,14 +141,14 @@ public:
|
||||
|
||||
private:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __move_assign_alloc(__split_buffer& __c, true_type)
|
||||
void __move_assign_alloc(const __split_buffer& __c, true_type)
|
||||
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
|
||||
{
|
||||
__alloc() = _VSTD::move(__c.__alloc());
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __move_assign_alloc(__split_buffer&, false_type) _NOEXCEPT
|
||||
void __move_assign_alloc(const __split_buffer& __c, false_type) _NOEXCEPT
|
||||
{}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -173,7 +167,7 @@ private:
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static void __swap_alloc(__alloc_rr&, __alloc_rr&, false_type) _NOEXCEPT
|
||||
static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y, false_type) _NOEXCEPT
|
||||
{}
|
||||
};
|
||||
|
||||
@@ -214,7 +208,7 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
|
||||
__alloc_rr& __a = this->__alloc();
|
||||
do
|
||||
{
|
||||
__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_));
|
||||
__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), value_type());
|
||||
++this->__end_;
|
||||
--__n;
|
||||
} while (__n > 0);
|
||||
@@ -289,7 +283,7 @@ _LIBCPP_INLINE_VISIBILITY inline
|
||||
void
|
||||
__split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, false_type)
|
||||
{
|
||||
while (__begin_ != __new_begin)
|
||||
while (__begin_ < __new_begin)
|
||||
__alloc_traits::destroy(__alloc(), __begin_++);
|
||||
}
|
||||
|
||||
@@ -306,7 +300,7 @@ _LIBCPP_INLINE_VISIBILITY inline
|
||||
void
|
||||
__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type) _NOEXCEPT
|
||||
{
|
||||
while (__new_last != __end_)
|
||||
while (__new_last < __end_)
|
||||
__alloc_traits::destroy(__alloc(), --__end_);
|
||||
}
|
||||
|
||||
@@ -394,8 +388,8 @@ __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c, const __al
|
||||
__first_ = __alloc_traits::allocate(__alloc(), __cap);
|
||||
__begin_ = __end_ = __first_;
|
||||
__end_cap() = __first_ + __cap;
|
||||
typedef move_iterator<iterator> _Ip;
|
||||
__construct_at_end(_Ip(__c.begin()), _Ip(__c.end()));
|
||||
typedef move_iterator<iterator> _I;
|
||||
__construct_at_end(_I(__c.begin()), _I(__c.end()));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -492,7 +486,7 @@ __split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
|
||||
}
|
||||
else
|
||||
{
|
||||
size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
|
||||
size_type __c = max<size_type>(2 * (__end_cap() - __first_), 1);
|
||||
__split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
|
||||
__t.__construct_at_end(move_iterator<pointer>(__begin_),
|
||||
move_iterator<pointer>(__end_));
|
||||
@@ -523,7 +517,7 @@ __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
|
||||
}
|
||||
else
|
||||
{
|
||||
size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
|
||||
size_type __c = max<size_type>(2 * (__end_cap() - __first_), 1);
|
||||
__split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
|
||||
__t.__construct_at_end(move_iterator<pointer>(__begin_),
|
||||
move_iterator<pointer>(__end_));
|
||||
@@ -556,7 +550,7 @@ __split_buffer<_Tp, _Allocator>::push_back(const_reference __x)
|
||||
}
|
||||
else
|
||||
{
|
||||
size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
|
||||
size_type __c = max<size_type>(2 * (__end_cap() - __first_), 1);
|
||||
__split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
|
||||
__t.__construct_at_end(move_iterator<pointer>(__begin_),
|
||||
move_iterator<pointer>(__end_));
|
||||
@@ -587,7 +581,7 @@ __split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
|
||||
}
|
||||
else
|
||||
{
|
||||
size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
|
||||
size_type __c = max<size_type>(2 * (__end_cap() - __first_), 1);
|
||||
__split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
|
||||
__t.__construct_at_end(move_iterator<pointer>(__begin_),
|
||||
move_iterator<pointer>(__end_));
|
||||
@@ -620,7 +614,7 @@ __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)
|
||||
}
|
||||
else
|
||||
{
|
||||
size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
|
||||
size_type __c = max<size_type>(2 * (__end_cap() - __first_), 1);
|
||||
__split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
|
||||
__t.__construct_at_end(move_iterator<pointer>(__begin_),
|
||||
move_iterator<pointer>(__end_));
|
||||
|
||||
@@ -15,26 +15,24 @@
|
||||
#include <type_traits>
|
||||
#include <new>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _Tp, size_t _Np> class _LIBCPP_HIDDEN __sso_allocator;
|
||||
template <class _Tp, size_t _N> class _LIBCPP_HIDDEN __sso_allocator;
|
||||
|
||||
template <size_t _Np>
|
||||
class _LIBCPP_HIDDEN __sso_allocator<void, _Np>
|
||||
template <size_t _N>
|
||||
class _LIBCPP_HIDDEN __sso_allocator<void, _N>
|
||||
{
|
||||
public:
|
||||
typedef const void* const_pointer;
|
||||
typedef void value_type;
|
||||
};
|
||||
|
||||
template <class _Tp, size_t _Np>
|
||||
template <class _Tp, size_t _N>
|
||||
class _LIBCPP_HIDDEN __sso_allocator
|
||||
{
|
||||
typename aligned_storage<sizeof(_Tp) * _Np>::type buf_;
|
||||
typename aligned_storage<sizeof(_Tp) * _N>::type buf_;
|
||||
bool __allocated_;
|
||||
public:
|
||||
typedef size_t size_type;
|
||||
@@ -43,14 +41,14 @@ public:
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY __sso_allocator() throw() : __allocated_(false) {}
|
||||
_LIBCPP_INLINE_VISIBILITY __sso_allocator(const __sso_allocator&) throw() : __allocated_(false) {}
|
||||
template <class _Up> _LIBCPP_INLINE_VISIBILITY __sso_allocator(const __sso_allocator<_Up, _Np>&) throw()
|
||||
template <class _Up> _LIBCPP_INLINE_VISIBILITY __sso_allocator(const __sso_allocator<_Up, _N>&) throw()
|
||||
: __allocated_(false) {}
|
||||
private:
|
||||
__sso_allocator& operator=(const __sso_allocator&);
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, typename __sso_allocator<void, _Np>::const_pointer = 0)
|
||||
_LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, typename __sso_allocator<void, _N>::const_pointer = 0)
|
||||
{
|
||||
if (!__allocated_ && __n <= _Np)
|
||||
if (!__allocated_ && __n <= _N)
|
||||
{
|
||||
__allocated_ = true;
|
||||
return (pointer)&buf_;
|
||||
|
||||
@@ -17,15 +17,11 @@
|
||||
#include <__locale>
|
||||
#include <cstdio>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
static const int __limit = 8;
|
||||
static const unsigned __limit = 8;
|
||||
|
||||
// __stdinbuf
|
||||
|
||||
@@ -104,7 +100,7 @@ __stdinbuf<_CharT>::__getchar(bool __consume)
|
||||
int __nread = _VSTD::max(1, __encoding_);
|
||||
for (int __i = 0; __i < __nread; ++__i)
|
||||
{
|
||||
int __c = getc(__file_);
|
||||
char __c = getc(__file_);
|
||||
if (__c == EOF)
|
||||
return traits_type::eof();
|
||||
__extbuf[__i] = static_cast<char>(__c);
|
||||
@@ -131,7 +127,7 @@ __stdinbuf<_CharT>::__getchar(bool __consume)
|
||||
if (__nread == sizeof(__extbuf))
|
||||
return traits_type::eof();
|
||||
{
|
||||
int __c = getc(__file_);
|
||||
char __c = getc(__file_);
|
||||
if (__c == EOF)
|
||||
return traits_type::eof();
|
||||
__extbuf[__nread] = static_cast<char>(__c);
|
||||
@@ -268,7 +264,7 @@ __stdoutbuf<_CharT>::overflow(int_type __c)
|
||||
if (__r == codecvt_base::partial)
|
||||
{
|
||||
this->setp((char_type*)__e, this->pptr());
|
||||
this->pbump(static_cast<int>(this->epptr() - this->pbase()));
|
||||
this->pbump(this->epptr() - this->pbase());
|
||||
}
|
||||
}
|
||||
else
|
||||
|
||||
@@ -17,9 +17,7 @@
|
||||
#include <stdexcept>
|
||||
#include <algorithm>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -614,8 +612,8 @@ public:
|
||||
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
|
||||
};
|
||||
|
||||
template <class _TreeIterator> class _LIBCPP_VISIBLE __map_iterator;
|
||||
template <class _TreeIterator> class _LIBCPP_VISIBLE __map_const_iterator;
|
||||
template <class _TreeIterator> class __map_iterator;
|
||||
template <class _TreeIterator> class __map_const_iterator;
|
||||
|
||||
template <class _Tp, class _NodePtr, class _DiffType>
|
||||
class _LIBCPP_VISIBLE __tree_iterator
|
||||
@@ -932,14 +930,14 @@ public:
|
||||
__emplace_hint_multi(const_iterator __p, _Args&&... __args);
|
||||
#endif // _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class _Vp>
|
||||
pair<iterator, bool> __insert_unique(_Vp&& __v);
|
||||
template <class _Vp>
|
||||
iterator __insert_unique(const_iterator __p, _Vp&& __v);
|
||||
template <class _Vp>
|
||||
iterator __insert_multi(_Vp&& __v);
|
||||
template <class _Vp>
|
||||
iterator __insert_multi(const_iterator __p, _Vp&& __v);
|
||||
template <class _V>
|
||||
pair<iterator, bool> __insert_unique(_V&& __v);
|
||||
template <class _V>
|
||||
iterator __insert_unique(const_iterator __p, _V&& __v);
|
||||
template <class _V>
|
||||
iterator __insert_multi(_V&& __v);
|
||||
template <class _V>
|
||||
iterator __insert_multi(const_iterator __p, _V&& __v);
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
pair<iterator, bool> __insert_unique(const value_type& __v);
|
||||
@@ -1021,8 +1019,8 @@ public:
|
||||
pair<const_iterator, const_iterator>
|
||||
__equal_range_multi(const _Key& __k) const;
|
||||
|
||||
typedef __tree_node_destructor<__node_allocator> _Dp;
|
||||
typedef unique_ptr<__node, _Dp> __node_holder;
|
||||
typedef __tree_node_destructor<__node_allocator> _D;
|
||||
typedef unique_ptr<__node, _D> __node_holder;
|
||||
|
||||
__node_holder remove(const_iterator __p) _NOEXCEPT;
|
||||
private:
|
||||
@@ -1711,7 +1709,7 @@ typename __tree<_Tp, _Compare, _Allocator>::__node_holder
|
||||
__tree<_Tp, _Compare, _Allocator>::__construct_node(_Args&& ...__args)
|
||||
{
|
||||
__node_allocator& __na = __node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::forward<_Args>(__args)...);
|
||||
__h.get_deleter().__value_constructed = true;
|
||||
return __h;
|
||||
@@ -1781,11 +1779,11 @@ __tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p,
|
||||
#endif // _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class _Tp, class _Compare, class _Allocator>
|
||||
template <class _Vp>
|
||||
template <class _V>
|
||||
pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
|
||||
__tree<_Tp, _Compare, _Allocator>::__insert_unique(_Vp&& __v)
|
||||
__tree<_Tp, _Compare, _Allocator>::__insert_unique(_V&& __v)
|
||||
{
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_Vp>(__v));
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_V>(__v));
|
||||
pair<iterator, bool> __r = __node_insert_unique(__h.get());
|
||||
if (__r.second)
|
||||
__h.release();
|
||||
@@ -1793,11 +1791,11 @@ __tree<_Tp, _Compare, _Allocator>::__insert_unique(_Vp&& __v)
|
||||
}
|
||||
|
||||
template <class _Tp, class _Compare, class _Allocator>
|
||||
template <class _Vp>
|
||||
template <class _V>
|
||||
typename __tree<_Tp, _Compare, _Allocator>::iterator
|
||||
__tree<_Tp, _Compare, _Allocator>::__insert_unique(const_iterator __p, _Vp&& __v)
|
||||
__tree<_Tp, _Compare, _Allocator>::__insert_unique(const_iterator __p, _V&& __v)
|
||||
{
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_Vp>(__v));
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_V>(__v));
|
||||
iterator __r = __node_insert_unique(__p, __h.get());
|
||||
if (__r.__ptr_ == __h.get())
|
||||
__h.release();
|
||||
@@ -1805,11 +1803,11 @@ __tree<_Tp, _Compare, _Allocator>::__insert_unique(const_iterator __p, _Vp&& __v
|
||||
}
|
||||
|
||||
template <class _Tp, class _Compare, class _Allocator>
|
||||
template <class _Vp>
|
||||
template <class _V>
|
||||
typename __tree<_Tp, _Compare, _Allocator>::iterator
|
||||
__tree<_Tp, _Compare, _Allocator>::__insert_multi(_Vp&& __v)
|
||||
__tree<_Tp, _Compare, _Allocator>::__insert_multi(_V&& __v)
|
||||
{
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_Vp>(__v));
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_V>(__v));
|
||||
__node_base_pointer __parent;
|
||||
__node_base_pointer& __child = __find_leaf_high(__parent, __h->__value_);
|
||||
__insert_node_at(__parent, __child, __h.get());
|
||||
@@ -1817,11 +1815,11 @@ __tree<_Tp, _Compare, _Allocator>::__insert_multi(_Vp&& __v)
|
||||
}
|
||||
|
||||
template <class _Tp, class _Compare, class _Allocator>
|
||||
template <class _Vp>
|
||||
template <class _V>
|
||||
typename __tree<_Tp, _Compare, _Allocator>::iterator
|
||||
__tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, _Vp&& __v)
|
||||
__tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, _V&& __v)
|
||||
{
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_Vp>(__v));
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_V>(__v));
|
||||
__node_base_pointer __parent;
|
||||
__node_base_pointer& __child = __find_leaf(__p, __parent, __h->__value_);
|
||||
__insert_node_at(__parent, __child, __h.get());
|
||||
@@ -1835,7 +1833,7 @@ typename __tree<_Tp, _Compare, _Allocator>::__node_holder
|
||||
__tree<_Tp, _Compare, _Allocator>::__construct_node(const value_type& __v)
|
||||
{
|
||||
__node_allocator& __na = __node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_), __v);
|
||||
__h.get_deleter().__value_constructed = true;
|
||||
return _VSTD::move(__h);
|
||||
@@ -2053,7 +2051,7 @@ template <class _Key>
|
||||
typename __tree<_Tp, _Compare, _Allocator>::size_type
|
||||
__tree<_Tp, _Compare, _Allocator>::__count_multi(const _Key& __k) const
|
||||
{
|
||||
typedef pair<const_iterator, const_iterator> _Pp;
|
||||
typedef pair<const_iterator, const_iterator> _P;
|
||||
__node_const_pointer __result = __end_node();
|
||||
__node_const_pointer __rt = __root();
|
||||
while (__rt != nullptr)
|
||||
@@ -2160,7 +2158,7 @@ pair<typename __tree<_Tp, _Compare, _Allocator>::iterator,
|
||||
typename __tree<_Tp, _Compare, _Allocator>::iterator>
|
||||
__tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k)
|
||||
{
|
||||
typedef pair<iterator, iterator> _Pp;
|
||||
typedef pair<iterator, iterator> _P;
|
||||
__node_pointer __result = __end_node();
|
||||
__node_pointer __rt = __root();
|
||||
while (__rt != nullptr)
|
||||
@@ -2173,13 +2171,13 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k)
|
||||
else if (value_comp()(__rt->__value_, __k))
|
||||
__rt = static_cast<__node_pointer>(__rt->__right_);
|
||||
else
|
||||
return _Pp(iterator(__rt),
|
||||
return _P(iterator(__rt),
|
||||
iterator(
|
||||
__rt->__right_ != nullptr ?
|
||||
static_cast<__node_pointer>(__tree_min(__rt->__right_))
|
||||
: __result));
|
||||
}
|
||||
return _Pp(iterator(__result), iterator(__result));
|
||||
return _P(iterator(__result), iterator(__result));
|
||||
}
|
||||
|
||||
template <class _Tp, class _Compare, class _Allocator>
|
||||
@@ -2188,7 +2186,7 @@ pair<typename __tree<_Tp, _Compare, _Allocator>::const_iterator,
|
||||
typename __tree<_Tp, _Compare, _Allocator>::const_iterator>
|
||||
__tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) const
|
||||
{
|
||||
typedef pair<const_iterator, const_iterator> _Pp;
|
||||
typedef pair<const_iterator, const_iterator> _P;
|
||||
__node_const_pointer __result = __end_node();
|
||||
__node_const_pointer __rt = __root();
|
||||
while (__rt != nullptr)
|
||||
@@ -2201,13 +2199,13 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) const
|
||||
else if (value_comp()(__rt->__value_, __k))
|
||||
__rt = static_cast<__node_const_pointer>(__rt->__right_);
|
||||
else
|
||||
return _Pp(const_iterator(__rt),
|
||||
return _P(const_iterator(__rt),
|
||||
const_iterator(
|
||||
__rt->__right_ != nullptr ?
|
||||
static_cast<__node_const_pointer>(__tree_min(__rt->__right_))
|
||||
: __result));
|
||||
}
|
||||
return _Pp(const_iterator(__result), const_iterator(__result));
|
||||
return _P(const_iterator(__result), const_iterator(__result));
|
||||
}
|
||||
|
||||
template <class _Tp, class _Compare, class _Allocator>
|
||||
@@ -2216,7 +2214,7 @@ pair<typename __tree<_Tp, _Compare, _Allocator>::iterator,
|
||||
typename __tree<_Tp, _Compare, _Allocator>::iterator>
|
||||
__tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k)
|
||||
{
|
||||
typedef pair<iterator, iterator> _Pp;
|
||||
typedef pair<iterator, iterator> _P;
|
||||
__node_pointer __result = __end_node();
|
||||
__node_pointer __rt = __root();
|
||||
while (__rt != nullptr)
|
||||
@@ -2229,10 +2227,10 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k)
|
||||
else if (value_comp()(__rt->__value_, __k))
|
||||
__rt = static_cast<__node_pointer>(__rt->__right_);
|
||||
else
|
||||
return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), __rt),
|
||||
return _P(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), __rt),
|
||||
__upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));
|
||||
}
|
||||
return _Pp(iterator(__result), iterator(__result));
|
||||
return _P(iterator(__result), iterator(__result));
|
||||
}
|
||||
|
||||
template <class _Tp, class _Compare, class _Allocator>
|
||||
@@ -2241,7 +2239,7 @@ pair<typename __tree<_Tp, _Compare, _Allocator>::const_iterator,
|
||||
typename __tree<_Tp, _Compare, _Allocator>::const_iterator>
|
||||
__tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) const
|
||||
{
|
||||
typedef pair<const_iterator, const_iterator> _Pp;
|
||||
typedef pair<const_iterator, const_iterator> _P;
|
||||
__node_const_pointer __result = __end_node();
|
||||
__node_const_pointer __rt = __root();
|
||||
while (__rt != nullptr)
|
||||
@@ -2254,10 +2252,10 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) const
|
||||
else if (value_comp()(__rt->__value_, __k))
|
||||
__rt = static_cast<__node_const_pointer>(__rt->__right_);
|
||||
else
|
||||
return _Pp(__lower_bound(__k, static_cast<__node_const_pointer>(__rt->__left_), __rt),
|
||||
return _P(__lower_bound(__k, static_cast<__node_const_pointer>(__rt->__left_), __rt),
|
||||
__upper_bound(__k, static_cast<__node_const_pointer>(__rt->__right_), __result));
|
||||
}
|
||||
return _Pp(const_iterator(__result), const_iterator(__result));
|
||||
return _P(const_iterator(__result), const_iterator(__result));
|
||||
}
|
||||
|
||||
template <class _Tp, class _Compare, class _Allocator>
|
||||
@@ -2275,7 +2273,7 @@ __tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p) _NOEXCEPT
|
||||
--size();
|
||||
__tree_remove(__end_node()->__left_,
|
||||
static_cast<__node_base_pointer>(__np));
|
||||
return __node_holder(__np, _Dp(__node_alloc()));
|
||||
return __node_holder(__np, _D(__node_alloc()));
|
||||
}
|
||||
|
||||
template <class _Tp, class _Compare, class _Allocator>
|
||||
|
||||
@@ -15,9 +15,7 @@
|
||||
#include <cstddef>
|
||||
#include <type_traits>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#ifdef _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
@@ -65,7 +63,7 @@ public:
|
||||
};
|
||||
|
||||
template <class ..._Tp> class _LIBCPP_VISIBLE tuple;
|
||||
template <class _T1, class _T2> struct _LIBCPP_VISIBLE pair;
|
||||
template <class _T1, class _T2> class _LIBCPP_VISIBLE pair;
|
||||
template <class _Tp, size_t _Size> struct _LIBCPP_VISIBLE array;
|
||||
|
||||
template <class _Tp> struct __tuple_like : false_type {};
|
||||
@@ -79,47 +77,38 @@ template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type
|
||||
template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
|
||||
|
||||
template <size_t _Ip, class ..._Tp>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
typename tuple_element<_Ip, tuple<_Tp...> >::type&
|
||||
get(tuple<_Tp...>&) _NOEXCEPT;
|
||||
|
||||
template <size_t _Ip, class ..._Tp>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const typename tuple_element<_Ip, tuple<_Tp...> >::type&
|
||||
get(const tuple<_Tp...>&) _NOEXCEPT;
|
||||
|
||||
template <size_t _Ip, class ..._Tp>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
typename tuple_element<_Ip, tuple<_Tp...> >::type&&
|
||||
get(tuple<_Tp...>&&) _NOEXCEPT;
|
||||
|
||||
template <size_t _Ip, class _T1, class _T2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
typename tuple_element<_Ip, pair<_T1, _T2> >::type&
|
||||
get(pair<_T1, _T2>&) _NOEXCEPT;
|
||||
|
||||
template <size_t _Ip, class _T1, class _T2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
|
||||
get(const pair<_T1, _T2>&) _NOEXCEPT;
|
||||
|
||||
template <size_t _Ip, class _T1, class _T2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
|
||||
get(pair<_T1, _T2>&&) _NOEXCEPT;
|
||||
|
||||
template <size_t _Ip, class _Tp, size_t _Size>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_Tp&
|
||||
get(array<_Tp, _Size>&) _NOEXCEPT;
|
||||
|
||||
template <size_t _Ip, class _Tp, size_t _Size>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const _Tp&
|
||||
get(const array<_Tp, _Size>&) _NOEXCEPT;
|
||||
|
||||
template <size_t _Ip, class _Tp, size_t _Size>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_Tp&&
|
||||
get(array<_Tp, _Size>&&) _NOEXCEPT;
|
||||
|
||||
@@ -225,7 +214,7 @@ struct __tuple_convertible_imp : public false_type {};
|
||||
template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
|
||||
struct __tuple_convertible_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
|
||||
: public integral_constant<bool,
|
||||
is_convertible<_Tp0, _Up0>::value &&
|
||||
is_constructible<_Up0, _Tp0>::value &&
|
||||
__tuple_convertible_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
|
||||
|
||||
template <>
|
||||
@@ -244,33 +233,6 @@ struct __tuple_convertible<_Tp, _Up, true, true>
|
||||
typename __make_tuple_types<_Tp>::type, typename __make_tuple_types<_Up>::type>
|
||||
{};
|
||||
|
||||
// __tuple_constructible
|
||||
|
||||
template <bool, class _Tp, class _Up>
|
||||
struct __tuple_constructible_imp : public false_type {};
|
||||
|
||||
template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
|
||||
struct __tuple_constructible_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
|
||||
: public integral_constant<bool,
|
||||
is_constructible<_Up0, _Tp0>::value &&
|
||||
__tuple_constructible_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
|
||||
|
||||
template <>
|
||||
struct __tuple_constructible_imp<true, __tuple_types<>, __tuple_types<> >
|
||||
: public true_type {};
|
||||
|
||||
template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
|
||||
bool = __tuple_like<_Up>::value>
|
||||
struct __tuple_constructible
|
||||
: public false_type {};
|
||||
|
||||
template <class _Tp, class _Up>
|
||||
struct __tuple_constructible<_Tp, _Up, true, true>
|
||||
: public __tuple_constructible_imp<tuple_size<typename remove_reference<_Tp>::type>::value ==
|
||||
tuple_size<_Up>::value,
|
||||
typename __make_tuple_types<_Tp>::type, typename __make_tuple_types<_Up>::type>
|
||||
{};
|
||||
|
||||
// __tuple_assignable
|
||||
|
||||
template <bool, class _Tp, class _Up>
|
||||
|
||||
@@ -13,9 +13,7 @@
|
||||
|
||||
#include <__config>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
@@ -1,19 +0,0 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is dual licensed under the MIT and the University of Illinois Open
|
||||
// Source Licenses. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifdef min
|
||||
#warning: macro min is incompatible with C++. #undefing min
|
||||
#undef min
|
||||
#endif
|
||||
|
||||
#ifdef max
|
||||
#warning: macro max is incompatible with C++. #undefing max
|
||||
#undef max
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -55,7 +55,7 @@ struct array
|
||||
// capacity:
|
||||
constexpr size_type size() const noexcept;
|
||||
constexpr size_type max_size() const noexcept;
|
||||
constexpr bool empty() const noexcept;
|
||||
bool empty() const noexcept;
|
||||
|
||||
// element access:
|
||||
reference operator[](size_type n);
|
||||
@@ -111,9 +111,7 @@ template <int I, class T, size_t N> T&& get(array<T, N>&&) noexcept;
|
||||
#include <cassert>
|
||||
#endif
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -173,11 +171,11 @@ struct _LIBCPP_VISIBLE array
|
||||
|
||||
// capacity:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT {return _Size;}
|
||||
/*constexpr*/ size_type size() const _NOEXCEPT {return _Size;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return _Size;}
|
||||
/*constexpr*/ size_type max_size() const _NOEXCEPT {return _Size;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return _Size == 0;}
|
||||
bool empty() const _NOEXCEPT {return _Size == 0;}
|
||||
|
||||
// element access:
|
||||
_LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n) {return __elems_[__n];}
|
||||
|
||||
724
include/atomic
724
include/atomic
File diff suppressed because it is too large
Load Diff
@@ -113,9 +113,7 @@ template <size_t N> struct hash<std::bitset<N>>;
|
||||
|
||||
*/
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#include <__config>
|
||||
#include <__bit_reference>
|
||||
@@ -129,8 +127,6 @@ template <size_t N> struct hash<std::bitset<N>>;
|
||||
#include <cassert>
|
||||
#endif
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <size_t _N_words, size_t _Size>
|
||||
@@ -148,9 +144,9 @@ class __bitset
|
||||
public:
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef size_t size_type;
|
||||
typedef size_type __storage_type;
|
||||
protected:
|
||||
typedef __bitset __self;
|
||||
typedef size_type __storage_type;
|
||||
typedef __storage_type* __storage_pointer;
|
||||
typedef const __storage_type* __const_storage_pointer;
|
||||
static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
|
||||
@@ -159,7 +155,7 @@ protected:
|
||||
friend class __bit_const_reference<__bitset>;
|
||||
friend class __bit_iterator<__bitset, false>;
|
||||
friend class __bit_iterator<__bitset, true>;
|
||||
friend struct __bit_array<__bitset>;
|
||||
friend class __bit_array<__bitset>;
|
||||
|
||||
__storage_type __first_[_N_words];
|
||||
|
||||
@@ -168,12 +164,12 @@ protected:
|
||||
typedef __bit_iterator<__bitset, false> iterator;
|
||||
typedef __bit_iterator<__bitset, true> const_iterator;
|
||||
|
||||
_LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
|
||||
explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long __v) _NOEXCEPT;
|
||||
__bitset() _NOEXCEPT;
|
||||
explicit __bitset(unsigned long long __v) _NOEXCEPT;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos) _NOEXCEPT
|
||||
{return reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __make_ref(size_t __pos) const _NOEXCEPT
|
||||
_LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t __pos) const _NOEXCEPT
|
||||
{return const_reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
|
||||
_LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos) _NOEXCEPT
|
||||
{return iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
|
||||
@@ -194,10 +190,8 @@ protected:
|
||||
bool any() const _NOEXCEPT;
|
||||
size_t __hash_code() const _NOEXCEPT;
|
||||
private:
|
||||
#ifdef _LIBCPP_HAS_NO_CONSTEXPR
|
||||
void __init(unsigned long long __v, false_type) _NOEXCEPT;
|
||||
void __init(unsigned long long __v, true_type) _NOEXCEPT;
|
||||
#endif // _LIBCPP_HAS_NO_CONSTEXPR
|
||||
unsigned long to_ulong(false_type) const;
|
||||
unsigned long to_ulong(true_type) const;
|
||||
unsigned long long to_ullong(false_type) const;
|
||||
@@ -208,22 +202,14 @@ private:
|
||||
|
||||
template <size_t _N_words, size_t _Size>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
__bitset<_N_words, _Size>::__bitset() _NOEXCEPT
|
||||
#ifndef _LIBCPP_HAS_NO_CONSTEXPR
|
||||
: __first_{0}
|
||||
#endif
|
||||
{
|
||||
#ifdef _LIBCPP_HAS_NO_CONSTEXPR
|
||||
_VSTD::fill_n(__first_, _N_words, __storage_type(0));
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef _LIBCPP_HAS_NO_CONSTEXPR
|
||||
|
||||
template <size_t _N_words, size_t _Size>
|
||||
void
|
||||
__bitset<_N_words, _Size>::__init(unsigned long long __v, false_type) _NOEXCEPT
|
||||
__bitset<_N_words, _Size>::__init(unsigned long long __v, false_type)
|
||||
{
|
||||
__storage_type __t[sizeof(unsigned long long) / sizeof(__storage_type)];
|
||||
for (size_t __i = 0; __i < sizeof(__t)/sizeof(__t[0]); ++__i, __v >>= __bits_per_word)
|
||||
@@ -236,25 +222,17 @@ __bitset<_N_words, _Size>::__init(unsigned long long __v, false_type) _NOEXCEPT
|
||||
template <size_t _N_words, size_t _Size>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
void
|
||||
__bitset<_N_words, _Size>::__init(unsigned long long __v, true_type) _NOEXCEPT
|
||||
__bitset<_N_words, _Size>::__init(unsigned long long __v, true_type)
|
||||
{
|
||||
__first_[0] = __v;
|
||||
_VSTD::fill(__first_ + 1, __first_ + sizeof(__first_)/sizeof(__first_[0]), __storage_type(0));
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_CONSTEXPR
|
||||
|
||||
template <size_t _N_words, size_t _Size>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
__bitset<_N_words, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
|
||||
#ifndef _LIBCPP_HAS_NO_CONSTEXPR
|
||||
: __first_{__v}
|
||||
#endif
|
||||
{
|
||||
#ifdef _LIBCPP_HAS_NO_CONSTEXPR
|
||||
__init(__v, integral_constant<bool, sizeof(unsigned long long) == sizeof(__storage_type)>());
|
||||
#endif
|
||||
}
|
||||
|
||||
template <size_t _N_words, size_t _Size>
|
||||
@@ -424,9 +402,9 @@ class __bitset<1, _Size>
|
||||
public:
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef size_t size_type;
|
||||
typedef size_type __storage_type;
|
||||
protected:
|
||||
typedef __bitset __self;
|
||||
typedef size_type __storage_type;
|
||||
typedef __storage_type* __storage_pointer;
|
||||
typedef const __storage_type* __const_storage_pointer;
|
||||
static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
|
||||
@@ -435,7 +413,7 @@ protected:
|
||||
friend class __bit_const_reference<__bitset>;
|
||||
friend class __bit_iterator<__bitset, false>;
|
||||
friend class __bit_iterator<__bitset, true>;
|
||||
friend struct __bit_array<__bitset>;
|
||||
friend class __bit_array<__bitset>;
|
||||
|
||||
__storage_type __first_;
|
||||
|
||||
@@ -444,12 +422,12 @@ protected:
|
||||
typedef __bit_iterator<__bitset, false> iterator;
|
||||
typedef __bit_iterator<__bitset, true> const_iterator;
|
||||
|
||||
_LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
|
||||
explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long __v) _NOEXCEPT;
|
||||
__bitset() _NOEXCEPT;
|
||||
explicit __bitset(unsigned long long __v) _NOEXCEPT;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos) _NOEXCEPT
|
||||
{return reference(&__first_, __storage_type(1) << __pos);}
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __make_ref(size_t __pos) const _NOEXCEPT
|
||||
_LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t __pos) const _NOEXCEPT
|
||||
{return const_reference(&__first_, __storage_type(1) << __pos);}
|
||||
_LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos) _NOEXCEPT
|
||||
{return iterator(&__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
|
||||
@@ -473,7 +451,6 @@ protected:
|
||||
|
||||
template <size_t _Size>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
__bitset<1, _Size>::__bitset() _NOEXCEPT
|
||||
: __first_(0)
|
||||
{
|
||||
@@ -481,7 +458,6 @@ __bitset<1, _Size>::__bitset() _NOEXCEPT
|
||||
|
||||
template <size_t _Size>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
__bitset<1, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
|
||||
: __first_(static_cast<__storage_type>(__v))
|
||||
{
|
||||
@@ -569,9 +545,9 @@ class __bitset<0, 0>
|
||||
public:
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef size_t size_type;
|
||||
typedef size_type __storage_type;
|
||||
protected:
|
||||
typedef __bitset __self;
|
||||
typedef size_type __storage_type;
|
||||
typedef __storage_type* __storage_pointer;
|
||||
typedef const __storage_type* __const_storage_pointer;
|
||||
static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
|
||||
@@ -580,23 +556,23 @@ protected:
|
||||
friend class __bit_const_reference<__bitset>;
|
||||
friend class __bit_iterator<__bitset, false>;
|
||||
friend class __bit_iterator<__bitset, true>;
|
||||
friend struct __bit_array<__bitset>;
|
||||
friend class __bit_array<__bitset>;
|
||||
|
||||
typedef __bit_reference<__bitset> reference;
|
||||
typedef __bit_const_reference<__bitset> const_reference;
|
||||
typedef __bit_iterator<__bitset, false> iterator;
|
||||
typedef __bit_iterator<__bitset, true> const_iterator;
|
||||
|
||||
_LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
|
||||
explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long) _NOEXCEPT;
|
||||
__bitset() _NOEXCEPT;
|
||||
explicit __bitset(unsigned long long) _NOEXCEPT;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t) _NOEXCEPT
|
||||
{return reference(0, 1);}
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __make_ref(size_t) const _NOEXCEPT
|
||||
_LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t) const _NOEXCEPT
|
||||
{return const_reference(0, 1);}
|
||||
_LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t) _NOEXCEPT
|
||||
_LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos) _NOEXCEPT
|
||||
{return iterator(0, 0);}
|
||||
_LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t) const _NOEXCEPT
|
||||
_LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const _NOEXCEPT
|
||||
{return const_iterator(0, 0);}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY void operator&=(const __bitset&) _NOEXCEPT {}
|
||||
@@ -615,18 +591,16 @@ protected:
|
||||
};
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
__bitset<0, 0>::__bitset() _NOEXCEPT
|
||||
{
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
__bitset<0, 0>::__bitset(unsigned long long) _NOEXCEPT
|
||||
{
|
||||
}
|
||||
|
||||
template <size_t _Size> class _LIBCPP_VISIBLE bitset;
|
||||
template <size_t _Size> class bitset;
|
||||
template <size_t _Size> struct hash<bitset<_Size> >;
|
||||
|
||||
template <size_t _Size>
|
||||
@@ -641,9 +615,8 @@ public:
|
||||
typedef typename base::const_reference const_reference;
|
||||
|
||||
// 23.3.5.1 constructors:
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR bitset() _NOEXCEPT {}
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
|
||||
bitset(unsigned long long __v) _NOEXCEPT : base(__v) {}
|
||||
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY bitset() _NOEXCEPT {}
|
||||
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY bitset(unsigned long long __v) _NOEXCEPT : base(__v) {}
|
||||
template<class _CharT>
|
||||
explicit bitset(const _CharT* __str,
|
||||
typename basic_string<_CharT>::size_type __n = basic_string<_CharT>::npos,
|
||||
@@ -670,8 +643,7 @@ public:
|
||||
bitset& flip(size_t __pos);
|
||||
|
||||
// element access:
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
|
||||
const_reference operator[](size_t __p) const {return base::__make_ref(__p);}
|
||||
_LIBCPP_INLINE_VISIBILITY const_reference operator[](size_t __p) const {return base::__make_ref(__p);}
|
||||
_LIBCPP_INLINE_VISIBILITY reference operator[](size_t __p) {return base::__make_ref(__p);}
|
||||
unsigned long to_ulong() const;
|
||||
unsigned long long to_ullong() const;
|
||||
@@ -687,7 +659,7 @@ public:
|
||||
basic_string<char, char_traits<char>, allocator<char> > to_string(char __zero = '0',
|
||||
char __one = '1') const;
|
||||
size_t count() const _NOEXCEPT;
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR size_t size() const _NOEXCEPT {return _Size;}
|
||||
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY size_t size() const _NOEXCEPT {return _Size;}
|
||||
bool operator==(const bitset& __rhs) const _NOEXCEPT;
|
||||
bool operator!=(const bitset& __rhs) const _NOEXCEPT;
|
||||
bool test(size_t __pos) const;
|
||||
@@ -719,11 +691,11 @@ bitset<_Size>::bitset(const _CharT* __str,
|
||||
#else
|
||||
assert(!"bitset string ctor has invalid argument");
|
||||
#endif
|
||||
size_t _Mp = _VSTD::min(__rlen, _Size);
|
||||
size_t _M = _VSTD::min(__rlen, _Size);
|
||||
size_t __i = 0;
|
||||
for (; __i < _Mp; ++__i)
|
||||
for (; __i < _M; ++__i)
|
||||
{
|
||||
_CharT __c = __str[_Mp - 1 - __i];
|
||||
_CharT __c = __str[_M - 1 - __i];
|
||||
if (__c == __zero)
|
||||
(*this)[__i] = false;
|
||||
else
|
||||
@@ -753,11 +725,11 @@ bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
|
||||
#else
|
||||
assert(!"bitset string ctor has invalid argument");
|
||||
#endif
|
||||
size_t _Mp = _VSTD::min(__rlen, _Size);
|
||||
size_t _M = _VSTD::min(__rlen, _Size);
|
||||
size_t __i = 0;
|
||||
for (; __i < _Mp; ++__i)
|
||||
for (; __i < _M; ++__i)
|
||||
{
|
||||
_CharT __c = __str[__pos + _Mp - 1 - __i];
|
||||
_CharT __c = __str[__pos + _M - 1 - __i];
|
||||
if (_Traits::eq(__c, __zero))
|
||||
(*this)[__i] = false;
|
||||
else
|
||||
@@ -1061,14 +1033,6 @@ struct _LIBCPP_VISIBLE hash<bitset<_Size> >
|
||||
{return __bs.__hash_code();}
|
||||
};
|
||||
|
||||
template <class _CharT, class _Traits, size_t _Size>
|
||||
basic_istream<_CharT, _Traits>&
|
||||
operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x);
|
||||
|
||||
template <class _CharT, class _Traits, size_t _Size>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x);
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
#endif // _LIBCPP_BITSET
|
||||
|
||||
@@ -20,6 +20,4 @@ Macros:
|
||||
#include <__config>
|
||||
#include <assert.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
@@ -20,9 +20,7 @@
|
||||
|
||||
#include <complex>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
// hh 080623 Created
|
||||
|
||||
|
||||
@@ -37,13 +37,8 @@ int toupper(int c);
|
||||
|
||||
#include <__config>
|
||||
#include <ctype.h>
|
||||
#if defined(_MSC_VER)
|
||||
#include "support/win32/support.h"
|
||||
#endif // _MSC_VER
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
318
include/cerrno
318
include/cerrno
@@ -26,9 +26,7 @@ Macros:
|
||||
#include <__config>
|
||||
#include <errno.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#if !defined(EOWNERDEAD) || !defined(ENOTRECOVERABLE)
|
||||
|
||||
@@ -74,320 +72,4 @@ const int __elast2 = 105;
|
||||
|
||||
#endif // !defined(EOWNERDEAD) || !defined(ENOTRECOVERABLE)
|
||||
|
||||
// supply errno values likely to be missing, particularly on Windows
|
||||
|
||||
#ifndef EAFNOSUPPORT
|
||||
#define EAFNOSUPPORT 9901
|
||||
#endif
|
||||
|
||||
#ifndef EADDRINUSE
|
||||
#define EADDRINUSE 9902
|
||||
#endif
|
||||
|
||||
#ifndef EADDRNOTAVAIL
|
||||
#define EADDRNOTAVAIL 9903
|
||||
#endif
|
||||
|
||||
#ifndef EISCONN
|
||||
#define EISCONN 9904
|
||||
#endif
|
||||
|
||||
#ifndef EBADMSG
|
||||
#define EBADMSG 9905
|
||||
#endif
|
||||
|
||||
#ifndef ECONNABORTED
|
||||
#define ECONNABORTED 9906
|
||||
#endif
|
||||
|
||||
#ifndef EALREADY
|
||||
#define EALREADY 9907
|
||||
#endif
|
||||
|
||||
#ifndef ECONNREFUSED
|
||||
#define ECONNREFUSED 9908
|
||||
#endif
|
||||
|
||||
#ifndef ECONNRESET
|
||||
#define ECONNRESET 9909
|
||||
#endif
|
||||
|
||||
#ifndef EDESTADDRREQ
|
||||
#define EDESTADDRREQ 9910
|
||||
#endif
|
||||
|
||||
#ifndef EHOSTUNREACH
|
||||
#define EHOSTUNREACH 9911
|
||||
#endif
|
||||
|
||||
#ifndef EIDRM
|
||||
#define EIDRM 9912
|
||||
#endif
|
||||
|
||||
#ifndef EMSGSIZE
|
||||
#define EMSGSIZE 9913
|
||||
#endif
|
||||
|
||||
#ifndef ENETDOWN
|
||||
#define ENETDOWN 9914
|
||||
#endif
|
||||
|
||||
#ifndef ENETRESET
|
||||
#define ENETRESET 9915
|
||||
#endif
|
||||
|
||||
#ifndef ENETUNREACH
|
||||
#define ENETUNREACH 9916
|
||||
#endif
|
||||
|
||||
#ifndef ENOBUFS
|
||||
#define ENOBUFS 9917
|
||||
#endif
|
||||
|
||||
#ifndef ENOLINK
|
||||
#define ENOLINK 9918
|
||||
#endif
|
||||
|
||||
#ifndef ENODATA
|
||||
#define ENODATA 9919
|
||||
#endif
|
||||
|
||||
#ifndef ENOMSG
|
||||
#define ENOMSG 9920
|
||||
#endif
|
||||
|
||||
#ifndef ENOPROTOOPT
|
||||
#define ENOPROTOOPT 9921
|
||||
#endif
|
||||
|
||||
#ifndef ENOSR
|
||||
#define ENOSR 9922
|
||||
#endif
|
||||
|
||||
#ifndef ENOTSOCK
|
||||
#define ENOTSOCK 9923
|
||||
#endif
|
||||
|
||||
#ifndef ENOSTR
|
||||
#define ENOSTR 9924
|
||||
#endif
|
||||
|
||||
#ifndef ENOTCONN
|
||||
#define ENOTCONN 9925
|
||||
#endif
|
||||
|
||||
#ifndef ENOTSUP
|
||||
#define ENOTSUP 9926
|
||||
#endif
|
||||
|
||||
#ifndef ECANCELED
|
||||
#define ECANCELED 9927
|
||||
#endif
|
||||
|
||||
#ifndef EINPROGRESS
|
||||
#define EINPROGRESS 9928
|
||||
#endif
|
||||
|
||||
#ifndef EOPNOTSUPP
|
||||
#define EOPNOTSUPP 9929
|
||||
#endif
|
||||
|
||||
#ifndef EWOULDBLOCK
|
||||
#define EWOULDBLOCK 9930
|
||||
#endif
|
||||
|
||||
#ifndef EOWNERDEAD
|
||||
#define EOWNERDEAD 9931
|
||||
#endif
|
||||
|
||||
#ifndef EPROTO
|
||||
#define EPROTO 9932
|
||||
#endif
|
||||
|
||||
#ifndef EPROTONOSUPPORT
|
||||
#define EPROTONOSUPPORT 9933
|
||||
#endif
|
||||
|
||||
#ifndef ENOTRECOVERABLE
|
||||
#define ENOTRECOVERABLE 9934
|
||||
#endif
|
||||
|
||||
#ifndef ETIME
|
||||
#define ETIME 9935
|
||||
#endif
|
||||
|
||||
#ifndef ETXTBSY
|
||||
#define ETXTBSY 9936
|
||||
#endif
|
||||
|
||||
#ifndef ETIMEDOUT
|
||||
#define ETIMEDOUT 9938
|
||||
#endif
|
||||
|
||||
#ifndef ELOOP
|
||||
#define ELOOP 9939
|
||||
#endif
|
||||
|
||||
#ifndef EOVERFLOW
|
||||
#define EOVERFLOW 9940
|
||||
#endif
|
||||
|
||||
#ifndef EPROTOTYPE
|
||||
#define EPROTOTYPE 9941
|
||||
#endif
|
||||
|
||||
#ifndef ENOSYS
|
||||
#define ENOSYS 9942
|
||||
#endif
|
||||
|
||||
#ifndef EINVAL
|
||||
#define EINVAL 9943
|
||||
#endif
|
||||
|
||||
#ifndef ERANGE
|
||||
#define ERANGE 9944
|
||||
#endif
|
||||
|
||||
#ifndef EILSEQ
|
||||
#define EILSEQ 9945
|
||||
#endif
|
||||
|
||||
// Windows Mobile doesn't appear to define these:
|
||||
|
||||
#ifndef E2BIG
|
||||
#define E2BIG 9946
|
||||
#endif
|
||||
|
||||
#ifndef EDOM
|
||||
#define EDOM 9947
|
||||
#endif
|
||||
|
||||
#ifndef EFAULT
|
||||
#define EFAULT 9948
|
||||
#endif
|
||||
|
||||
#ifndef EBADF
|
||||
#define EBADF 9949
|
||||
#endif
|
||||
|
||||
#ifndef EPIPE
|
||||
#define EPIPE 9950
|
||||
#endif
|
||||
|
||||
#ifndef EXDEV
|
||||
#define EXDEV 9951
|
||||
#endif
|
||||
|
||||
#ifndef EBUSY
|
||||
#define EBUSY 9952
|
||||
#endif
|
||||
|
||||
#ifndef ENOTEMPTY
|
||||
#define ENOTEMPTY 9953
|
||||
#endif
|
||||
|
||||
#ifndef ENOEXEC
|
||||
#define ENOEXEC 9954
|
||||
#endif
|
||||
|
||||
#ifndef EEXIST
|
||||
#define EEXIST 9955
|
||||
#endif
|
||||
|
||||
#ifndef EFBIG
|
||||
#define EFBIG 9956
|
||||
#endif
|
||||
|
||||
#ifndef ENAMETOOLONG
|
||||
#define ENAMETOOLONG 9957
|
||||
#endif
|
||||
|
||||
#ifndef ENOTTY
|
||||
#define ENOTTY 9958
|
||||
#endif
|
||||
|
||||
#ifndef EINTR
|
||||
#define EINTR 9959
|
||||
#endif
|
||||
|
||||
#ifndef ESPIPE
|
||||
#define ESPIPE 9960
|
||||
#endif
|
||||
|
||||
#ifndef EIO
|
||||
#define EIO 9961
|
||||
#endif
|
||||
|
||||
#ifndef EISDIR
|
||||
#define EISDIR 9962
|
||||
#endif
|
||||
|
||||
#ifndef ECHILD
|
||||
#define ECHILD 9963
|
||||
#endif
|
||||
|
||||
#ifndef ENOLCK
|
||||
#define ENOLCK 9964
|
||||
#endif
|
||||
|
||||
#ifndef ENOSPC
|
||||
#define ENOSPC 9965
|
||||
#endif
|
||||
|
||||
#ifndef ENXIO
|
||||
#define ENXIO 9966
|
||||
#endif
|
||||
|
||||
#ifndef ENODEV
|
||||
#define ENODEV 9967
|
||||
#endif
|
||||
|
||||
#ifndef ENOENT
|
||||
#define ENOENT 9968
|
||||
#endif
|
||||
|
||||
#ifndef ESRCH
|
||||
#define ESRCH 9969
|
||||
#endif
|
||||
|
||||
#ifndef ENOTDIR
|
||||
#define ENOTDIR 9970
|
||||
#endif
|
||||
|
||||
#ifndef ENOMEM
|
||||
#define ENOMEM 9971
|
||||
#endif
|
||||
|
||||
#ifndef EPERM
|
||||
#define EPERM 9972
|
||||
#endif
|
||||
|
||||
#ifndef EACCES
|
||||
#define EACCES 9973
|
||||
#endif
|
||||
|
||||
#ifndef EROFS
|
||||
#define EROFS 9974
|
||||
#endif
|
||||
|
||||
#ifndef EDEADLK
|
||||
#define EDEADLK 9975
|
||||
#endif
|
||||
|
||||
#ifndef EAGAIN
|
||||
#define EAGAIN 9976
|
||||
#endif
|
||||
|
||||
#ifndef ENFILE
|
||||
#define ENFILE 9977
|
||||
#endif
|
||||
|
||||
#ifndef EMFILE
|
||||
#define EMFILE 9978
|
||||
#endif
|
||||
|
||||
#ifndef EMLINK
|
||||
#define EMLINK 9979
|
||||
#endif
|
||||
|
||||
#endif // _LIBCPP_CERRNO
|
||||
|
||||
@@ -56,9 +56,7 @@ int feupdateenv(const fenv_t* envp);
|
||||
#include <__config>
|
||||
#include <fenv.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
@@ -63,9 +63,7 @@ Macros:
|
||||
#include <__config>
|
||||
#include <float.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#ifndef FLT_EVAL_METHOD
|
||||
#define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
|
||||
|
||||
135
include/chrono
135
include/chrono
@@ -20,7 +20,6 @@ namespace chrono
|
||||
{
|
||||
|
||||
template <class ToDuration, class Rep, class Period>
|
||||
constexpr
|
||||
ToDuration
|
||||
duration_cast(const duration<Rep, Period>& fd);
|
||||
|
||||
@@ -30,9 +29,9 @@ template <class Rep>
|
||||
struct duration_values
|
||||
{
|
||||
public:
|
||||
static constexpr Rep zero();
|
||||
static constexpr Rep max();
|
||||
static constexpr Rep min();
|
||||
static Rep zero();
|
||||
static Rep max();
|
||||
static Rep min();
|
||||
};
|
||||
|
||||
// duration
|
||||
@@ -47,9 +46,9 @@ public:
|
||||
typedef Rep rep;
|
||||
typedef Period period;
|
||||
|
||||
constexpr duration() = default;
|
||||
duration() = default;
|
||||
template <class Rep2>
|
||||
constexpr explicit duration(const Rep2& r,
|
||||
explicit duration(const Rep2& r,
|
||||
typename enable_if
|
||||
<
|
||||
is_convertible<Rep2, rep>::value &&
|
||||
@@ -59,7 +58,7 @@ public:
|
||||
|
||||
// conversions
|
||||
template <class Rep2, class Period2>
|
||||
constexpr duration(const duration<Rep2, Period2>& d,
|
||||
duration(const duration<Rep2, Period2>& d,
|
||||
typename enable_if
|
||||
<
|
||||
treat_as_floating_point<rep>::value ||
|
||||
@@ -68,12 +67,12 @@ public:
|
||||
|
||||
// observer
|
||||
|
||||
constexpr rep count() const;
|
||||
rep count() const;
|
||||
|
||||
// arithmetic
|
||||
|
||||
constexpr duration operator+() const;
|
||||
constexpr duration operator-() const;
|
||||
duration operator+() const;
|
||||
duration operator-() const;
|
||||
duration& operator++();
|
||||
duration operator++(int);
|
||||
duration& operator--();
|
||||
@@ -87,9 +86,9 @@ public:
|
||||
|
||||
// special values
|
||||
|
||||
static constexpr duration zero();
|
||||
static constexpr duration min();
|
||||
static constexpr duration max();
|
||||
static duration zero();
|
||||
static duration min();
|
||||
static duration max();
|
||||
};
|
||||
|
||||
typedef duration<long long, nano> nanoseconds;
|
||||
@@ -146,48 +145,36 @@ namespace chrono {
|
||||
|
||||
// duration arithmetic
|
||||
template <class Rep1, class Period1, class Rep2, class Period2>
|
||||
constexpr
|
||||
typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
|
||||
operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
||||
template <class Rep1, class Period1, class Rep2, class Period2>
|
||||
constexpr
|
||||
typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
|
||||
operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
||||
template <class Rep1, class Period, class Rep2>
|
||||
constexpr
|
||||
duration<typename common_type<Rep1, Rep2>::type, Period>
|
||||
operator*(const duration<Rep1, Period>& d, const Rep2& s);
|
||||
template <class Rep1, class Period, class Rep2>
|
||||
constexpr
|
||||
duration<typename common_type<Rep1, Rep2>::type, Period>
|
||||
operator*(const Rep1& s, const duration<Rep2, Period>& d);
|
||||
template <class Rep1, class Period, class Rep2>
|
||||
constexpr
|
||||
duration<typename common_type<Rep1, Rep2>::type, Period>
|
||||
operator/(const duration<Rep1, Period>& d, const Rep2& s);
|
||||
template <class Rep1, class Period1, class Rep2, class Period2>
|
||||
constexpr
|
||||
typename common_type<Rep1, Rep2>::type
|
||||
operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
||||
|
||||
// duration comparisons
|
||||
template <class Rep1, class Period1, class Rep2, class Period2>
|
||||
constexpr
|
||||
bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
||||
template <class Rep1, class Period1, class Rep2, class Period2>
|
||||
constexpr
|
||||
bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
||||
template <class Rep1, class Period1, class Rep2, class Period2>
|
||||
constexpr
|
||||
bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
||||
template <class Rep1, class Period1, class Rep2, class Period2>
|
||||
constexpr
|
||||
bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
||||
template <class Rep1, class Period1, class Rep2, class Period2>
|
||||
constexpr
|
||||
bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
||||
template <class Rep1, class Period1, class Rep2, class Period2>
|
||||
constexpr
|
||||
bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
|
||||
|
||||
// duration_cast
|
||||
@@ -268,11 +255,7 @@ typedef steady_clock high_resolution_clock;
|
||||
#include <ratio>
|
||||
#include <limits>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -319,7 +302,7 @@ struct __duration_cast;
|
||||
template <class _FromDuration, class _ToDuration, class _Period>
|
||||
struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true>
|
||||
{
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_ToDuration operator()(const _FromDuration& __fd) const
|
||||
{
|
||||
return _ToDuration(static_cast<typename _ToDuration::rep>(__fd.count()));
|
||||
@@ -329,7 +312,7 @@ struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true>
|
||||
template <class _FromDuration, class _ToDuration, class _Period>
|
||||
struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false>
|
||||
{
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_ToDuration operator()(const _FromDuration& __fd) const
|
||||
{
|
||||
typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
|
||||
@@ -341,7 +324,7 @@ struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false>
|
||||
template <class _FromDuration, class _ToDuration, class _Period>
|
||||
struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true>
|
||||
{
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_ToDuration operator()(const _FromDuration& __fd) const
|
||||
{
|
||||
typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
|
||||
@@ -353,7 +336,7 @@ struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true>
|
||||
template <class _FromDuration, class _ToDuration, class _Period>
|
||||
struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false>
|
||||
{
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_ToDuration operator()(const _FromDuration& __fd) const
|
||||
{
|
||||
typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
|
||||
@@ -365,7 +348,6 @@ struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false>
|
||||
|
||||
template <class _ToDuration, class _Rep, class _Period>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
typename enable_if
|
||||
<
|
||||
__is_duration<_ToDuration>::value,
|
||||
@@ -383,9 +365,9 @@ template <class _Rep>
|
||||
struct _LIBCPP_VISIBLE duration_values
|
||||
{
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() {return _Rep(0);}
|
||||
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max() {return numeric_limits<_Rep>::max();}
|
||||
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min() {return numeric_limits<_Rep>::lowest();}
|
||||
_LIBCPP_INLINE_VISIBILITY static _Rep zero() {return _Rep(0);}
|
||||
_LIBCPP_INLINE_VISIBILITY static _Rep max() {return numeric_limits<_Rep>::max();}
|
||||
_LIBCPP_INLINE_VISIBILITY static _Rep min() {return numeric_limits<_Rep>::lowest();}
|
||||
};
|
||||
|
||||
// duration
|
||||
@@ -403,9 +385,9 @@ private:
|
||||
rep __rep_;
|
||||
public:
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR duration() {} // = default;
|
||||
_LIBCPP_INLINE_VISIBILITY duration() {} // = default;
|
||||
template <class _Rep2>
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit duration(const _Rep2& __r,
|
||||
typename enable_if
|
||||
<
|
||||
@@ -417,7 +399,7 @@ public:
|
||||
|
||||
// conversions
|
||||
template <class _Rep2, class _Period2>
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
duration(const duration<_Rep2, _Period2>& __d,
|
||||
typename enable_if
|
||||
<
|
||||
@@ -429,12 +411,12 @@ public:
|
||||
|
||||
// observer
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;}
|
||||
_LIBCPP_INLINE_VISIBILITY rep count() const {return __rep_;}
|
||||
|
||||
// arithmetic
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR duration operator+() const {return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR duration operator-() const {return duration(-__rep_);}
|
||||
_LIBCPP_INLINE_VISIBILITY duration operator+() const {return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY duration operator-() const {return duration(-__rep_);}
|
||||
_LIBCPP_INLINE_VISIBILITY duration& operator++() {++__rep_; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY duration operator++(int) {return duration(__rep_++);}
|
||||
_LIBCPP_INLINE_VISIBILITY duration& operator--() {--__rep_; return *this;}
|
||||
@@ -450,9 +432,9 @@ public:
|
||||
|
||||
// special values
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() {return duration(duration_values<rep>::zero());}
|
||||
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min() {return duration(duration_values<rep>::min());}
|
||||
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max() {return duration(duration_values<rep>::max());}
|
||||
_LIBCPP_INLINE_VISIBILITY static duration zero() {return duration(duration_values<rep>::zero());}
|
||||
_LIBCPP_INLINE_VISIBILITY static duration min() {return duration(duration_values<rep>::min());}
|
||||
_LIBCPP_INLINE_VISIBILITY static duration max() {return duration(duration_values<rep>::max());}
|
||||
};
|
||||
|
||||
typedef duration<long long, nano> nanoseconds;
|
||||
@@ -467,7 +449,7 @@ typedef duration< long, ratio<3600> > hours;
|
||||
template <class _LhsDuration, class _RhsDuration>
|
||||
struct __duration_eq
|
||||
{
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs)
|
||||
{
|
||||
typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
|
||||
@@ -478,14 +460,13 @@ struct __duration_eq
|
||||
template <class _LhsDuration>
|
||||
struct __duration_eq<_LhsDuration, _LhsDuration>
|
||||
{
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs)
|
||||
{return __lhs.count() == __rhs.count();}
|
||||
};
|
||||
|
||||
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
bool
|
||||
operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
||||
{
|
||||
@@ -496,7 +477,6 @@ operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period
|
||||
|
||||
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
bool
|
||||
operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
||||
{
|
||||
@@ -508,7 +488,7 @@ operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period
|
||||
template <class _LhsDuration, class _RhsDuration>
|
||||
struct __duration_lt
|
||||
{
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs)
|
||||
{
|
||||
typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
|
||||
@@ -519,14 +499,13 @@ struct __duration_lt
|
||||
template <class _LhsDuration>
|
||||
struct __duration_lt<_LhsDuration, _LhsDuration>
|
||||
{
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs)
|
||||
{return __lhs.count() < __rhs.count();}
|
||||
};
|
||||
|
||||
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
bool
|
||||
operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
||||
{
|
||||
@@ -537,7 +516,6 @@ operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period
|
||||
|
||||
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
bool
|
||||
operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
||||
{
|
||||
@@ -548,7 +526,6 @@ operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period
|
||||
|
||||
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
bool
|
||||
operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
||||
{
|
||||
@@ -559,7 +536,6 @@ operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period
|
||||
|
||||
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
bool
|
||||
operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
||||
{
|
||||
@@ -570,31 +546,30 @@ operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period
|
||||
|
||||
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
|
||||
operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
||||
{
|
||||
typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
|
||||
return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count());
|
||||
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type __r = __lhs;
|
||||
__r += __rhs;
|
||||
return __r;
|
||||
}
|
||||
|
||||
// Duration -
|
||||
|
||||
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
|
||||
operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
||||
{
|
||||
typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
|
||||
return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count());
|
||||
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type __r = __lhs;
|
||||
__r -= __rhs;
|
||||
return __r;
|
||||
}
|
||||
|
||||
// Duration *
|
||||
|
||||
template <class _Rep1, class _Period, class _Rep2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
typename enable_if
|
||||
<
|
||||
is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
|
||||
@@ -603,13 +578,13 @@ typename enable_if
|
||||
operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
|
||||
{
|
||||
typedef typename common_type<_Rep1, _Rep2>::type _Cr;
|
||||
typedef duration<_Cr, _Period> _Cd;
|
||||
return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s));
|
||||
duration<_Cr, _Period> __r = __d;
|
||||
__r *= static_cast<_Cr>(__s);
|
||||
return __r;
|
||||
}
|
||||
|
||||
template <class _Rep1, class _Period, class _Rep2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
typename enable_if
|
||||
<
|
||||
is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value,
|
||||
@@ -648,18 +623,17 @@ struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false>
|
||||
|
||||
template <class _Rep1, class _Period, class _Rep2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
|
||||
operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
|
||||
{
|
||||
typedef typename common_type<_Rep1, _Rep2>::type _Cr;
|
||||
typedef duration<_Cr, _Period> _Cd;
|
||||
return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s));
|
||||
duration<_Cr, _Period> __r = __d;
|
||||
__r /= static_cast<_Cr>(__s);
|
||||
return __r;
|
||||
}
|
||||
|
||||
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
typename common_type<_Rep1, _Rep2>::type
|
||||
operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
||||
{
|
||||
@@ -671,24 +645,23 @@ operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2
|
||||
|
||||
template <class _Rep1, class _Period, class _Rep2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
|
||||
operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
|
||||
{
|
||||
typedef typename common_type<_Rep1, _Rep2>::type _Cr;
|
||||
typedef duration<_Cr, _Period> _Cd;
|
||||
return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s));
|
||||
duration<_Cr, _Period> __r = __d;
|
||||
__r %= static_cast<_Cr>(__s);
|
||||
return __r;
|
||||
}
|
||||
|
||||
template <class _Rep1, class _Period1, class _Rep2, class _Period2>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
|
||||
operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
|
||||
{
|
||||
typedef typename common_type<_Rep1, _Rep2>::type _Cr;
|
||||
typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
|
||||
return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count()));
|
||||
typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type __r = __lhs;
|
||||
__r %= __rhs;
|
||||
return __r;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////
|
||||
@@ -728,13 +701,13 @@ public:
|
||||
|
||||
// arithmetic
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY time_point& operator+=(const duration& __d) {__d_ += __d; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY time_point& operator+=(const duration& __d) {__d_ += __d;}
|
||||
_LIBCPP_INLINE_VISIBILITY time_point& operator-=(const duration& __d) {__d_ -= __d;}
|
||||
|
||||
// special values
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() {return time_point(duration::min());}
|
||||
_LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() {return time_point(duration::max());}
|
||||
_LIBCPP_INLINE_VISIBILITY static time_point min() {return time_point(duration::min());}
|
||||
_LIBCPP_INLINE_VISIBILITY static time_point max() {return time_point(duration::max());}
|
||||
};
|
||||
|
||||
} // chrono
|
||||
|
||||
@@ -239,9 +239,7 @@ uintmax_t wcstoumax(const wchar_t* restrict nptr, wchar_t** restrict endptr, int
|
||||
#include <cstdint>
|
||||
#include <inttypes.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
@@ -18,8 +18,6 @@
|
||||
|
||||
#include <__config>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#endif // _LIBCPP_CISO646
|
||||
|
||||
@@ -41,8 +41,6 @@ Macros:
|
||||
#include <__config>
|
||||
#include <limits.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#endif // _LIBCPP_CLIMITS
|
||||
|
||||
@@ -38,9 +38,7 @@ lconv* localeconv();
|
||||
#include <__config>
|
||||
#include <locale.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
495
include/cmath
495
include/cmath
File diff suppressed because it is too large
Load Diff
@@ -55,9 +55,7 @@ class codecvt_utf8_utf16
|
||||
#include <__config>
|
||||
#include <__locale>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
@@ -249,9 +249,7 @@ template<class T, class charT, class traits>
|
||||
#include <cassert>
|
||||
#endif
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -282,8 +280,7 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
|
||||
_LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator= (const value_type& __re)
|
||||
{__re_ = __re; __im_ = value_type(); return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator= (const value_type& __re) {__re_ = __re; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator+=(const value_type& __re) {__re_ += __re; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator-=(const value_type& __re) {__re_ -= __re; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator*=(const value_type& __re) {__re_ *= __re; __im_ *= __re; return *this;}
|
||||
@@ -330,19 +327,18 @@ class _LIBCPP_VISIBLE complex<float>
|
||||
public:
|
||||
typedef float value_type;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(float __re = 0.0f, float __im = 0.0f)
|
||||
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY complex(float __re = 0.0f, float __im = 0.0f)
|
||||
: __re_(__re), __im_(__im) {}
|
||||
explicit _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
|
||||
explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
|
||||
explicit /*constexpr*/ complex(const complex<double>& __c);
|
||||
explicit /*constexpr*/ complex(const complex<long double>& __c);
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float real() const {return __re_;}
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float imag() const {return __im_;}
|
||||
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY float real() const {return __re_;}
|
||||
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY float imag() const {return __im_;}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
|
||||
_LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator= (float __re)
|
||||
{__re_ = __re; __im_ = value_type(); return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator= (float __re) {__re_ = __re; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator+=(float __re) {__re_ += __re; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator-=(float __re) {__re_ -= __re; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator*=(float __re) {__re_ *= __re; __im_ *= __re; return *this;}
|
||||
@@ -386,19 +382,18 @@ class _LIBCPP_VISIBLE complex<double>
|
||||
public:
|
||||
typedef double value_type;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(double __re = 0.0, double __im = 0.0)
|
||||
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY complex(double __re = 0.0, double __im = 0.0)
|
||||
: __re_(__re), __im_(__im) {}
|
||||
_LIBCPP_CONSTEXPR complex(const complex<float>& __c);
|
||||
explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
|
||||
/*constexpr*/ complex(const complex<float>& __c);
|
||||
explicit /*constexpr*/ complex(const complex<long double>& __c);
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double real() const {return __re_;}
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double imag() const {return __im_;}
|
||||
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY double real() const {return __re_;}
|
||||
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY double imag() const {return __im_;}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
|
||||
_LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator= (double __re)
|
||||
{__re_ = __re; __im_ = value_type(); return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator= (double __re) {__re_ = __re; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator+=(double __re) {__re_ += __re; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator-=(double __re) {__re_ -= __re; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator*=(double __re) {__re_ *= __re; __im_ *= __re; return *this;}
|
||||
@@ -442,19 +437,18 @@ class _LIBCPP_VISIBLE complex<long double>
|
||||
public:
|
||||
typedef long double value_type;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(long double __re = 0.0L, long double __im = 0.0L)
|
||||
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY complex(long double __re = 0.0L, long double __im = 0.0L)
|
||||
: __re_(__re), __im_(__im) {}
|
||||
_LIBCPP_CONSTEXPR complex(const complex<float>& __c);
|
||||
_LIBCPP_CONSTEXPR complex(const complex<double>& __c);
|
||||
/*constexpr*/ complex(const complex<float>& __c);
|
||||
/*constexpr*/ complex(const complex<double>& __c);
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double real() const {return __re_;}
|
||||
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double imag() const {return __im_;}
|
||||
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY long double real() const {return __re_;}
|
||||
/*constexpr*/ _LIBCPP_INLINE_VISIBILITY long double imag() const {return __im_;}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY void real(value_type __re) {__re_ = __re;}
|
||||
_LIBCPP_INLINE_VISIBILITY void imag(value_type __im) {__im_ = __im;}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator= (long double __re)
|
||||
{__re_ = __re; __im_ = value_type(); return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator= (long double __re) {__re_ = __re; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator+=(long double __re) {__re_ += __re; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator-=(long double __re) {__re_ -= __re; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY complex& operator*=(long double __re) {__re_ *= __re; __im_ *= __re; return *this;}
|
||||
@@ -490,33 +484,33 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
//constexpr
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
complex<float>::complex(const complex<double>& __c)
|
||||
: __re_(__c.real()), __im_(__c.imag()) {}
|
||||
|
||||
//constexpr
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
complex<float>::complex(const complex<long double>& __c)
|
||||
: __re_(__c.real()), __im_(__c.imag()) {}
|
||||
|
||||
//constexpr
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
complex<double>::complex(const complex<float>& __c)
|
||||
: __re_(__c.real()), __im_(__c.imag()) {}
|
||||
|
||||
//constexpr
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
complex<double>::complex(const complex<long double>& __c)
|
||||
: __re_(__c.real()), __im_(__c.imag()) {}
|
||||
|
||||
//constexpr
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
complex<long double>::complex(const complex<float>& __c)
|
||||
: __re_(__c.real()), __im_(__c.imag()) {}
|
||||
|
||||
//constexpr
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
complex<long double>::complex(const complex<double>& __c)
|
||||
: __re_(__c.real()), __im_(__c.imag()) {}
|
||||
|
||||
@@ -1249,12 +1243,10 @@ acosh(const complex<_Tp>& __x)
|
||||
if (isnan(__x.imag()))
|
||||
return complex<_Tp>(abs(__x.real()), __x.imag());
|
||||
if (isinf(__x.imag()))
|
||||
{
|
||||
if (__x.real() > 0)
|
||||
return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
|
||||
else
|
||||
return complex<_Tp>(-__x.real(), copysign(__pi * _Tp(0.75), __x.imag()));
|
||||
}
|
||||
if (__x.real() < 0)
|
||||
return complex<_Tp>(-__x.real(), copysign(__pi, __x.imag()));
|
||||
return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
|
||||
@@ -1353,11 +1345,7 @@ tanh(const complex<_Tp>& __x)
|
||||
_Tp __2r(_Tp(2) * __x.real());
|
||||
_Tp __2i(_Tp(2) * __x.imag());
|
||||
_Tp __d(cosh(__2r) + cos(__2i));
|
||||
_Tp __2rsh(sinh(__2r));
|
||||
if (isinf(__2rsh) && isinf(__d))
|
||||
return complex<_Tp>(__2rsh > _Tp(0) ? _Tp(1) : _Tp(-1),
|
||||
__2i > _Tp(0) ? _Tp(0) : _Tp(-0.));
|
||||
return complex<_Tp>(__2rsh/__d, sin(__2i)/__d);
|
||||
return complex<_Tp>(sinh(__2r)/__d, sin(__2i)/__d);
|
||||
}
|
||||
|
||||
// asin
|
||||
|
||||
@@ -28,8 +28,6 @@
|
||||
|
||||
#endif // __cplusplus
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#endif // _LIBCPP_COMPLEX_H
|
||||
|
||||
@@ -28,8 +28,8 @@ public:
|
||||
condition_variable(const condition_variable&) = delete;
|
||||
condition_variable& operator=(const condition_variable&) = delete;
|
||||
|
||||
void notify_one() noexcept;
|
||||
void notify_all() noexcept;
|
||||
void notify_one();
|
||||
void notify_all();
|
||||
|
||||
void wait(unique_lock<mutex>& lock);
|
||||
template <class Predicate>
|
||||
@@ -72,8 +72,8 @@ public:
|
||||
condition_variable_any(const condition_variable_any&) = delete;
|
||||
condition_variable_any& operator=(const condition_variable_any&) = delete;
|
||||
|
||||
void notify_one() noexcept;
|
||||
void notify_all() noexcept;
|
||||
void notify_one();
|
||||
void notify_all();
|
||||
|
||||
template <class Lock>
|
||||
void wait(Lock& lock);
|
||||
@@ -111,9 +111,7 @@ public:
|
||||
#include <__mutex_base>
|
||||
#include <memory>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -124,8 +122,8 @@ class _LIBCPP_VISIBLE condition_variable_any
|
||||
public:
|
||||
condition_variable_any();
|
||||
|
||||
void notify_one() _NOEXCEPT;
|
||||
void notify_all() _NOEXCEPT;
|
||||
void notify_one();
|
||||
void notify_all();
|
||||
|
||||
template <class _Lock>
|
||||
void wait(_Lock& __lock);
|
||||
@@ -161,17 +159,17 @@ condition_variable_any::condition_variable_any()
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
void
|
||||
condition_variable_any::notify_one() _NOEXCEPT
|
||||
condition_variable_any::notify_one()
|
||||
{
|
||||
{lock_guard<mutex> __lx(*__mut_);}
|
||||
{lock_guard<mutex> _(*__mut_);}
|
||||
__cv_.notify_one();
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
void
|
||||
condition_variable_any::notify_all() _NOEXCEPT
|
||||
condition_variable_any::notify_all()
|
||||
{
|
||||
{lock_guard<mutex> __lx(*__mut_);}
|
||||
{lock_guard<mutex> _(*__mut_);}
|
||||
__cv_.notify_all();
|
||||
}
|
||||
|
||||
@@ -188,8 +186,8 @@ condition_variable_any::wait(_Lock& __lock)
|
||||
shared_ptr<mutex> __mut = __mut_;
|
||||
unique_lock<mutex> __lk(*__mut);
|
||||
__lock.unlock();
|
||||
unique_ptr<_Lock, __lock_external> __lxx(&__lock);
|
||||
lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock);
|
||||
unique_ptr<_Lock, __lock_external> __(&__lock);
|
||||
lock_guard<unique_lock<mutex> > _(__lk, adopt_lock);
|
||||
__cv_.wait(__lk);
|
||||
} // __mut_.unlock(), __lock.lock()
|
||||
|
||||
@@ -210,8 +208,8 @@ condition_variable_any::wait_until(_Lock& __lock,
|
||||
shared_ptr<mutex> __mut = __mut_;
|
||||
unique_lock<mutex> __lk(*__mut);
|
||||
__lock.unlock();
|
||||
unique_ptr<_Lock, __lock_external> __lxx(&__lock);
|
||||
lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock);
|
||||
unique_ptr<_Lock, __lock_external> __(&__lock);
|
||||
lock_guard<unique_lock<mutex> > _(__lk, adopt_lock);
|
||||
return __cv_.wait_until(__lk, __t);
|
||||
} // __mut_.unlock(), __lock.lock()
|
||||
|
||||
|
||||
@@ -34,9 +34,7 @@ void longjmp(jmp_buf env, int val);
|
||||
#include <__config>
|
||||
#include <setjmp.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#ifndef setjmp
|
||||
#define setjmp(env) setjmp(env)
|
||||
|
||||
@@ -43,9 +43,7 @@ int raise(int sig);
|
||||
#include <__config>
|
||||
#include <signal.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
@@ -35,9 +35,7 @@ Types:
|
||||
#include <__config>
|
||||
#include <stdarg.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
@@ -22,9 +22,7 @@ Macros:
|
||||
|
||||
#include <__config>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#undef __bool_true_false_are_defined
|
||||
#define __bool_true_false_are_defined 1
|
||||
|
||||
@@ -43,9 +43,7 @@ Types:
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -58,32 +56,31 @@ typedef long double max_align_t;
|
||||
|
||||
struct _LIBCPP_VISIBLE nullptr_t
|
||||
{
|
||||
void* __lx;
|
||||
void* _;
|
||||
|
||||
struct __nat {int __for_bool_;};
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR nullptr_t() : __lx(0) {}
|
||||
_LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR nullptr_t(int __nat::*) : __lx(0) {}
|
||||
_LIBCPP_ALWAYS_INLINE nullptr_t(int __nat::*) {}
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR operator int __nat::*() const {return 0;}
|
||||
_LIBCPP_ALWAYS_INLINE operator int __nat::*() const {return 0;}
|
||||
|
||||
template <class _Tp>
|
||||
_LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
operator _Tp* () const {return 0;}
|
||||
|
||||
template <class _Tp, class _Up>
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
operator _Tp _Up::* () const {return 0;}
|
||||
|
||||
friend _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR bool operator==(nullptr_t, nullptr_t) {return true;}
|
||||
friend _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR bool operator!=(nullptr_t, nullptr_t) {return false;}
|
||||
friend _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR bool operator<(nullptr_t, nullptr_t) {return false;}
|
||||
friend _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR bool operator<=(nullptr_t, nullptr_t) {return true;}
|
||||
friend _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR bool operator>(nullptr_t, nullptr_t) {return false;}
|
||||
friend _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR bool operator>=(nullptr_t, nullptr_t) {return true;}
|
||||
friend _LIBCPP_ALWAYS_INLINE bool operator==(nullptr_t, nullptr_t) {return true;}
|
||||
friend _LIBCPP_ALWAYS_INLINE bool operator!=(nullptr_t, nullptr_t) {return false;}
|
||||
friend _LIBCPP_ALWAYS_INLINE bool operator<(nullptr_t, nullptr_t) {return false;}
|
||||
friend _LIBCPP_ALWAYS_INLINE bool operator<=(nullptr_t, nullptr_t) {return true;}
|
||||
friend _LIBCPP_ALWAYS_INLINE bool operator>(nullptr_t, nullptr_t) {return false;}
|
||||
friend _LIBCPP_ALWAYS_INLINE bool operator>=(nullptr_t, nullptr_t) {return true;}
|
||||
};
|
||||
|
||||
inline _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR nullptr_t __get_nullptr_t() {return nullptr_t(0);}
|
||||
inline _LIBCPP_ALWAYS_INLINE nullptr_t __get_nullptr_t() {return nullptr_t(0);}
|
||||
|
||||
#define nullptr _VSTD::__get_nullptr_t()
|
||||
|
||||
|
||||
@@ -144,9 +144,7 @@ Types:
|
||||
#include <__config>
|
||||
#include <stdint.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
@@ -99,21 +99,7 @@ void perror(const char* s);
|
||||
#include <__config>
|
||||
#include <stdio.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#ifdef getc
|
||||
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_getc(FILE* __stream) {return getc(__stream);}
|
||||
#undef getc
|
||||
inline _LIBCPP_INLINE_VISIBILITY int getc(FILE* __stream) {return __libcpp_getc(__stream);}
|
||||
#endif // getc
|
||||
|
||||
#ifdef putc
|
||||
inline _LIBCPP_INLINE_VISIBILITY int __libcpp_putc(int __c, FILE* __stream) {return putc(__c, __stream);}
|
||||
#undef putc
|
||||
inline _LIBCPP_INLINE_VISIBILITY int putc(int __c, FILE* __stream) {return __libcpp_putc(__c, __stream);}
|
||||
#endif // putc
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -138,15 +124,13 @@ using ::scanf;
|
||||
using ::snprintf;
|
||||
using ::sprintf;
|
||||
using ::sscanf;
|
||||
#ifndef _MSC_VER
|
||||
using ::vfprintf;
|
||||
using ::vfscanf;
|
||||
using ::vscanf;
|
||||
using ::vsscanf;
|
||||
#endif // _MSC_VER
|
||||
using ::vprintf;
|
||||
using ::vscanf;
|
||||
using ::vsnprintf;
|
||||
using ::vsprintf;
|
||||
using ::vsscanf;
|
||||
using ::fgetc;
|
||||
using ::fgets;
|
||||
using ::fputc;
|
||||
|
||||
@@ -74,9 +74,6 @@ int mbtowc(wchar_t* restrict pwc, const char* restrict s, size_t n);
|
||||
int wctomb(char* s, wchar_t wchar);
|
||||
size_t mbstowcs(wchar_t* restrict pwcs, const char* restrict s, size_t n);
|
||||
size_t wcstombs(char* restrict s, const wchar_t* restrict pwcs, size_t n);
|
||||
int at_quick_exit(void (*func)(void)) // C++11
|
||||
void quick_exit(int status); // C++11
|
||||
void *aligned_alloc(size_t alignment, size_t size); // C11
|
||||
|
||||
} // std
|
||||
|
||||
@@ -84,13 +81,8 @@ void *aligned_alloc(size_t alignment, size_t size); // C11
|
||||
|
||||
#include <__config>
|
||||
#include <stdlib.h>
|
||||
#ifdef _MSC_VER
|
||||
#include "support/win32/locale_win32.h"
|
||||
#endif // _MSC_VER
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -134,22 +126,12 @@ using ::mbtowc;
|
||||
using ::wctomb;
|
||||
using ::mbstowcs;
|
||||
using ::wcstombs;
|
||||
#ifdef _LIBCPP_HAS_QUICK_EXIT
|
||||
using ::at_quick_exit;
|
||||
using ::quick_exit;
|
||||
#endif
|
||||
#ifdef _LIBCPP_HAS_C11_FEATURES
|
||||
using ::aligned_alloc;
|
||||
#endif
|
||||
|
||||
// MSVC already has the correct prototype in <stdlib.h.h> #ifdef __cplusplus
|
||||
#if !defined(_MSC_VER) && !defined(__sun__)
|
||||
inline _LIBCPP_INLINE_VISIBILITY long abs( long __x) _NOEXCEPT {return labs(__x);}
|
||||
inline _LIBCPP_INLINE_VISIBILITY long long abs(long long __x) _NOEXCEPT {return llabs(__x);}
|
||||
inline _LIBCPP_INLINE_VISIBILITY long abs( long __x) {return labs(__x);}
|
||||
inline _LIBCPP_INLINE_VISIBILITY long long abs(long long __x) {return llabs(__x);}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY ldiv_t div( long __x, long __y) _NOEXCEPT {return ldiv(__x, __y);}
|
||||
inline _LIBCPP_INLINE_VISIBILITY lldiv_t div(long long __x, long long __y) _NOEXCEPT {return lldiv(__x, __y);}
|
||||
#endif // _MSC_VER
|
||||
inline _LIBCPP_INLINE_VISIBILITY ldiv_t div( long __x, long __y) {return ldiv(__x, __y);}
|
||||
inline _LIBCPP_INLINE_VISIBILITY lldiv_t div(long long __x, long long __y) {return lldiv(__x, __y);}
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
|
||||
@@ -60,9 +60,7 @@ size_t strlen(const char* s);
|
||||
#include <__config>
|
||||
#include <string.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -93,8 +91,7 @@ using ::strspn;
|
||||
|
||||
using ::strstr;
|
||||
|
||||
// MSVC, GNU libc and its derivates already have the correct prototype in <string.h> #ifdef __cplusplus
|
||||
#if !defined(__GLIBC__) && !defined(_MSC_VER) && !defined(__sun__)
|
||||
#ifndef __GLIBC__ // GNU libc and its derivates already have the correct prototype in <string.h> #ifdef __cplusplus
|
||||
inline _LIBCPP_INLINE_VISIBILITY char* strchr( char* __s, int __c) {return ::strchr(__s, __c);}
|
||||
inline _LIBCPP_INLINE_VISIBILITY char* strpbrk( char* __s1, const char* __s2) {return ::strpbrk(__s1, __s2);}
|
||||
inline _LIBCPP_INLINE_VISIBILITY char* strrchr( char* __s, int __c) {return ::strrchr(__s, __c);}
|
||||
|
||||
@@ -22,8 +22,6 @@
|
||||
#include <ccomplex>
|
||||
#include <cmath>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#endif // _LIBCPP_CTGMATH
|
||||
|
||||
@@ -47,9 +47,7 @@ size_t strftime(char* restrict s, size_t maxsize, const char* restrict format,
|
||||
#include <__config>
|
||||
#include <time.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
@@ -106,13 +106,8 @@ size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,
|
||||
#include <__config>
|
||||
#include <cwctype>
|
||||
#include <wchar.h>
|
||||
#if _WIN32
|
||||
#include <support/win32/support.h> // pull in *swprintf defines
|
||||
#endif // _WIN32
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -124,15 +119,13 @@ using ::FILE;
|
||||
using ::fwprintf;
|
||||
using ::fwscanf;
|
||||
using ::swprintf;
|
||||
using ::vfwprintf;
|
||||
using ::vswprintf;
|
||||
using ::vwprintf;
|
||||
#ifndef _MSC_VER
|
||||
using ::swscanf;
|
||||
using ::vfwprintf;
|
||||
using ::vfwscanf;
|
||||
using ::vswprintf;
|
||||
using ::vswscanf;
|
||||
using ::vwprintf;
|
||||
using ::vwscanf;
|
||||
#endif // _MSC_VER
|
||||
using ::wprintf;
|
||||
using ::wscanf;
|
||||
using ::fgetwc;
|
||||
@@ -146,10 +139,8 @@ using ::putwc;
|
||||
using ::putwchar;
|
||||
using ::ungetwc;
|
||||
using ::wcstod;
|
||||
#ifndef _MSC_VER
|
||||
using ::wcstof;
|
||||
using ::wcstold;
|
||||
#endif // _MSC_VER
|
||||
using ::wcstol;
|
||||
using ::wcstoll;
|
||||
using ::wcstoul;
|
||||
|
||||
@@ -54,9 +54,7 @@ wctrans_t wctrans(const char* property);
|
||||
#include <cctype>
|
||||
#include <wctype.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
@@ -150,9 +150,7 @@ template <class T, class Allocator>
|
||||
|
||||
*/
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#include <__config>
|
||||
#include <__split_buffer>
|
||||
@@ -162,8 +160,6 @@ template <class T, class Allocator>
|
||||
#include <algorithm>
|
||||
#include <stdexcept>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _Tp, class _Allocator> class __deque_base;
|
||||
@@ -280,10 +276,10 @@ public:
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY __deque_iterator() _NOEXCEPT {}
|
||||
|
||||
template <class _Pp, class _Rp, class _MP>
|
||||
template <class _P, class _R, class _MP>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__deque_iterator(const __deque_iterator<value_type, _Pp, _Rp, _MP, difference_type, __block_size>& __it,
|
||||
typename enable_if<is_convertible<_Pp, pointer>::value>::type* = 0) _NOEXCEPT
|
||||
__deque_iterator(const __deque_iterator<value_type, _P, _R, _MP, difference_type, __block_size>& __it,
|
||||
typename enable_if<is_convertible<_P, pointer>::value>::type* = 0) _NOEXCEPT
|
||||
: __m_iter_(__it.__m_iter_), __ptr_(__it.__ptr_) {}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY reference operator*() const {return *__ptr_;}
|
||||
@@ -409,9 +405,9 @@ private:
|
||||
_LIBCPP_INLINE_VISIBILITY __deque_iterator(__map_iterator __m, pointer __p) _NOEXCEPT
|
||||
: __m_iter_(__m), __ptr_(__p) {}
|
||||
|
||||
template <class _Tp, class _Ap> friend class __deque_base;
|
||||
template <class _Tp, class _Ap> friend class _LIBCPP_VISIBLE deque;
|
||||
template <class _Vp, class _Pp, class _Rp, class _MP, class _Dp, _Dp>
|
||||
template <class _Tp, class _A> friend class __deque_base;
|
||||
template <class _Tp, class _A> friend class _LIBCPP_VISIBLE deque;
|
||||
template <class _V, class _P, class _R, class _MP, class _D, _D>
|
||||
friend class _LIBCPP_VISIBLE __deque_iterator;
|
||||
|
||||
template <class _RAIter,
|
||||
@@ -981,14 +977,14 @@ protected:
|
||||
|
||||
private:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __move_assign_alloc(__deque_base& __c, true_type)
|
||||
void __move_assign_alloc(const __deque_base& __c, true_type)
|
||||
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
|
||||
{
|
||||
__alloc() = _VSTD::move(__c.__alloc());
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __move_assign_alloc(__deque_base&, false_type) _NOEXCEPT
|
||||
void __move_assign_alloc(const __deque_base& __c, false_type) _NOEXCEPT
|
||||
{}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -1007,7 +1003,7 @@ private:
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static void __swap_alloc(allocator_type&, allocator_type&, false_type)
|
||||
static void __swap_alloc(allocator_type& __x, allocator_type& __y, false_type)
|
||||
_NOEXCEPT
|
||||
{}
|
||||
};
|
||||
@@ -1208,16 +1204,12 @@ public:
|
||||
typename enable_if<__is_input_iterator<_InputIter>::value>::type* = 0);
|
||||
deque(const deque& __c);
|
||||
deque(const deque& __c, const allocator_type& __a);
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
deque(initializer_list<value_type> __il);
|
||||
deque(initializer_list<value_type> __il, const allocator_type& __a);
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
deque& operator=(const deque& __c);
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
deque& operator=(initializer_list<value_type> __il) {assign(__il); return *this;}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
deque(deque&& __c) _NOEXCEPT_(is_nothrow_move_constructible<__base>::value);
|
||||
@@ -1235,10 +1227,8 @@ public:
|
||||
void assign(_RAIter __f, _RAIter __l,
|
||||
typename enable_if<__is_random_access_iterator<_RAIter>::value>::type* = 0);
|
||||
void assign(size_type __n, const value_type& __v);
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void assign(initializer_list<value_type> __il) {assign(__il.begin(), __il.end());}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
allocator_type get_allocator() const _NOEXCEPT;
|
||||
|
||||
@@ -1323,11 +1313,9 @@ public:
|
||||
template <class _BiIter>
|
||||
iterator insert (const_iterator __p, _BiIter __f, _BiIter __l,
|
||||
typename enable_if<__is_bidirectional_iterator<_BiIter>::value>::type* = 0);
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(const_iterator __p, initializer_list<value_type> __il)
|
||||
{return insert(__p, __il.begin(), __il.end());}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
void pop_front();
|
||||
void pop_back();
|
||||
iterator erase(const_iterator __p);
|
||||
@@ -1403,7 +1391,7 @@ private:
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __copy_assign_alloc(const deque&, false_type)
|
||||
void __copy_assign_alloc(const deque& __c, false_type)
|
||||
{}
|
||||
|
||||
void __move_assign(deque& __c, true_type)
|
||||
@@ -1464,8 +1452,6 @@ deque<_Tp, _Allocator>::deque(const deque& __c, const allocator_type& __a)
|
||||
__append(__c.begin(), __c.end());
|
||||
}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _Tp, class _Allocator>
|
||||
deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il)
|
||||
{
|
||||
@@ -1479,8 +1465,6 @@ deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il, const allocator
|
||||
__append(__il.begin(), __il.end());
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _Tp, class _Allocator>
|
||||
deque<_Tp, _Allocator>&
|
||||
deque<_Tp, _Allocator>::operator=(const deque& __c)
|
||||
@@ -1510,8 +1494,8 @@ deque<_Tp, _Allocator>::deque(deque&& __c, const allocator_type& __a)
|
||||
{
|
||||
if (__a != __c.__alloc())
|
||||
{
|
||||
typedef move_iterator<iterator> _Ip;
|
||||
assign(_Ip(__c.begin()), _Ip(__c.end()));
|
||||
typedef move_iterator<iterator> _I;
|
||||
assign(_I(__c.begin()), _I(__c.end()));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1533,8 +1517,8 @@ deque<_Tp, _Allocator>::__move_assign(deque& __c, false_type)
|
||||
{
|
||||
if (__base::__alloc() != __c.__alloc())
|
||||
{
|
||||
typedef move_iterator<iterator> _Ip;
|
||||
assign(_Ip(__c.begin()), _Ip(__c.end()));
|
||||
typedef move_iterator<iterator> _I;
|
||||
assign(_I(__c.begin()), _I(__c.end()));
|
||||
}
|
||||
else
|
||||
__move_assign(__c, true_type());
|
||||
@@ -1966,7 +1950,6 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
|
||||
}
|
||||
else
|
||||
{
|
||||
value_type __tmp(_VSTD::forward<_Args>(__args)...);
|
||||
iterator __b = __base::begin();
|
||||
iterator __bm1 = _VSTD::prev(__b);
|
||||
__alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
|
||||
@@ -1974,7 +1957,7 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
|
||||
++__base::size();
|
||||
if (__pos > 1)
|
||||
__b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b);
|
||||
*__b = _VSTD::move(__tmp);
|
||||
*__b = value_type(_VSTD::forward<_Args>(__args)...);
|
||||
}
|
||||
}
|
||||
else
|
||||
@@ -1990,14 +1973,13 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
|
||||
}
|
||||
else
|
||||
{
|
||||
value_type __tmp(_VSTD::forward<_Args>(__args)...);
|
||||
iterator __e = __base::end();
|
||||
iterator __em1 = _VSTD::prev(__e);
|
||||
__alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1));
|
||||
++__base::size();
|
||||
if (__de > 1)
|
||||
__e = _VSTD::move_backward(__e - __de, __em1, __e);
|
||||
*--__e = _VSTD::move(__tmp);
|
||||
*--__e = value_type(_VSTD::forward<_Args>(__args)...);
|
||||
}
|
||||
}
|
||||
return __base::begin() + __pos;
|
||||
|
||||
@@ -80,9 +80,7 @@ template <class E> void rethrow_if_nested(const E& e);
|
||||
#include <cstddef>
|
||||
#include <type_traits>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
namespace std // purposefully not using versioning namespace
|
||||
{
|
||||
@@ -107,19 +105,19 @@ public:
|
||||
typedef void (*unexpected_handler)();
|
||||
_LIBCPP_VISIBLE unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT;
|
||||
_LIBCPP_VISIBLE unexpected_handler get_unexpected() _NOEXCEPT;
|
||||
_LIBCPP_NORETURN _LIBCPP_VISIBLE void unexpected();
|
||||
_ATTRIBUTE(noreturn) _LIBCPP_VISIBLE void unexpected();
|
||||
|
||||
typedef void (*terminate_handler)();
|
||||
_LIBCPP_VISIBLE terminate_handler set_terminate(terminate_handler) _NOEXCEPT;
|
||||
_LIBCPP_VISIBLE terminate_handler get_terminate() _NOEXCEPT;
|
||||
_LIBCPP_NORETURN _LIBCPP_VISIBLE void terminate() _NOEXCEPT;
|
||||
_ATTRIBUTE(noreturn) _LIBCPP_VISIBLE void terminate() _NOEXCEPT;
|
||||
|
||||
_LIBCPP_VISIBLE bool uncaught_exception() _NOEXCEPT;
|
||||
|
||||
class _LIBCPP_VISIBLE exception_ptr;
|
||||
class exception_ptr;
|
||||
|
||||
exception_ptr current_exception() _NOEXCEPT;
|
||||
_LIBCPP_NORETURN void rethrow_exception(exception_ptr);
|
||||
_ATTRIBUTE(noreturn) void rethrow_exception(exception_ptr);
|
||||
|
||||
class _LIBCPP_VISIBLE exception_ptr
|
||||
{
|
||||
@@ -132,7 +130,7 @@ public:
|
||||
~exception_ptr() _NOEXCEPT;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_EXPLICIT
|
||||
// explicit
|
||||
operator bool() const _NOEXCEPT {return __ptr_ != nullptr;}
|
||||
|
||||
friend _LIBCPP_INLINE_VISIBILITY
|
||||
@@ -143,12 +141,12 @@ public:
|
||||
{return !(__x == __y);}
|
||||
|
||||
friend exception_ptr current_exception() _NOEXCEPT;
|
||||
_LIBCPP_NORETURN friend void rethrow_exception(exception_ptr);
|
||||
_ATTRIBUTE(noreturn) friend void rethrow_exception(exception_ptr);
|
||||
};
|
||||
|
||||
template<class _Ep>
|
||||
template<class _E>
|
||||
exception_ptr
|
||||
make_exception_ptr(_Ep __e) _NOEXCEPT
|
||||
make_exception_ptr(_E __e) _NOEXCEPT
|
||||
{
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
try
|
||||
@@ -174,7 +172,7 @@ public:
|
||||
virtual ~nested_exception() _NOEXCEPT;
|
||||
|
||||
// access functions
|
||||
_LIBCPP_NORETURN void rethrow_nested() const;
|
||||
_ATTRIBUTE(noreturn) void rethrow_nested() const;
|
||||
_LIBCPP_INLINE_VISIBILITY exception_ptr nested_ptr() const _NOEXCEPT {return __ptr_;}
|
||||
};
|
||||
|
||||
@@ -187,7 +185,7 @@ struct __nested
|
||||
};
|
||||
|
||||
template <class _Tp>
|
||||
_LIBCPP_NORETURN
|
||||
_ATTRIBUTE(noreturn)
|
||||
void
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
throw_with_nested(_Tp&& __t, typename enable_if<
|
||||
@@ -206,7 +204,7 @@ throw_with_nested (_Tp& __t, typename enable_if<
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
_LIBCPP_NORETURN
|
||||
_ATTRIBUTE(noreturn)
|
||||
void
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
throw_with_nested(_Tp&& __t, typename enable_if<
|
||||
@@ -224,11 +222,11 @@ throw_with_nested (_Tp& __t, typename enable_if<
|
||||
#endif
|
||||
}
|
||||
|
||||
template <class _Ep>
|
||||
template <class _E>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
void
|
||||
rethrow_if_nested(const _Ep& __e, typename enable_if<
|
||||
is_polymorphic<_Ep>::value
|
||||
rethrow_if_nested(const _E& __e, typename enable_if<
|
||||
is_polymorphic<_E>::value
|
||||
>::type* = 0)
|
||||
{
|
||||
const nested_exception* __nep = dynamic_cast<const nested_exception*>(&__e);
|
||||
@@ -236,11 +234,11 @@ rethrow_if_nested(const _Ep& __e, typename enable_if<
|
||||
__nep->rethrow_nested();
|
||||
}
|
||||
|
||||
template <class _Ep>
|
||||
template <class _E>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
void
|
||||
rethrow_if_nested(const _Ep&, typename enable_if<
|
||||
!is_polymorphic<_Ep>::value
|
||||
rethrow_if_nested(const _E& __e, typename enable_if<
|
||||
!is_polymorphic<_E>::value
|
||||
>::type* = 0)
|
||||
{
|
||||
}
|
||||
|
||||
@@ -1,46 +0,0 @@
|
||||
// -*- C++ -*-
|
||||
//===------------------------- hash_set ------------------------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is dual licensed under the MIT and the University of Illinois Open
|
||||
// Source Licenses. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP_EXT_HASH
|
||||
#define _LIBCPP_EXT_HASH
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
|
||||
namespace __gnu_cxx {
|
||||
using namespace std;
|
||||
|
||||
template <typename T> struct _LIBCPP_VISIBLE hash : public std::hash<T>
|
||||
{ };
|
||||
|
||||
template <> struct _LIBCPP_VISIBLE hash<const char*>
|
||||
: public unary_function<const char*, size_t>
|
||||
{
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
size_t operator()(const char *__c) const _NOEXCEPT
|
||||
{
|
||||
return __do_string_hash(__c, __c + strlen(__c));
|
||||
}
|
||||
};
|
||||
|
||||
template <> struct _LIBCPP_VISIBLE hash<char *>
|
||||
: public unary_function<char*, size_t>
|
||||
{
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
size_t operator()(char *__c) const _NOEXCEPT
|
||||
{
|
||||
return __do_string_hash<const char *>(__c, __c + strlen(__c));
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_EXT_HASH
|
||||
@@ -203,11 +203,8 @@ template <class Key, class T, class Hash, class Pred, class Alloc>
|
||||
#include <__hash_table>
|
||||
#include <functional>
|
||||
#include <stdexcept>
|
||||
#include <ext/__hash>
|
||||
|
||||
#if __DEPRECATED
|
||||
#warning Use of the header <ext/hash_map> is deprecated. Migrate to <unordered_map>
|
||||
#endif
|
||||
|
||||
#pragma GCC system_header
|
||||
|
||||
@@ -215,11 +212,7 @@ namespace __gnu_cxx {
|
||||
|
||||
using namespace std;
|
||||
|
||||
template <class _Tp, class _Hash, bool = is_empty<_Hash>::value
|
||||
#if __has_feature(is_final)
|
||||
&& !__is_final(_Hash)
|
||||
#endif
|
||||
>
|
||||
template <class _Tp, class _Hash, bool = is_empty<_Hash>::value>
|
||||
class __hash_map_hasher
|
||||
: private _Hash
|
||||
{
|
||||
@@ -251,11 +244,7 @@ public:
|
||||
{return __hash_(__x);}
|
||||
};
|
||||
|
||||
template <class _Tp, class _Pred, bool = is_empty<_Pred>::value
|
||||
#if __has_feature(is_final)
|
||||
&& !__is_final(_Pred)
|
||||
#endif
|
||||
>
|
||||
template <class _Tp, class _Pred, bool = is_empty<_Pred>::value>
|
||||
class __hash_map_equal
|
||||
: private _Pred
|
||||
{
|
||||
@@ -477,7 +466,6 @@ public:
|
||||
// types
|
||||
typedef _Key key_type;
|
||||
typedef _Tp mapped_type;
|
||||
typedef _Tp data_type;
|
||||
typedef _Hash hasher;
|
||||
typedef _Pred key_equal;
|
||||
typedef _Alloc allocator_type;
|
||||
@@ -507,8 +495,8 @@ private:
|
||||
typedef typename __table::__node_traits __node_traits;
|
||||
typedef typename __table::__node_allocator __node_allocator;
|
||||
typedef typename __table::__node __node;
|
||||
typedef __hash_map_node_destructor<__node_allocator> _Dp;
|
||||
typedef unique_ptr<__node, _Dp> __node_holder;
|
||||
typedef __hash_map_node_destructor<__node_allocator> _D;
|
||||
typedef unique_ptr<__node, _D> __node_holder;
|
||||
typedef allocator_traits<allocator_type> __alloc_traits;
|
||||
public:
|
||||
typedef typename __alloc_traits::pointer pointer;
|
||||
@@ -561,8 +549,6 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
pair<iterator, bool> insert(const value_type& __x)
|
||||
{return __table_.__insert_unique(__x);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(const_iterator, const value_type& __x) {return insert(__x).first;}
|
||||
template <class _InputIterator>
|
||||
void insert(_InputIterator __first, _InputIterator __last);
|
||||
|
||||
@@ -679,7 +665,7 @@ typename hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
|
||||
hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type& __k)
|
||||
{
|
||||
__node_allocator& __na = __table_.__node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), __k);
|
||||
__h.get_deleter().__first_constructed = true;
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
|
||||
@@ -756,7 +742,6 @@ public:
|
||||
// types
|
||||
typedef _Key key_type;
|
||||
typedef _Tp mapped_type;
|
||||
typedef _Tp data_type;
|
||||
typedef _Hash hasher;
|
||||
typedef _Pred key_equal;
|
||||
typedef _Alloc allocator_type;
|
||||
@@ -784,8 +769,8 @@ private:
|
||||
typedef typename __table::__node_traits __node_traits;
|
||||
typedef typename __table::__node_allocator __node_allocator;
|
||||
typedef typename __table::__node __node;
|
||||
typedef __hash_map_node_destructor<__node_allocator> _Dp;
|
||||
typedef unique_ptr<__node, _Dp> __node_holder;
|
||||
typedef __hash_map_node_destructor<__node_allocator> _D;
|
||||
typedef unique_ptr<__node, _D> __node_holder;
|
||||
typedef allocator_traits<allocator_type> __alloc_traits;
|
||||
public:
|
||||
typedef typename __alloc_traits::pointer pointer;
|
||||
@@ -838,8 +823,6 @@ public:
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(const_iterator, const value_type& __x) {return insert(__x);}
|
||||
template <class _InputIterator>
|
||||
void insert(_InputIterator __first, _InputIterator __last);
|
||||
|
||||
|
||||
@@ -196,17 +196,14 @@ template <class Value, class Hash, class Pred, class Alloc>
|
||||
#include <__config>
|
||||
#include <__hash_table>
|
||||
#include <functional>
|
||||
#include <ext/__hash>
|
||||
|
||||
#if __DEPRECATED
|
||||
#warning Use of the header <ext/hash_set> is deprecated. Migrate to <unordered_set>
|
||||
#endif
|
||||
|
||||
namespace __gnu_cxx {
|
||||
|
||||
using namespace std;
|
||||
|
||||
template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
|
||||
template <class _Value, class _Hash = std::hash<_Value>, class _Pred = equal_to<_Value>,
|
||||
class _Alloc = allocator<_Value> >
|
||||
class _LIBCPP_VISIBLE hash_set
|
||||
{
|
||||
@@ -275,8 +272,6 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
pair<iterator, bool> insert(const value_type& __x)
|
||||
{return __table_.__insert_unique(__x);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(const_iterator, const value_type& __x) {return insert(__x).first;}
|
||||
template <class _InputIterator>
|
||||
void insert(_InputIterator __first, _InputIterator __last);
|
||||
|
||||
@@ -495,8 +490,6 @@ public:
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(const_iterator, const value_type& __x) {return insert(__x);}
|
||||
template <class _InputIterator>
|
||||
void insert(_InputIterator __first, _InputIterator __last);
|
||||
|
||||
|
||||
@@ -174,11 +174,7 @@ template <class T, class Allocator>
|
||||
#include <iterator>
|
||||
#include <algorithm>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -212,8 +208,8 @@ struct __forward_list_node
|
||||
value_type __value_;
|
||||
};
|
||||
|
||||
template<class _Tp, class _Alloc> class _LIBCPP_VISIBLE forward_list;
|
||||
template<class _NodeConstPtr> class _LIBCPP_VISIBLE __forward_list_const_iterator;
|
||||
template<class _Tp, class _Alloc> class forward_list;
|
||||
template<class _NodeConstPtr> class __forward_list_const_iterator;
|
||||
|
||||
template <class _NodePtr>
|
||||
class _LIBCPP_VISIBLE __forward_list_iterator
|
||||
@@ -225,8 +221,8 @@ class _LIBCPP_VISIBLE __forward_list_iterator
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit __forward_list_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
|
||||
|
||||
template<class, class> friend class _LIBCPP_VISIBLE forward_list;
|
||||
template<class> friend class _LIBCPP_VISIBLE __forward_list_const_iterator;
|
||||
template<class, class> friend class forward_list;
|
||||
template<class> friend class __forward_list_const_iterator;
|
||||
|
||||
public:
|
||||
typedef forward_iterator_tag iterator_category;
|
||||
@@ -584,10 +580,8 @@ public:
|
||||
: base(_VSTD::move(__x)) {}
|
||||
forward_list(forward_list&& __x, const allocator_type& __a);
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
forward_list(initializer_list<value_type> __il);
|
||||
forward_list(initializer_list<value_type> __il, const allocator_type& __a);
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
// ~forward_list() = default;
|
||||
|
||||
@@ -598,9 +592,7 @@ public:
|
||||
__node_traits::propagate_on_container_move_assignment::value &&
|
||||
is_nothrow_move_assignable<allocator_type>::value);
|
||||
#endif
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
forward_list& operator=(initializer_list<value_type> __il);
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _InputIterator>
|
||||
typename enable_if
|
||||
@@ -610,9 +602,7 @@ public:
|
||||
>::type
|
||||
assign(_InputIterator __f, _InputIterator __l);
|
||||
void assign(size_type __n, const value_type& __v);
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
void assign(initializer_list<value_type> __il);
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
allocator_type get_allocator() const _NOEXCEPT
|
||||
@@ -687,10 +677,8 @@ public:
|
||||
iterator
|
||||
>::type
|
||||
insert_after(const_iterator __p, _InputIterator __f, _InputIterator __l);
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
iterator insert_after(const_iterator __p, initializer_list<value_type> __il)
|
||||
{return insert_after(__p, __il.begin(), __il.end());}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
iterator erase_after(const_iterator __p);
|
||||
iterator erase_after(const_iterator __f, const_iterator __l);
|
||||
@@ -772,8 +760,8 @@ forward_list<_Tp, _Alloc>::forward_list(size_type __n)
|
||||
if (__n > 0)
|
||||
{
|
||||
__node_allocator& __a = base::__alloc();
|
||||
typedef __allocator_destructor<__node_allocator> _Dp;
|
||||
unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
|
||||
typedef __allocator_destructor<__node_allocator> _D;
|
||||
unique_ptr<__node, _D> __h(nullptr, _D(__a, 1));
|
||||
for (__node_pointer __p = base::__before_begin(); __n > 0; --__n,
|
||||
__p = __p->__next_)
|
||||
{
|
||||
@@ -848,15 +836,13 @@ forward_list<_Tp, _Alloc>::forward_list(forward_list&& __x,
|
||||
{
|
||||
if (base::__alloc() != __x.__alloc())
|
||||
{
|
||||
typedef move_iterator<iterator> _Ip;
|
||||
insert_after(cbefore_begin(), _Ip(__x.begin()), _Ip(__x.end()));
|
||||
typedef move_iterator<iterator> _I;
|
||||
insert_after(cbefore_begin(), _I(__x.begin()), _I(__x.end()));
|
||||
}
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _Tp, class _Alloc>
|
||||
forward_list<_Tp, _Alloc>::forward_list(initializer_list<value_type> __il)
|
||||
{
|
||||
@@ -871,8 +857,6 @@ forward_list<_Tp, _Alloc>::forward_list(initializer_list<value_type> __il,
|
||||
insert_after(cbefore_begin(), __il.begin(), __il.end());
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _Tp, class _Alloc>
|
||||
forward_list<_Tp, _Alloc>&
|
||||
forward_list<_Tp, _Alloc>::operator=(const forward_list& __x)
|
||||
@@ -906,8 +890,8 @@ forward_list<_Tp, _Alloc>::__move_assign(forward_list& __x, false_type)
|
||||
__move_assign(__x, true_type());
|
||||
else
|
||||
{
|
||||
typedef move_iterator<iterator> _Ip;
|
||||
assign(_Ip(__x.begin()), _Ip(__x.end()));
|
||||
typedef move_iterator<iterator> _I;
|
||||
assign(_I(__x.begin()), _I(__x.end()));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -926,8 +910,6 @@ forward_list<_Tp, _Alloc>::operator=(forward_list&& __x)
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _Tp, class _Alloc>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
forward_list<_Tp, _Alloc>&
|
||||
@@ -937,8 +919,6 @@ forward_list<_Tp, _Alloc>::operator=(initializer_list<value_type> __il)
|
||||
return *this;
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _Tp, class _Alloc>
|
||||
template <class _InputIterator>
|
||||
typename enable_if
|
||||
@@ -974,8 +954,6 @@ forward_list<_Tp, _Alloc>::assign(size_type __n, const value_type& __v)
|
||||
erase_after(__i, __e);
|
||||
}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _Tp, class _Alloc>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
void
|
||||
@@ -984,8 +962,6 @@ forward_list<_Tp, _Alloc>::assign(initializer_list<value_type> __il)
|
||||
assign(__il.begin(), __il.end());
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
@@ -995,8 +971,8 @@ void
|
||||
forward_list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
|
||||
{
|
||||
__node_allocator& __a = base::__alloc();
|
||||
typedef __allocator_destructor<__node_allocator> _Dp;
|
||||
unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
|
||||
typedef __allocator_destructor<__node_allocator> _D;
|
||||
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
|
||||
__node_traits::construct(__a, _VSTD::addressof(__h->__value_),
|
||||
_VSTD::forward<_Args>(__args)...);
|
||||
__h->__next_ = base::__before_begin()->__next_;
|
||||
@@ -1010,8 +986,8 @@ void
|
||||
forward_list<_Tp, _Alloc>::push_front(value_type&& __v)
|
||||
{
|
||||
__node_allocator& __a = base::__alloc();
|
||||
typedef __allocator_destructor<__node_allocator> _Dp;
|
||||
unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
|
||||
typedef __allocator_destructor<__node_allocator> _D;
|
||||
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
|
||||
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
|
||||
__h->__next_ = base::__before_begin()->__next_;
|
||||
base::__before_begin()->__next_ = __h.release();
|
||||
@@ -1024,8 +1000,8 @@ void
|
||||
forward_list<_Tp, _Alloc>::push_front(const value_type& __v)
|
||||
{
|
||||
__node_allocator& __a = base::__alloc();
|
||||
typedef __allocator_destructor<__node_allocator> _Dp;
|
||||
unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
|
||||
typedef __allocator_destructor<__node_allocator> _D;
|
||||
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
|
||||
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
|
||||
__h->__next_ = base::__before_begin()->__next_;
|
||||
base::__before_begin()->__next_ = __h.release();
|
||||
@@ -1052,8 +1028,8 @@ forward_list<_Tp, _Alloc>::emplace_after(const_iterator __p, _Args&&... __args)
|
||||
{
|
||||
__node_pointer const __r = const_cast<__node_pointer>(__p.__ptr_);
|
||||
__node_allocator& __a = base::__alloc();
|
||||
typedef __allocator_destructor<__node_allocator> _Dp;
|
||||
unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
|
||||
typedef __allocator_destructor<__node_allocator> _D;
|
||||
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
|
||||
__node_traits::construct(__a, _VSTD::addressof(__h->__value_),
|
||||
_VSTD::forward<_Args>(__args)...);
|
||||
__h->__next_ = __r->__next_;
|
||||
@@ -1069,8 +1045,8 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, value_type&& __v)
|
||||
{
|
||||
__node_pointer const __r = const_cast<__node_pointer>(__p.__ptr_);
|
||||
__node_allocator& __a = base::__alloc();
|
||||
typedef __allocator_destructor<__node_allocator> _Dp;
|
||||
unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
|
||||
typedef __allocator_destructor<__node_allocator> _D;
|
||||
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
|
||||
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
|
||||
__h->__next_ = __r->__next_;
|
||||
__r->__next_ = __h.release();
|
||||
@@ -1085,8 +1061,8 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, const value_type& __
|
||||
{
|
||||
__node_pointer const __r = const_cast<__node_pointer>(__p.__ptr_);
|
||||
__node_allocator& __a = base::__alloc();
|
||||
typedef __allocator_destructor<__node_allocator> _Dp;
|
||||
unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
|
||||
typedef __allocator_destructor<__node_allocator> _D;
|
||||
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
|
||||
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
|
||||
__h->__next_ = __r->__next_;
|
||||
__r->__next_ = __h.release();
|
||||
@@ -1102,8 +1078,8 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
|
||||
if (__n > 0)
|
||||
{
|
||||
__node_allocator& __a = base::__alloc();
|
||||
typedef __allocator_destructor<__node_allocator> _Dp;
|
||||
unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
|
||||
typedef __allocator_destructor<__node_allocator> _D;
|
||||
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
|
||||
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
|
||||
__node_pointer __first = __h.release();
|
||||
__node_pointer __last = __first;
|
||||
@@ -1152,8 +1128,8 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
|
||||
if (__f != __l)
|
||||
{
|
||||
__node_allocator& __a = base::__alloc();
|
||||
typedef __allocator_destructor<__node_allocator> _Dp;
|
||||
unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
|
||||
typedef __allocator_destructor<__node_allocator> _D;
|
||||
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
|
||||
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f);
|
||||
__node_pointer __first = __h.release();
|
||||
__node_pointer __last = __first;
|
||||
@@ -1244,8 +1220,8 @@ forward_list<_Tp, _Alloc>::resize(size_type __n)
|
||||
if (__n > 0)
|
||||
{
|
||||
__node_allocator& __a = base::__alloc();
|
||||
typedef __allocator_destructor<__node_allocator> _Dp;
|
||||
unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
|
||||
typedef __allocator_destructor<__node_allocator> _D;
|
||||
unique_ptr<__node, _D> __h(nullptr, _D(__a, 1));
|
||||
for (__node_pointer __ptr = __p.__ptr_; __n > 0; --__n,
|
||||
__ptr = __ptr->__next_)
|
||||
{
|
||||
@@ -1276,8 +1252,8 @@ forward_list<_Tp, _Alloc>::resize(size_type __n, const value_type& __v)
|
||||
if (__n > 0)
|
||||
{
|
||||
__node_allocator& __a = base::__alloc();
|
||||
typedef __allocator_destructor<__node_allocator> _Dp;
|
||||
unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
|
||||
typedef __allocator_destructor<__node_allocator> _D;
|
||||
unique_ptr<__node, _D> __h(nullptr, _D(__a, 1));
|
||||
for (__node_pointer __ptr = __p.__ptr_; __n > 0; --__n,
|
||||
__ptr = __ptr->__next_)
|
||||
{
|
||||
@@ -1569,12 +1545,12 @@ template <class _Tp, class _Alloc>
|
||||
bool operator==(const forward_list<_Tp, _Alloc>& __x,
|
||||
const forward_list<_Tp, _Alloc>& __y)
|
||||
{
|
||||
typedef forward_list<_Tp, _Alloc> _Cp;
|
||||
typedef typename _Cp::const_iterator _Ip;
|
||||
_Ip __ix = __x.begin();
|
||||
_Ip __ex = __x.end();
|
||||
_Ip __iy = __y.begin();
|
||||
_Ip __ey = __y.end();
|
||||
typedef forward_list<_Tp, _Alloc> _C;
|
||||
typedef typename _C::const_iterator _I;
|
||||
_I __ix = __x.begin();
|
||||
_I __ex = __x.end();
|
||||
_I __iy = __y.begin();
|
||||
_I __ey = __y.end();
|
||||
for (; __ix != __ex && __iy != __ey; ++__ix, ++__iy)
|
||||
if (!(*__ix == *__iy))
|
||||
return false;
|
||||
|
||||
@@ -171,11 +171,7 @@ typedef basic_fstream<wchar_t> wfstream;
|
||||
#include <__locale>
|
||||
#include <cstdio>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -234,7 +230,6 @@ private:
|
||||
FILE* __file_;
|
||||
const codecvt<char_type, char, state_type>* __cv_;
|
||||
state_type __st_;
|
||||
state_type __st_last_;
|
||||
ios_base::openmode __om_;
|
||||
ios_base::openmode __cm_;
|
||||
bool __owns_eb_;
|
||||
@@ -254,20 +249,14 @@ basic_filebuf<_CharT, _Traits>::basic_filebuf()
|
||||
__intbuf_(0),
|
||||
__ibs_(0),
|
||||
__file_(0),
|
||||
__cv_(nullptr),
|
||||
__cv_(&use_facet<codecvt<char_type, char, state_type> >(this->getloc())),
|
||||
__st_(),
|
||||
__st_last_(),
|
||||
__om_(0),
|
||||
__cm_(0),
|
||||
__owns_eb_(false),
|
||||
__owns_ib_(false),
|
||||
__always_noconv_(false)
|
||||
__always_noconv_(__cv_->always_noconv())
|
||||
{
|
||||
if (has_facet<codecvt<char_type, char, state_type> >(this->getloc()))
|
||||
{
|
||||
__cv_ = &use_facet<codecvt<char_type, char, state_type> >(this->getloc());
|
||||
__always_noconv_ = __cv_->always_noconv();
|
||||
}
|
||||
setbuf(0, 4096);
|
||||
}
|
||||
|
||||
@@ -295,7 +284,6 @@ basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs)
|
||||
__file_ = __rhs.__file_;
|
||||
__cv_ = __rhs.__cv_;
|
||||
__st_ = __rhs.__st_;
|
||||
__st_last_ = __rhs.__st_last_;
|
||||
__om_ = __rhs.__om_;
|
||||
__cm_ = __rhs.__cm_;
|
||||
__owns_eb_ = __rhs.__owns_eb_;
|
||||
@@ -328,7 +316,6 @@ basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs)
|
||||
__rhs.__ibs_ = 0;
|
||||
__rhs.__file_ = 0;
|
||||
__rhs.__st_ = state_type();
|
||||
__rhs.__st_last_ = state_type();
|
||||
__rhs.__om_ = 0;
|
||||
__rhs.__cm_ = 0;
|
||||
__rhs.__owns_eb_ = false;
|
||||
@@ -344,7 +331,6 @@ basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs)
|
||||
{
|
||||
close();
|
||||
swap(__rhs);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
@@ -407,7 +393,6 @@ basic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs)
|
||||
_VSTD::swap(__file_, __rhs.__file_);
|
||||
_VSTD::swap(__cv_, __rhs.__cv_);
|
||||
_VSTD::swap(__st_, __rhs.__st_);
|
||||
_VSTD::swap(__st_last_, __rhs.__st_last_);
|
||||
_VSTD::swap(__om_, __rhs.__om_);
|
||||
_VSTD::swap(__cm_, __rhs.__cm_);
|
||||
_VSTD::swap(__owns_eb_, __rhs.__owns_eb_);
|
||||
@@ -560,7 +545,7 @@ basic_filebuf<_CharT, _Traits>::close()
|
||||
{
|
||||
__rt = this;
|
||||
unique_ptr<FILE, int(*)(FILE*)> __h(__file_, fclose);
|
||||
if (sync())
|
||||
if ((__cm_ & ios_base::out) && sync())
|
||||
__rt = 0;
|
||||
if (fclose(__h.release()) == 0)
|
||||
__file_ = 0;
|
||||
@@ -602,22 +587,18 @@ basic_filebuf<_CharT, _Traits>::underflow()
|
||||
memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
|
||||
__extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
|
||||
__extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
|
||||
size_t __nmemb = _VSTD::min(static_cast<size_t>(__ibs_ - __unget_sz),
|
||||
size_t __nmemb = _VSTD::min(static_cast<size_t>(this->egptr() - this->eback() - __unget_sz),
|
||||
static_cast<size_t>(__extbufend_ - __extbufnext_));
|
||||
codecvt_base::result __r;
|
||||
__st_last_ = __st_;
|
||||
state_type __svs = __st_;
|
||||
size_t __nr = fread((void*)__extbufnext_, 1, __nmemb, __file_);
|
||||
if (__nr != 0)
|
||||
{
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
if (!__cv_)
|
||||
throw bad_cast();
|
||||
#endif
|
||||
__extbufend_ = __extbufnext_ + __nr;
|
||||
char_type* __inext;
|
||||
__r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_,
|
||||
this->eback() + __unget_sz,
|
||||
this->eback() + __ibs_, __inext);
|
||||
this->egptr(), __inext);
|
||||
if (__r == codecvt_base::noconv)
|
||||
{
|
||||
this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, (char_type*)__extbufend_);
|
||||
@@ -691,10 +672,6 @@ basic_filebuf<_CharT, _Traits>::overflow(int_type __c)
|
||||
codecvt_base::result __r;
|
||||
do
|
||||
{
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
if (!__cv_)
|
||||
throw bad_cast();
|
||||
#endif
|
||||
const char_type* __e;
|
||||
__r = __cv_->out(__st_, this->pbase(), this->pptr(), __e,
|
||||
__extbuf_, __extbuf_ + __ebs_, __extbe);
|
||||
@@ -784,10 +761,6 @@ typename basic_filebuf<_CharT, _Traits>::pos_type
|
||||
basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way,
|
||||
ios_base::openmode)
|
||||
{
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
if (!__cv_)
|
||||
throw bad_cast();
|
||||
#endif
|
||||
int __width = __cv_->encoding();
|
||||
if (__file_ == 0 || (__width <= 0 && __off != 0) || sync())
|
||||
return pos_type(off_type(-1));
|
||||
@@ -822,7 +795,6 @@ basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode)
|
||||
return pos_type(off_type(-1));
|
||||
if (fseeko(__file_, __sp, SEEK_SET))
|
||||
return pos_type(off_type(-1));
|
||||
__st_ = __sp.state();
|
||||
return __sp;
|
||||
}
|
||||
|
||||
@@ -832,10 +804,6 @@ basic_filebuf<_CharT, _Traits>::sync()
|
||||
{
|
||||
if (__file_ == 0)
|
||||
return 0;
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
if (!__cv_)
|
||||
throw bad_cast();
|
||||
#endif
|
||||
if (__cm_ & ios_base::out)
|
||||
{
|
||||
if (this->pptr() != this->pbase())
|
||||
@@ -858,8 +826,6 @@ basic_filebuf<_CharT, _Traits>::sync()
|
||||
else if (__cm_ & ios_base::in)
|
||||
{
|
||||
off_type __c;
|
||||
state_type __state = __st_last_;
|
||||
bool __update_st = false;
|
||||
if (__always_noconv_)
|
||||
__c = this->egptr() - this->gptr();
|
||||
else
|
||||
@@ -872,19 +838,32 @@ basic_filebuf<_CharT, _Traits>::sync()
|
||||
{
|
||||
if (this->gptr() != this->egptr())
|
||||
{
|
||||
const int __off = __cv_->length(__state, __extbuf_,
|
||||
__extbufnext_,
|
||||
this->gptr() - this->eback());
|
||||
__c += __extbufnext_ - __extbuf_ - __off;
|
||||
__update_st = true;
|
||||
reverse(this->gptr(), this->egptr());
|
||||
codecvt_base::result __r;
|
||||
const char_type* __e = this->gptr();
|
||||
char* __extbe;
|
||||
do
|
||||
{
|
||||
__r = __cv_->out(__st_, __e, this->egptr(), __e,
|
||||
__extbuf_, __extbuf_ + __ebs_, __extbe);
|
||||
switch (__r)
|
||||
{
|
||||
case codecvt_base::noconv:
|
||||
__c += this->egptr() - this->gptr();
|
||||
break;
|
||||
case codecvt_base::ok:
|
||||
case codecvt_base::partial:
|
||||
__c += __extbe - __extbuf_;
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
} while (__r == codecvt_base::partial);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (fseeko(__file_, -__c, SEEK_CUR))
|
||||
return -1;
|
||||
if (__update_st)
|
||||
__st_ = __state;
|
||||
__extbufnext_ = __extbufend_ = __extbuf_;
|
||||
this->setg(0, 0, 0);
|
||||
__cm_ = 0;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
1072
include/future
1072
include/future
File diff suppressed because it is too large
Load Diff
@@ -46,60 +46,54 @@ template<class E> const E* end(initializer_list<E> il) noexcept;
|
||||
#include <__config>
|
||||
#include <cstddef>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
namespace std // purposefully not versioned
|
||||
{
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template<class _Ep>
|
||||
template<class _E>
|
||||
class _LIBCPP_VISIBLE initializer_list
|
||||
{
|
||||
const _Ep* __begin_;
|
||||
const _E* __begin_;
|
||||
size_t __size_;
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
initializer_list(const _Ep* __b, size_t __s) _NOEXCEPT
|
||||
initializer_list(const _E* __b, size_t __s) _NOEXCEPT
|
||||
: __begin_(__b),
|
||||
__size_(__s)
|
||||
{}
|
||||
public:
|
||||
typedef _Ep value_type;
|
||||
typedef const _Ep& reference;
|
||||
typedef const _Ep& const_reference;
|
||||
typedef _E value_type;
|
||||
typedef const _E& reference;
|
||||
typedef const _E& const_reference;
|
||||
typedef size_t size_type;
|
||||
|
||||
typedef const _Ep* iterator;
|
||||
typedef const _Ep* const_iterator;
|
||||
typedef const _E* iterator;
|
||||
typedef const _E* const_iterator;
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE initializer_list() _NOEXCEPT : __begin_(nullptr), __size_(0) {}
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE size_t size() const _NOEXCEPT {return __size_;}
|
||||
_LIBCPP_ALWAYS_INLINE const _Ep* begin() const _NOEXCEPT {return __begin_;}
|
||||
_LIBCPP_ALWAYS_INLINE const _Ep* end() const _NOEXCEPT {return __begin_ + __size_;}
|
||||
_LIBCPP_ALWAYS_INLINE const _E* begin() const _NOEXCEPT {return __begin_;}
|
||||
_LIBCPP_ALWAYS_INLINE const _E* end() const _NOEXCEPT {return __begin_ + __size_;}
|
||||
};
|
||||
|
||||
template<class _Ep>
|
||||
template<class _E>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
const _Ep*
|
||||
begin(initializer_list<_Ep> __il) _NOEXCEPT
|
||||
const _E*
|
||||
begin(initializer_list<_E> __il) _NOEXCEPT
|
||||
{
|
||||
return __il.begin();
|
||||
}
|
||||
|
||||
template<class _Ep>
|
||||
template<class _E>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
const _Ep*
|
||||
end(initializer_list<_Ep> __il) _NOEXCEPT
|
||||
const _E*
|
||||
end(initializer_list<_E> __il) _NOEXCEPT
|
||||
{
|
||||
return __il.end();
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
} // std
|
||||
|
||||
#endif // _LIBCPP_INITIALIZER_LIST
|
||||
|
||||
@@ -33,9 +33,7 @@ template <class charT> T10 put_time(const struct tm* tmb, const charT* fmt);
|
||||
#include <__config>
|
||||
#include <istream>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -277,10 +275,10 @@ public:
|
||||
__iom_t7(_MoneyT& __mon, bool __intl)
|
||||
: __mon_(__mon), __intl_(__intl) {}
|
||||
|
||||
template <class _CharT, class _Traits, class _Mp>
|
||||
template <class _CharT, class _Traits, class _M>
|
||||
friend
|
||||
basic_istream<_CharT, _Traits>&
|
||||
operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_Mp>& __x);
|
||||
operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_M>& __x);
|
||||
};
|
||||
|
||||
template <class _CharT, class _Traits, class _MoneyT>
|
||||
@@ -294,11 +292,11 @@ operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x)
|
||||
typename basic_istream<_CharT, _Traits>::sentry __s(__is);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<_CharT, _Traits> _Ip;
|
||||
typedef money_get<_CharT, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<_CharT, _Traits> _I;
|
||||
typedef money_get<_CharT, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
const _Fp& __mf = use_facet<_Fp>(__is.getloc());
|
||||
__mf.get(_Ip(__is), _Ip(), __x.__intl_, __is, __err, __x.__mon_);
|
||||
const _F& __mf = use_facet<_F>(__is.getloc());
|
||||
__mf.get(_I(__is), _I(), __x.__intl_, __is, __err, __x.__mon_);
|
||||
__is.setstate(__err);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
@@ -337,10 +335,10 @@ public:
|
||||
__iom_t8(const _MoneyT& __mon, bool __intl)
|
||||
: __mon_(__mon), __intl_(__intl) {}
|
||||
|
||||
template <class _CharT, class _Traits, class _Mp>
|
||||
template <class _CharT, class _Traits, class _M>
|
||||
friend
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_Mp>& __x);
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_M>& __x);
|
||||
};
|
||||
|
||||
template <class _CharT, class _Traits, class _MoneyT>
|
||||
@@ -354,10 +352,10 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x)
|
||||
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
|
||||
if (__s)
|
||||
{
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _Op;
|
||||
typedef money_put<_CharT, _Op> _Fp;
|
||||
const _Fp& __mf = use_facet<_Fp>(__os.getloc());
|
||||
if (__mf.put(_Op(__os), __x.__intl_, __os, __os.fill(), __x.__mon_).failed())
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _O;
|
||||
typedef money_put<_CharT, _O> _F;
|
||||
const _F& __mf = use_facet<_F>(__os.getloc());
|
||||
if (__mf.put(_O(__os), __x.__intl_, __os, __os.fill(), __x.__mon_).failed())
|
||||
__os.setstate(ios_base::badbit);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
@@ -396,10 +394,10 @@ public:
|
||||
__iom_t9(tm* __tm, const _CharT* __fmt)
|
||||
: __tm_(__tm), __fmt_(__fmt) {}
|
||||
|
||||
template <class _Cp, class _Traits>
|
||||
template <class _C, class _Traits>
|
||||
friend
|
||||
basic_istream<_Cp, _Traits>&
|
||||
operator>>(basic_istream<_Cp, _Traits>& __is, const __iom_t9<_Cp>& __x);
|
||||
basic_istream<_C, _Traits>&
|
||||
operator>>(basic_istream<_C, _Traits>& __is, const __iom_t9<_C>& __x);
|
||||
};
|
||||
|
||||
template <class _CharT, class _Traits>
|
||||
@@ -413,11 +411,11 @@ operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x)
|
||||
typename basic_istream<_CharT, _Traits>::sentry __s(__is);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<_CharT, _Traits> _Ip;
|
||||
typedef time_get<_CharT, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<_CharT, _Traits> _I;
|
||||
typedef time_get<_CharT, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
const _Fp& __tf = use_facet<_Fp>(__is.getloc());
|
||||
__tf.get(_Ip(__is), _Ip(), __is, __err, __x.__tm_,
|
||||
const _F& __tf = use_facet<_F>(__is.getloc());
|
||||
__tf.get(_I(__is), _I(), __is, __err, __x.__tm_,
|
||||
__x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_));
|
||||
__is.setstate(__err);
|
||||
}
|
||||
@@ -457,10 +455,10 @@ public:
|
||||
__iom_t10(const tm* __tm, const _CharT* __fmt)
|
||||
: __tm_(__tm), __fmt_(__fmt) {}
|
||||
|
||||
template <class _Cp, class _Traits>
|
||||
template <class _C, class _Traits>
|
||||
friend
|
||||
basic_ostream<_Cp, _Traits>&
|
||||
operator<<(basic_ostream<_Cp, _Traits>& __os, const __iom_t10<_Cp>& __x);
|
||||
basic_ostream<_C, _Traits>&
|
||||
operator<<(basic_ostream<_C, _Traits>& __os, const __iom_t10<_C>& __x);
|
||||
};
|
||||
|
||||
template <class _CharT, class _Traits>
|
||||
@@ -474,10 +472,10 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x)
|
||||
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
|
||||
if (__s)
|
||||
{
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _Op;
|
||||
typedef time_put<_CharT, _Op> _Fp;
|
||||
const _Fp& __tf = use_facet<_Fp>(__os.getloc());
|
||||
if (__tf.put(_Op(__os), __os, __os.fill(), __x.__tm_,
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _O;
|
||||
typedef time_put<_CharT, _O> _F;
|
||||
const _F& __tf = use_facet<_F>(__os.getloc());
|
||||
if (__tf.put(_O(__os), __os, __os.fill(), __x.__tm_,
|
||||
__x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_)).failed())
|
||||
__os.setstate(ios_base::badbit);
|
||||
}
|
||||
|
||||
99
include/ios
99
include/ios
@@ -29,43 +29,43 @@ public:
|
||||
class failure;
|
||||
|
||||
typedef T1 fmtflags;
|
||||
static constexpr fmtflags boolalpha;
|
||||
static constexpr fmtflags dec;
|
||||
static constexpr fmtflags fixed;
|
||||
static constexpr fmtflags hex;
|
||||
static constexpr fmtflags internal;
|
||||
static constexpr fmtflags left;
|
||||
static constexpr fmtflags oct;
|
||||
static constexpr fmtflags right;
|
||||
static constexpr fmtflags scientific;
|
||||
static constexpr fmtflags showbase;
|
||||
static constexpr fmtflags showpoint;
|
||||
static constexpr fmtflags showpos;
|
||||
static constexpr fmtflags skipws;
|
||||
static constexpr fmtflags unitbuf;
|
||||
static constexpr fmtflags uppercase;
|
||||
static constexpr fmtflags adjustfield;
|
||||
static constexpr fmtflags basefield;
|
||||
static constexpr fmtflags floatfield;
|
||||
static const fmtflags boolalpha;
|
||||
static const fmtflags dec;
|
||||
static const fmtflags fixed;
|
||||
static const fmtflags hex;
|
||||
static const fmtflags internal;
|
||||
static const fmtflags left;
|
||||
static const fmtflags oct;
|
||||
static const fmtflags right;
|
||||
static const fmtflags scientific;
|
||||
static const fmtflags showbase;
|
||||
static const fmtflags showpoint;
|
||||
static const fmtflags showpos;
|
||||
static const fmtflags skipws;
|
||||
static const fmtflags unitbuf;
|
||||
static const fmtflags uppercase;
|
||||
static const fmtflags adjustfield;
|
||||
static const fmtflags basefield;
|
||||
static const fmtflags floatfield;
|
||||
|
||||
typedef T2 iostate;
|
||||
static constexpr iostate badbit;
|
||||
static constexpr iostate eofbit;
|
||||
static constexpr iostate failbit;
|
||||
static constexpr iostate goodbit;
|
||||
static const iostate badbit;
|
||||
static const iostate eofbit;
|
||||
static const iostate failbit;
|
||||
static const iostate goodbit;
|
||||
|
||||
typedef T3 openmode;
|
||||
static constexpr openmode app;
|
||||
static constexpr openmode ate;
|
||||
static constexpr openmode binary;
|
||||
static constexpr openmode in;
|
||||
static constexpr openmode out;
|
||||
static constexpr openmode trunc;
|
||||
static const openmode app;
|
||||
static const openmode ate;
|
||||
static const openmode binary;
|
||||
static const openmode in;
|
||||
static const openmode out;
|
||||
static const openmode trunc;
|
||||
|
||||
typedef T4 seekdir;
|
||||
static constexpr seekdir beg;
|
||||
static constexpr seekdir cur;
|
||||
static constexpr seekdir end;
|
||||
static const seekdir beg;
|
||||
static const seekdir cur;
|
||||
static const seekdir end;
|
||||
|
||||
class Init;
|
||||
|
||||
@@ -160,7 +160,7 @@ protected:
|
||||
basic_ios();
|
||||
void init(basic_streambuf<charT,traits>* sb);
|
||||
void move(basic_ios& rhs);
|
||||
void swap(basic_ios& rhs) noexcept;
|
||||
void swap(basic_ios& rhs);
|
||||
void set_rdbuf(basic_streambuf<charT, traits>* sb);
|
||||
};
|
||||
|
||||
@@ -216,9 +216,7 @@ storage-class-specifier const error_category& iostream_category;
|
||||
#include <__locale>
|
||||
#include <system_error>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -227,7 +225,7 @@ typedef ptrdiff_t streamsize;
|
||||
class _LIBCPP_VISIBLE ios_base
|
||||
{
|
||||
public:
|
||||
class _LIBCPP_VISIBLE failure;
|
||||
class failure;
|
||||
|
||||
typedef unsigned int fmtflags;
|
||||
static const fmtflags boolalpha = 0x0001;
|
||||
@@ -271,7 +269,7 @@ public:
|
||||
typedef _VSTD::streamoff streamoff;
|
||||
typedef _VSTD::streampos streampos;
|
||||
|
||||
class _LIBCPP_VISIBLE Init;
|
||||
class Init;
|
||||
|
||||
// 27.5.2.2 fmtflags state:
|
||||
_LIBCPP_INLINE_VISIBILITY fmtflags flags() const;
|
||||
@@ -342,7 +340,7 @@ protected:
|
||||
void __call_callbacks(event);
|
||||
void copyfmt(const ios_base&);
|
||||
void move(ios_base&);
|
||||
void swap(ios_base&) _NOEXCEPT;
|
||||
void swap(ios_base&);
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
void set_rdbuf(void* __sb)
|
||||
@@ -373,19 +371,21 @@ private:
|
||||
};
|
||||
|
||||
//enum class io_errc
|
||||
_LIBCPP_DECLARE_STRONG_ENUM(io_errc)
|
||||
struct _LIBCPP_VISIBLE io_errc
|
||||
{
|
||||
enum _ {
|
||||
stream = 1
|
||||
};
|
||||
_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc)
|
||||
_ __v_;
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE io_errc(_ __v) : __v_(__v) {}
|
||||
_LIBCPP_ALWAYS_INLINE operator int() const {return __v_;}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct _LIBCPP_VISIBLE is_error_code_enum<io_errc> : public true_type { };
|
||||
|
||||
#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
|
||||
template <>
|
||||
struct _LIBCPP_VISIBLE is_error_code_enum<io_errc::__lx> : public true_type { };
|
||||
#endif
|
||||
struct _LIBCPP_VISIBLE is_error_code_enum<io_errc::_> : public true_type { };
|
||||
|
||||
_LIBCPP_VISIBLE
|
||||
const error_category& iostream_category();
|
||||
@@ -572,8 +572,7 @@ public:
|
||||
typedef typename traits_type::pos_type pos_type;
|
||||
typedef typename traits_type::off_type off_type;
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
_LIBCPP_EXPLICIT
|
||||
_LIBCPP_ALWAYS_INLINE // explicit
|
||||
operator bool() const {return !fail();}
|
||||
_LIBCPP_ALWAYS_INLINE bool operator!() const {return fail();}
|
||||
_LIBCPP_ALWAYS_INLINE iostate rdstate() const {return ios_base::rdstate();}
|
||||
@@ -632,12 +631,12 @@ protected:
|
||||
void move(basic_ios&& __rhs) {move(__rhs);}
|
||||
#endif
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void swap(basic_ios& __rhs) _NOEXCEPT;
|
||||
void swap(basic_ios& __rhs);
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void set_rdbuf(basic_streambuf<char_type, traits_type>* __sb);
|
||||
private:
|
||||
basic_ostream<char_type, traits_type>* __tie_;
|
||||
mutable int_type __fill_;
|
||||
char_type __fill_;
|
||||
};
|
||||
|
||||
template <class _CharT, class _Traits>
|
||||
@@ -659,7 +658,7 @@ basic_ios<_CharT, _Traits>::init(basic_streambuf<char_type, traits_type>* __sb)
|
||||
{
|
||||
ios_base::init(__sb);
|
||||
__tie_ = 0;
|
||||
__fill_ = traits_type::eof();
|
||||
__fill_ = widen(' ');
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits>
|
||||
@@ -731,8 +730,6 @@ inline _LIBCPP_INLINE_VISIBILITY
|
||||
_CharT
|
||||
basic_ios<_CharT, _Traits>::fill() const
|
||||
{
|
||||
if (traits_type::eq_int_type(traits_type::eof(), __fill_))
|
||||
__fill_ = widen(' ');
|
||||
return __fill_;
|
||||
}
|
||||
|
||||
@@ -776,7 +773,7 @@ basic_ios<_CharT, _Traits>::move(basic_ios& __rhs)
|
||||
template <class _CharT, class _Traits>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
void
|
||||
basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs) _NOEXCEPT
|
||||
basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs)
|
||||
{
|
||||
ios_base::swap(__rhs);
|
||||
_VSTD::swap(__tie_, __rhs.__tie_);
|
||||
|
||||
@@ -89,13 +89,11 @@ typedef fpos<char_traits<wchar_t>::state_type> wstreampos;
|
||||
#include <__config>
|
||||
#include <wchar.h> // for mbstate_t
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
class _LIBCPP_VISIBLE ios_base;
|
||||
class ios_base;
|
||||
|
||||
template<class _CharT> struct _LIBCPP_VISIBLE char_traits;
|
||||
template<class _Tp> class _LIBCPP_VISIBLE allocator;
|
||||
|
||||
@@ -40,9 +40,7 @@ extern wostream wclog;
|
||||
#include <istream>
|
||||
#include <ostream>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
486
include/istream
486
include/istream
@@ -155,11 +155,7 @@ template <class charT, class traits, class T>
|
||||
#include <__config>
|
||||
#include <ostream>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -194,7 +190,7 @@ protected:
|
||||
public:
|
||||
|
||||
// 27.7.1.1.3 Prefix/suffix:
|
||||
class _LIBCPP_VISIBLE sentry;
|
||||
class sentry;
|
||||
|
||||
// 27.7.1.2 Formatted input:
|
||||
basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&));
|
||||
@@ -256,7 +252,7 @@ public:
|
||||
// ~sentry() = default;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_EXPLICIT
|
||||
// explicit
|
||||
operator bool() const {return __ok_;}
|
||||
};
|
||||
|
||||
@@ -271,10 +267,10 @@ basic_istream<_CharT, _Traits>::sentry::sentry(basic_istream<_CharT, _Traits>& _
|
||||
__is.tie()->flush();
|
||||
if (!__noskipws && (__is.flags() & ios_base::skipws))
|
||||
{
|
||||
typedef istreambuf_iterator<_CharT, _Traits> _Ip;
|
||||
typedef istreambuf_iterator<_CharT, _Traits> _I;
|
||||
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
|
||||
_Ip __i(__is);
|
||||
_Ip __eof;
|
||||
_I __i(__is);
|
||||
_I __eof;
|
||||
for (; __i != __eof; ++__i)
|
||||
if (!__ct.is(__ct.space, *__i))
|
||||
break;
|
||||
@@ -342,10 +338,10 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<char_type, traits_type> _Ip;
|
||||
typedef num_get<char_type, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef num_get<char_type, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n);
|
||||
use_facet<_F>(this->getloc()).get(_I(*this), _I(), *this, __err, __n);
|
||||
this->setstate(__err);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
@@ -369,10 +365,10 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned int& __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<char_type, traits_type> _Ip;
|
||||
typedef num_get<char_type, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef num_get<char_type, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n);
|
||||
use_facet<_F>(this->getloc()).get(_I(*this), _I(), *this, __err, __n);
|
||||
this->setstate(__err);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
@@ -396,10 +392,10 @@ basic_istream<_CharT, _Traits>::operator>>(long& __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<char_type, traits_type> _Ip;
|
||||
typedef num_get<char_type, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef num_get<char_type, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n);
|
||||
use_facet<_F>(this->getloc()).get(_I(*this), _I(), *this, __err, __n);
|
||||
this->setstate(__err);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
@@ -423,10 +419,10 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned long& __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<char_type, traits_type> _Ip;
|
||||
typedef num_get<char_type, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef num_get<char_type, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n);
|
||||
use_facet<_F>(this->getloc()).get(_I(*this), _I(), *this, __err, __n);
|
||||
this->setstate(__err);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
@@ -450,10 +446,10 @@ basic_istream<_CharT, _Traits>::operator>>(long long& __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<char_type, traits_type> _Ip;
|
||||
typedef num_get<char_type, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef num_get<char_type, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n);
|
||||
use_facet<_F>(this->getloc()).get(_I(*this), _I(), *this, __err, __n);
|
||||
this->setstate(__err);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
@@ -477,10 +473,10 @@ basic_istream<_CharT, _Traits>::operator>>(unsigned long long& __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<char_type, traits_type> _Ip;
|
||||
typedef num_get<char_type, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef num_get<char_type, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n);
|
||||
use_facet<_F>(this->getloc()).get(_I(*this), _I(), *this, __err, __n);
|
||||
this->setstate(__err);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
@@ -504,10 +500,10 @@ basic_istream<_CharT, _Traits>::operator>>(float& __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<char_type, traits_type> _Ip;
|
||||
typedef num_get<char_type, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef num_get<char_type, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n);
|
||||
use_facet<_F>(this->getloc()).get(_I(*this), _I(), *this, __err, __n);
|
||||
this->setstate(__err);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
@@ -531,10 +527,10 @@ basic_istream<_CharT, _Traits>::operator>>(double& __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<char_type, traits_type> _Ip;
|
||||
typedef num_get<char_type, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef num_get<char_type, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n);
|
||||
use_facet<_F>(this->getloc()).get(_I(*this), _I(), *this, __err, __n);
|
||||
this->setstate(__err);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
@@ -558,10 +554,10 @@ basic_istream<_CharT, _Traits>::operator>>(long double& __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<char_type, traits_type> _Ip;
|
||||
typedef num_get<char_type, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef num_get<char_type, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n);
|
||||
use_facet<_F>(this->getloc()).get(_I(*this), _I(), *this, __err, __n);
|
||||
this->setstate(__err);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
@@ -585,10 +581,10 @@ basic_istream<_CharT, _Traits>::operator>>(bool& __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<char_type, traits_type> _Ip;
|
||||
typedef num_get<char_type, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef num_get<char_type, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n);
|
||||
use_facet<_F>(this->getloc()).get(_I(*this), _I(), *this, __err, __n);
|
||||
this->setstate(__err);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
@@ -612,10 +608,10 @@ basic_istream<_CharT, _Traits>::operator>>(void*& __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<char_type, traits_type> _Ip;
|
||||
typedef num_get<char_type, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef num_get<char_type, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n);
|
||||
use_facet<_F>(this->getloc()).get(_I(*this), _I(), *this, __err, __n);
|
||||
this->setstate(__err);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
@@ -639,11 +635,11 @@ basic_istream<_CharT, _Traits>::operator>>(short& __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<char_type, traits_type> _Ip;
|
||||
typedef num_get<char_type, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef num_get<char_type, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
long __temp;
|
||||
use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __temp);
|
||||
use_facet<_F>(this->getloc()).get(_I(*this), _I(), *this, __err, __temp);
|
||||
if (__temp < numeric_limits<short>::min())
|
||||
{
|
||||
__err |= ios_base::failbit;
|
||||
@@ -679,11 +675,11 @@ basic_istream<_CharT, _Traits>::operator>>(int& __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef istreambuf_iterator<char_type, traits_type> _Ip;
|
||||
typedef num_get<char_type, _Ip> _Fp;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef num_get<char_type, _I> _F;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
long __temp;
|
||||
use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __temp);
|
||||
use_facet<_F>(this->getloc()).get(_I(*this), _I(), *this, __err, __temp);
|
||||
if (__temp < numeric_limits<int>::min())
|
||||
{
|
||||
__err |= ios_base::failbit;
|
||||
@@ -746,29 +742,26 @@ operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s)
|
||||
typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
|
||||
if (__sen)
|
||||
{
|
||||
typedef istreambuf_iterator<_CharT, _Traits> _I;
|
||||
streamsize __n = __is.width();
|
||||
if (__n <= 0)
|
||||
if (__n == 0)
|
||||
__n = numeric_limits<streamsize>::max() / sizeof(_CharT) - 1;
|
||||
streamsize __c = 0;
|
||||
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
while (__c < __n-1)
|
||||
_I __i(__is);
|
||||
_I __eof;
|
||||
for (; __i != __eof && __c < __n-1; ++__i, ++__s, ++__c)
|
||||
{
|
||||
typename _Traits::int_type __i = __is.rdbuf()->sgetc();
|
||||
if (_Traits::eq_int_type(__i, _Traits::eof()))
|
||||
{
|
||||
__err |= ios_base::eofbit;
|
||||
break;
|
||||
}
|
||||
_CharT __ch = _Traits::to_char_type(__i);
|
||||
_CharT __ch = *__i;
|
||||
if (__ct.is(__ct.space, __ch))
|
||||
break;
|
||||
*__s++ = __ch;
|
||||
++__c;
|
||||
__is.rdbuf()->sbumpc();
|
||||
*__s = __ch;
|
||||
}
|
||||
*__s = _CharT();
|
||||
__is.width(0);
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
if (__i == __eof)
|
||||
__err |= ios_base::eofbit;
|
||||
if (__c == 0)
|
||||
__err |= ios_base::failbit;
|
||||
__is.setstate(__err);
|
||||
@@ -810,11 +803,25 @@ operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c)
|
||||
typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
|
||||
if (__sen)
|
||||
{
|
||||
#if 1
|
||||
typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
|
||||
if (_Traits::eq_int_type(__i, _Traits::eof()))
|
||||
__is.setstate(ios_base::eofbit | ios_base::failbit);
|
||||
else
|
||||
__c = _Traits::to_char_type(__i);
|
||||
#else
|
||||
typedef istreambuf_iterator<_CharT, _Traits> _I;
|
||||
_I __i(__is);
|
||||
_I __eof;
|
||||
if (__i != __eof)
|
||||
{
|
||||
__c = *__i;
|
||||
if (++__i == __eof)
|
||||
__is.setstate(ios_base::eofbit);
|
||||
}
|
||||
else
|
||||
__is.setstate(ios_base::eofbit | ios_base::failbit);
|
||||
#endif
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
}
|
||||
@@ -854,42 +861,42 @@ basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_typ
|
||||
sentry __s(*this, true);
|
||||
if (__s)
|
||||
{
|
||||
streamsize __c = 0;
|
||||
if (__sb)
|
||||
{
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
try
|
||||
{
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
while (true)
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef ostreambuf_iterator<char_type, traits_type> _O;
|
||||
_I __i(*this);
|
||||
_I __eof;
|
||||
_O __o(__sb);
|
||||
for (; __i != __eof; ++__i, ++__o, ++__c)
|
||||
{
|
||||
typename traits_type::int_type __i = this->rdbuf()->sgetc();
|
||||
if (traits_type::eq_int_type(__i, _Traits::eof()))
|
||||
{
|
||||
__err |= ios_base::eofbit;
|
||||
break;
|
||||
}
|
||||
if (traits_type::eq_int_type(
|
||||
__sb->sputc(traits_type::to_char_type(__i)),
|
||||
traits_type::eof()))
|
||||
*__o = *__i;
|
||||
if (__o.failed())
|
||||
break;
|
||||
++__gc_;
|
||||
this->rdbuf()->sbumpc();
|
||||
}
|
||||
if (__gc_ == 0)
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
if (__i == __eof)
|
||||
__err |= ios_base::eofbit;
|
||||
if (__c == 0)
|
||||
__err |= ios_base::failbit;
|
||||
this->setstate(__err);
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
if (__gc_ == 0)
|
||||
if (__c == 0)
|
||||
this->__set_failbit_and_consider_rethrow();
|
||||
}
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
}
|
||||
else
|
||||
this->setstate(ios_base::failbit);
|
||||
__gc_ = __c;
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
}
|
||||
@@ -914,11 +921,22 @@ basic_istream<_CharT, _Traits>::get()
|
||||
sentry __s(*this, true);
|
||||
if (__s)
|
||||
{
|
||||
__r = this->rdbuf()->sbumpc();
|
||||
if (traits_type::eq_int_type(__r, traits_type::eof()))
|
||||
this->setstate(ios_base::failbit | ios_base::eofbit);
|
||||
streamsize __c = 0;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
_I __i(*this);
|
||||
_I __eof;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
if (__i != __eof)
|
||||
{
|
||||
__r = traits_type::to_int_type(*__i);
|
||||
++__c;
|
||||
if (++__i == __eof)
|
||||
__err |= ios_base::eofbit;
|
||||
}
|
||||
else
|
||||
__gc_ = 1;
|
||||
__err |= ios_base::failbit | ios_base::eofbit;
|
||||
this->setstate(__err);
|
||||
__gc_ = __c;
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
}
|
||||
@@ -953,31 +971,30 @@ basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __
|
||||
sentry __sen(*this, true);
|
||||
if (__sen)
|
||||
{
|
||||
streamsize __c = 0;
|
||||
if (__n > 0)
|
||||
{
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
while (__gc_ < __n-1)
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
_I __i(*this);
|
||||
_I __eof;
|
||||
for (; __i != __eof && __n > 1; ++__i, ++__s, ++__c)
|
||||
{
|
||||
int_type __i = this->rdbuf()->sgetc();
|
||||
if (traits_type::eq_int_type(__i, traits_type::eof()))
|
||||
{
|
||||
__err |= ios_base::eofbit;
|
||||
break;
|
||||
}
|
||||
char_type __ch = traits_type::to_char_type(__i);
|
||||
char_type __ch = *__i;
|
||||
if (traits_type::eq(__ch, __dlm))
|
||||
break;
|
||||
*__s++ = __ch;
|
||||
++__gc_;
|
||||
this->rdbuf()->sbumpc();
|
||||
*__s = __ch;
|
||||
}
|
||||
*__s = char_type();
|
||||
if (__gc_ == 0)
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
if (__i == __eof)
|
||||
__err |= ios_base::eofbit;
|
||||
if (__c == 0)
|
||||
__err |= ios_base::failbit;
|
||||
this->setstate(__err);
|
||||
}
|
||||
else
|
||||
this->setstate(ios_base::failbit);
|
||||
__gc_ = __c;
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
}
|
||||
@@ -1010,36 +1027,38 @@ basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __s
|
||||
sentry __sen(*this, true);
|
||||
if (__sen)
|
||||
{
|
||||
streamsize __c = 0;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
try
|
||||
{
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
while (true)
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
typedef ostreambuf_iterator<char_type, traits_type> _O;
|
||||
_I __i(*this);
|
||||
_I __eof;
|
||||
_O __o(&__sb);
|
||||
for (; __i != __eof; ++__i, ++__o, ++__c)
|
||||
{
|
||||
typename traits_type::int_type __i = this->rdbuf()->sgetc();
|
||||
if (traits_type::eq_int_type(__i, traits_type::eof()))
|
||||
{
|
||||
__err |= ios_base::eofbit;
|
||||
break;
|
||||
}
|
||||
char_type __ch = traits_type::to_char_type(__i);
|
||||
char_type __ch = *__i;
|
||||
if (traits_type::eq(__ch, __dlm))
|
||||
break;
|
||||
if (traits_type::eq_int_type(__sb.sputc(__ch), traits_type::eof()))
|
||||
*__o = __ch;
|
||||
if (__o.failed())
|
||||
break;
|
||||
++__gc_;
|
||||
this->rdbuf()->sbumpc();
|
||||
}
|
||||
if (__i == __eof)
|
||||
__err |= ios_base::eofbit;
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
}
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
if (__gc_ == 0)
|
||||
if (__c == 0)
|
||||
__err |= ios_base::failbit;
|
||||
this->setstate(__err);
|
||||
__gc_ = __c;
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
}
|
||||
@@ -1071,36 +1090,33 @@ basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_typ
|
||||
sentry __sen(*this, true);
|
||||
if (__sen)
|
||||
{
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
while (true)
|
||||
streamsize __c = 0;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
_I __i(*this);
|
||||
_I __eof;
|
||||
for (; __i != __eof; ++__s, --__n)
|
||||
{
|
||||
typename traits_type::int_type __i = this->rdbuf()->sgetc();
|
||||
if (traits_type::eq_int_type(__i, traits_type::eof()))
|
||||
{
|
||||
__err |= ios_base::eofbit;
|
||||
break;
|
||||
}
|
||||
char_type __ch = traits_type::to_char_type(__i);
|
||||
char_type __ch = *__i;
|
||||
++__i;
|
||||
++__c;
|
||||
if (traits_type::eq(__ch, __dlm))
|
||||
break;
|
||||
if (__n < 2)
|
||||
{
|
||||
this->rdbuf()->sbumpc();
|
||||
++__gc_;
|
||||
this->setstate(ios_base::failbit);
|
||||
break;
|
||||
}
|
||||
if (__gc_ >= __n-1)
|
||||
{
|
||||
__err |= ios_base::failbit;
|
||||
break;
|
||||
}
|
||||
*__s++ = __ch;
|
||||
this->rdbuf()->sbumpc();
|
||||
++__gc_;
|
||||
*__s = __ch;
|
||||
}
|
||||
if (__n > 0)
|
||||
if (__n)
|
||||
*__s = char_type();
|
||||
if (__gc_ == 0)
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
if (__i == __eof)
|
||||
__err |= ios_base::eofbit;
|
||||
if (__c == 0)
|
||||
__err |= ios_base::failbit;
|
||||
this->setstate(__err);
|
||||
__gc_ = __c;
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
}
|
||||
@@ -1132,40 +1148,35 @@ basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm)
|
||||
sentry __sen(*this, true);
|
||||
if (__sen)
|
||||
{
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
if (__n == numeric_limits<streamsize>::max())
|
||||
streamsize __c = 0;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
_I __i(*this);
|
||||
_I __eof;
|
||||
if (__n != numeric_limits<streamsize>::max())
|
||||
{
|
||||
while (true)
|
||||
for (; __n > 0 && __i != __eof; --__n)
|
||||
{
|
||||
typename traits_type::int_type __i = this->rdbuf()->sbumpc();
|
||||
if (traits_type::eq_int_type(__i, traits_type::eof()))
|
||||
{
|
||||
__err |= ios_base::eofbit;
|
||||
break;
|
||||
}
|
||||
++__gc_;
|
||||
char_type __ch = traits_type::to_char_type(__i);
|
||||
if (traits_type::eq(__ch, static_cast<char_type>(__dlm)))
|
||||
char_type __ch = *__i;
|
||||
++__i;
|
||||
++__c;
|
||||
if (traits_type::eq(__ch, __dlm))
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (__gc_ < __n)
|
||||
while (__i != __eof)
|
||||
{
|
||||
typename traits_type::int_type __i = this->rdbuf()->sbumpc();
|
||||
if (traits_type::eq_int_type(__i, traits_type::eof()))
|
||||
{
|
||||
__err |= ios_base::eofbit;
|
||||
break;
|
||||
}
|
||||
++__gc_;
|
||||
char_type __ch = traits_type::to_char_type(__i);
|
||||
if (traits_type::eq(__ch, static_cast<char_type>(__dlm)))
|
||||
char_type __ch = *__i;
|
||||
++__i;
|
||||
++__c;
|
||||
if (traits_type::eq(__ch, __dlm))
|
||||
break;
|
||||
}
|
||||
}
|
||||
this->setstate(__err);
|
||||
if (__i == __eof)
|
||||
this->setstate(ios_base::eofbit);
|
||||
__gc_ = __c;
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
}
|
||||
@@ -1189,11 +1200,7 @@ basic_istream<_CharT, _Traits>::peek()
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
sentry __sen(*this, true);
|
||||
if (__sen)
|
||||
{
|
||||
__r = this->rdbuf()->sgetc();
|
||||
if (traits_type::eq_int_type(__r, traits_type::eof()))
|
||||
this->setstate(ios_base::eofbit);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
}
|
||||
catch (...)
|
||||
@@ -1216,16 +1223,20 @@ basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n)
|
||||
sentry __sen(*this, true);
|
||||
if (__sen)
|
||||
{
|
||||
for (; __gc_ < __n; ++__gc_)
|
||||
streamsize __c = 0;
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
_I __i(*this);
|
||||
_I __eof;
|
||||
for (; __i != __eof && __n > 0; ++__i, ++__s, ++__c, --__n)
|
||||
*__s = *__i;
|
||||
if (__i == __eof)
|
||||
{
|
||||
typename traits_type::int_type __i = this->rdbuf()->sbumpc();
|
||||
if (traits_type::eq_int_type(__i, traits_type::eof()))
|
||||
{
|
||||
this->setstate(ios_base::failbit | ios_base::eofbit);
|
||||
break;
|
||||
}
|
||||
*__s++ = traits_type::to_char_type(__i);
|
||||
ios_base::iostate __err = ios_base::eofbit;
|
||||
if (__n > 0)
|
||||
__err |= ios_base::failbit;
|
||||
this->setstate(__err);
|
||||
}
|
||||
__gc_ = __c;
|
||||
}
|
||||
else
|
||||
this->setstate(ios_base::failbit);
|
||||
@@ -1243,19 +1254,45 @@ template<class _CharT, class _Traits>
|
||||
streamsize
|
||||
basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
|
||||
{
|
||||
streamsize __c = this->rdbuf()->in_avail();
|
||||
switch (__c)
|
||||
__gc_ = 0;
|
||||
streamsize __c = 0;
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
try
|
||||
{
|
||||
case -1:
|
||||
this->setstate(ios_base::eofbit);
|
||||
break;
|
||||
case 0:
|
||||
break;
|
||||
default:
|
||||
read(__s, _VSTD::min(__c, __n));
|
||||
break;
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
sentry __sen(*this, true);
|
||||
if (__sen)
|
||||
{
|
||||
typedef istreambuf_iterator<char_type, traits_type> _I;
|
||||
_I __i(*this);
|
||||
_I __eof;
|
||||
__c = this->rdbuf()->in_avail();
|
||||
switch (__c)
|
||||
{
|
||||
case -1:
|
||||
__i = __eof;
|
||||
break;
|
||||
case 0:
|
||||
break;
|
||||
default:
|
||||
__c = _VSTD::min(__c, __n);
|
||||
for (streamsize __k = 0; __k < __c; ++__k, ++__s, ++__i)
|
||||
*__s = *__i;
|
||||
}
|
||||
if (__i == __eof)
|
||||
this->setstate(ios_base::eofbit);
|
||||
__gc_ = __c;
|
||||
}
|
||||
else
|
||||
this->setstate(ios_base::failbit);
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
}
|
||||
return __gc_;
|
||||
catch (...)
|
||||
{
|
||||
this->__set_badbit_and_consider_rethrow();
|
||||
}
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
return __c;
|
||||
}
|
||||
|
||||
template<class _CharT, class _Traits>
|
||||
@@ -1267,7 +1304,6 @@ basic_istream<_CharT, _Traits>::putback(char_type __c)
|
||||
try
|
||||
{
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
this->clear(this->rdstate() & ~ios_base::eofbit);
|
||||
sentry __sen(*this, true);
|
||||
if (__sen)
|
||||
{
|
||||
@@ -1295,7 +1331,6 @@ basic_istream<_CharT, _Traits>::unget()
|
||||
try
|
||||
{
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
this->clear(this->rdstate() & ~ios_base::eofbit);
|
||||
sentry __sen(*this, true);
|
||||
if (__sen)
|
||||
{
|
||||
@@ -1374,7 +1409,6 @@ basic_istream<_CharT, _Traits>::seekg(pos_type __pos)
|
||||
try
|
||||
{
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
this->clear(this->rdstate() & ~ios_base::eofbit);
|
||||
sentry __sen(*this, true);
|
||||
if (__sen)
|
||||
if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1))
|
||||
@@ -1421,19 +1455,15 @@ ws(basic_istream<_CharT, _Traits>& __is)
|
||||
typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
|
||||
if (__sen)
|
||||
{
|
||||
typedef istreambuf_iterator<_CharT, _Traits> _I;
|
||||
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
|
||||
while (true)
|
||||
{
|
||||
typename _Traits::int_type __i = __is.rdbuf()->sgetc();
|
||||
if (_Traits::eq_int_type(__i, _Traits::eof()))
|
||||
{
|
||||
__is.setstate(ios_base::eofbit);
|
||||
break;
|
||||
}
|
||||
if (!__ct.is(__ct.space, _Traits::to_char_type(__i)))
|
||||
_I __i(__is);
|
||||
_I __eof;
|
||||
for (; __i != __eof; ++__i)
|
||||
if (!__ct.is(__ct.space, *__i))
|
||||
break;
|
||||
__is.rdbuf()->sbumpc();
|
||||
}
|
||||
if (__i == __eof)
|
||||
__is.setstate(ios_base::failbit | ios_base::eofbit);
|
||||
}
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
}
|
||||
@@ -1542,30 +1572,27 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
|
||||
if (__sen)
|
||||
{
|
||||
__str.clear();
|
||||
typedef istreambuf_iterator<_CharT, _Traits> _I;
|
||||
streamsize __n = __is.width();
|
||||
if (__n <= 0)
|
||||
if (__n == 0)
|
||||
__n = __str.max_size();
|
||||
if (__n <= 0)
|
||||
if (__n < 0)
|
||||
__n = numeric_limits<streamsize>::max();
|
||||
streamsize __c = 0;
|
||||
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
while (__c < __n)
|
||||
_I __i(__is);
|
||||
_I __eof;
|
||||
for (; __i != __eof && __c < __n; ++__i, ++__c)
|
||||
{
|
||||
typename _Traits::int_type __i = __is.rdbuf()->sgetc();
|
||||
if (_Traits::eq_int_type(__i, _Traits::eof()))
|
||||
{
|
||||
__err |= ios_base::eofbit;
|
||||
break;
|
||||
}
|
||||
_CharT __ch = _Traits::to_char_type(__i);
|
||||
_CharT __ch = *__i;
|
||||
if (__ct.is(__ct.space, __ch))
|
||||
break;
|
||||
__str.push_back(__ch);
|
||||
++__c;
|
||||
__is.rdbuf()->sbumpc();
|
||||
}
|
||||
__is.width(0);
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
if (__i == __eof)
|
||||
__err |= ios_base::eofbit;
|
||||
if (__c == 0)
|
||||
__err |= ios_base::failbit;
|
||||
__is.setstate(__err);
|
||||
@@ -1595,28 +1622,31 @@ getline(basic_istream<_CharT, _Traits>& __is,
|
||||
if (__sen)
|
||||
{
|
||||
__str.clear();
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
streamsize __extr = 0;
|
||||
while (true)
|
||||
streamsize __c = 0;
|
||||
typedef istreambuf_iterator<_CharT, _Traits> _I;
|
||||
_I __i(__is);
|
||||
_I __eof;
|
||||
streamsize __n = __str.max_size();
|
||||
if (__n < 0)
|
||||
__n = numeric_limits<streamsize>::max();
|
||||
for (; __i != __eof;)
|
||||
{
|
||||
typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
|
||||
if (_Traits::eq_int_type(__i, _Traits::eof()))
|
||||
{
|
||||
__err |= ios_base::eofbit;
|
||||
break;
|
||||
}
|
||||
++__extr;
|
||||
_CharT __ch = _Traits::to_char_type(__i);
|
||||
_CharT __ch = *__i;
|
||||
++__i;
|
||||
++__c;
|
||||
if (_Traits::eq(__ch, __dlm))
|
||||
break;
|
||||
__str.push_back(__ch);
|
||||
if (__str.size() == __str.max_size())
|
||||
if (__c == __n)
|
||||
{
|
||||
__err |= ios_base::failbit;
|
||||
__is.setstate(ios_base::failbit);
|
||||
break;
|
||||
}
|
||||
__str.push_back(__ch);
|
||||
}
|
||||
if (__extr == 0)
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
if (__i == __eof)
|
||||
__err |= ios_base::eofbit;
|
||||
if (__c == 0)
|
||||
__err |= ios_base::failbit;
|
||||
__is.setstate(__err);
|
||||
}
|
||||
@@ -1674,26 +1704,24 @@ operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
|
||||
{
|
||||
basic_string<_CharT, _Traits> __str;
|
||||
const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
|
||||
typedef istreambuf_iterator<_CharT, _Traits> _I;
|
||||
streamsize __c = 0;
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
_CharT __zero = __ct.widen('0');
|
||||
_CharT __one = __ct.widen('1');
|
||||
while (__c < _Size)
|
||||
_I __i(__is);
|
||||
_I __eof;
|
||||
for (; __i != __eof && __c < _Size; ++__i, ++__c)
|
||||
{
|
||||
typename _Traits::int_type __i = __is.rdbuf()->sgetc();
|
||||
if (_Traits::eq_int_type(__i, _Traits::eof()))
|
||||
{
|
||||
__err |= ios_base::eofbit;
|
||||
break;
|
||||
}
|
||||
_CharT __ch = _Traits::to_char_type(__i);
|
||||
if (!_Traits::eq(__ch, __zero) && !_Traits::eq(__ch, __one))
|
||||
_CharT __ch = *__i;
|
||||
if (__ch != __zero && __ch != __one)
|
||||
break;
|
||||
__str.push_back(__ch);
|
||||
++__c;
|
||||
__is.rdbuf()->sbumpc();
|
||||
}
|
||||
__is.width(0);
|
||||
__x = bitset<_Size>(__str);
|
||||
ios_base::iostate __err = ios_base::goodbit;
|
||||
if (__i == __eof)
|
||||
__err |= ios_base::eofbit;
|
||||
if (__c == 0)
|
||||
__err |= ios_base::failbit;
|
||||
__is.setstate(__err);
|
||||
@@ -1710,9 +1738,9 @@ operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
|
||||
return __is;
|
||||
}
|
||||
|
||||
_LIBCPP_EXTERN_TEMPLATE(class basic_istream<char>)
|
||||
_LIBCPP_EXTERN_TEMPLATE(class basic_istream<wchar_t>)
|
||||
_LIBCPP_EXTERN_TEMPLATE(class basic_iostream<char>)
|
||||
extern template class basic_istream<char>;
|
||||
extern template class basic_istream<wchar_t>;
|
||||
extern template class basic_iostream<char>;
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
|
||||
314
include/iterator
314
include/iterator
@@ -263,10 +263,10 @@ public:
|
||||
typedef basic_streambuf<charT,traits> streambuf_type;
|
||||
typedef basic_istream<charT,traits> istream_type;
|
||||
|
||||
istreambuf_iterator() noexcept;
|
||||
istreambuf_iterator(istream_type& s) noexcept;
|
||||
istreambuf_iterator(streambuf_type* s) noexcept;
|
||||
istreambuf_iterator(a-private-type) noexcept;
|
||||
istreambuf_iterator() throw();
|
||||
istreambuf_iterator(istream_type& s) throw();
|
||||
istreambuf_iterator(streambuf_type* s) throw();
|
||||
istreambuf_iterator(a-private-type) throw();
|
||||
|
||||
charT operator*() const;
|
||||
pointer operator->() const;
|
||||
@@ -293,13 +293,13 @@ public:
|
||||
typedef basic_streambuf<charT,traits> streambuf_type;
|
||||
typedef basic_ostream<charT,traits> ostream_type;
|
||||
|
||||
ostreambuf_iterator(ostream_type& s) noexcept;
|
||||
ostreambuf_iterator(streambuf_type* s) noexcept;
|
||||
ostreambuf_iterator(ostream_type& s) throw();
|
||||
ostreambuf_iterator(streambuf_type* s) throw();
|
||||
ostreambuf_iterator& operator=(charT c);
|
||||
ostreambuf_iterator& operator*();
|
||||
ostreambuf_iterator& operator++();
|
||||
ostreambuf_iterator& operator++(int);
|
||||
bool failed() const noexcept;
|
||||
bool failed() const throw();
|
||||
};
|
||||
|
||||
template <class C> auto begin(C& c) -> decltype(c.begin());
|
||||
@@ -321,9 +321,7 @@ template <class T, size_t N> T* end(T (&array)[N]);
|
||||
#include <cassert>
|
||||
#endif
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -337,7 +335,7 @@ template <class _Tp>
|
||||
struct __has_iterator_category
|
||||
{
|
||||
private:
|
||||
struct __two {char __lx; char __lxx;};
|
||||
struct __two {char _; char __;};
|
||||
template <class _Up> static __two __test(...);
|
||||
template <class _Up> static char __test(typename _Up::iterator_category* = 0);
|
||||
public:
|
||||
@@ -626,11 +624,11 @@ public:
|
||||
typedef _Container container_type;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY explicit back_insert_iterator(_Container& __x) : container(&__x) {}
|
||||
_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(const typename _Container::value_type& __value_)
|
||||
{container->push_back(__value_); return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(const typename _Container::value_type& __value)
|
||||
{container->push_back(__value); return *this;}
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(typename _Container::value_type&& __value_)
|
||||
{container->push_back(_VSTD::move(__value_)); return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(typename _Container::value_type&& __value)
|
||||
{container->push_back(_VSTD::move(__value)); return *this;}
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator*() {return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator++() {return *this;}
|
||||
@@ -659,11 +657,11 @@ public:
|
||||
typedef _Container container_type;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY explicit front_insert_iterator(_Container& __x) : container(&__x) {}
|
||||
_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(const typename _Container::value_type& __value_)
|
||||
{container->push_front(__value_); return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(const typename _Container::value_type& __value)
|
||||
{container->push_front(__value); return *this;}
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(typename _Container::value_type&& __value_)
|
||||
{container->push_front(_VSTD::move(__value_)); return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(typename _Container::value_type&& __value)
|
||||
{container->push_front(_VSTD::move(__value)); return *this;}
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator*() {return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator++() {return *this;}
|
||||
@@ -694,11 +692,11 @@ public:
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY insert_iterator(_Container& __x, typename _Container::iterator __i)
|
||||
: container(&__x), iter(__i) {}
|
||||
_LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(const typename _Container::value_type& __value_)
|
||||
{iter = container->insert(iter, __value_); ++iter; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(const typename _Container::value_type& __value)
|
||||
{iter = container->insert(iter, __value); ++iter; return *this;}
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
_LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(typename _Container::value_type&& __value_)
|
||||
{iter = container->insert(iter, _VSTD::move(__value_)); ++iter; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(typename _Container::value_type&& __value)
|
||||
{iter = container->insert(iter, _VSTD::move(__value)); ++iter; return *this;}
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
_LIBCPP_INLINE_VISIBILITY insert_iterator& operator*() {return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY insert_iterator& operator++() {return *this;}
|
||||
@@ -769,9 +767,9 @@ public:
|
||||
: __out_stream_(&__s), __delim_(0) {}
|
||||
_LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s, const _CharT* __delimiter)
|
||||
: __out_stream_(&__s), __delim_(__delimiter) {}
|
||||
_LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value_)
|
||||
_LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value)
|
||||
{
|
||||
*__out_stream_ << __value_;
|
||||
*__out_stream_ << __value;
|
||||
if (__delim_)
|
||||
*__out_stream_ << __delim_;
|
||||
return *this;
|
||||
@@ -815,16 +813,15 @@ private:
|
||||
__sbuf_ = 0;
|
||||
}
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator() _NOEXCEPT : __sbuf_(0) {}
|
||||
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator(istream_type& __s) _NOEXCEPT
|
||||
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator() throw() : __sbuf_(0) {}
|
||||
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator(istream_type& __s) throw()
|
||||
: __sbuf_(__s.rdbuf()) {__test_for_eof();}
|
||||
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator(streambuf_type* __s) _NOEXCEPT
|
||||
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator(streambuf_type* __s) throw()
|
||||
: __sbuf_(__s) {__test_for_eof();}
|
||||
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator(const __proxy& __p) _NOEXCEPT
|
||||
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator(const __proxy& __p) throw()
|
||||
: __sbuf_(__p.__sbuf_) {}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY char_type operator*() const
|
||||
{return static_cast<char_type>(__sbuf_->sgetc());}
|
||||
_LIBCPP_INLINE_VISIBILITY _CharT operator*() const {return __sbuf_->sgetc();}
|
||||
_LIBCPP_INLINE_VISIBILITY char_type* operator->() const {return nullptr;}
|
||||
_LIBCPP_INLINE_VISIBILITY istreambuf_iterator& operator++()
|
||||
{
|
||||
@@ -867,9 +864,9 @@ public:
|
||||
private:
|
||||
streambuf_type* __sbuf_;
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(ostream_type& __s) _NOEXCEPT
|
||||
_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(ostream_type& __s) throw()
|
||||
: __sbuf_(__s.rdbuf()) {}
|
||||
_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(streambuf_type* __s) _NOEXCEPT
|
||||
_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(streambuf_type* __s) throw()
|
||||
: __sbuf_(__s) {}
|
||||
_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator=(_CharT __c)
|
||||
{
|
||||
@@ -880,15 +877,7 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator*() {return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++() {return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++(int) {return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY bool failed() const _NOEXCEPT {return __sbuf_ == 0;}
|
||||
|
||||
template <class _Ch, class _Tr>
|
||||
friend
|
||||
_LIBCPP_HIDDEN
|
||||
ostreambuf_iterator<_Ch, _Tr>
|
||||
__pad_and_output(ostreambuf_iterator<_Ch, _Tr> __s,
|
||||
const _Ch* __ob, const _Ch* __op, const _Ch* __oe,
|
||||
ios_base& __iob, _Ch __fl);
|
||||
_LIBCPP_INLINE_VISIBILITY bool failed() const throw() {return __sbuf_ == 0;}
|
||||
};
|
||||
|
||||
template <class _Iter>
|
||||
@@ -1017,52 +1006,43 @@ make_move_iterator(const _Iter& __i)
|
||||
template <class _Iter> class __wrap_iter;
|
||||
|
||||
template <class _Iter1, class _Iter2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
|
||||
|
||||
template <class _Iter1, class _Iter2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
|
||||
|
||||
template <class _Iter1, class _Iter2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
|
||||
|
||||
template <class _Iter1, class _Iter2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
|
||||
|
||||
template <class _Iter1, class _Iter2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
|
||||
|
||||
template <class _Iter1, class _Iter2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
|
||||
|
||||
template <class _Iter1, class _Iter2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
typename __wrap_iter<_Iter1>::difference_type
|
||||
operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
|
||||
|
||||
template <class _Iter>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__wrap_iter<_Iter>
|
||||
operator+(typename __wrap_iter<_Iter>::difference_type, __wrap_iter<_Iter>) _NOEXCEPT;
|
||||
operator+(typename __wrap_iter<_Iter>::difference_type, const __wrap_iter<_Iter>&) _NOEXCEPT;
|
||||
|
||||
template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY copy(_Ip, _Ip, _Op);
|
||||
template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY copy_backward(_B1, _B1, _B2);
|
||||
template <class _Ip, class _Op> _Op _LIBCPP_INLINE_VISIBILITY move(_Ip, _Ip, _Op);
|
||||
template <class _B1, class _B2> _B2 _LIBCPP_INLINE_VISIBILITY move_backward(_B1, _B1, _B2);
|
||||
template <class _I, class _O> _O copy(_I, _I, _O);
|
||||
template <class _B1, class _B2> _B2 copy_backward(_B1, _B1, _B2);
|
||||
template <class _I, class _O> _O move(_I, _I, _O);
|
||||
template <class _B1, class _B2> _B2 move_backward(_B1, _B1, _B2);
|
||||
|
||||
template <class _Tp>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
typename enable_if
|
||||
<
|
||||
is_trivially_copy_assignable<_Tp>::value,
|
||||
@@ -1083,108 +1063,33 @@ public:
|
||||
private:
|
||||
iterator_type __i;
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY __wrap_iter() _NOEXCEPT
|
||||
{
|
||||
#if _LIBCPP_DEBUG_LEVEL >= 2
|
||||
__get_db()->__insert_i(this);
|
||||
#endif
|
||||
}
|
||||
_LIBCPP_INLINE_VISIBILITY __wrap_iter() _NOEXCEPT {}
|
||||
template <class _Up> _LIBCPP_INLINE_VISIBILITY __wrap_iter(const __wrap_iter<_Up>& __u,
|
||||
typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = 0) _NOEXCEPT
|
||||
: __i(__u.base())
|
||||
{
|
||||
#if _LIBCPP_DEBUG_LEVEL >= 2
|
||||
__get_db()->__iterator_copy(this, &__u);
|
||||
#endif
|
||||
}
|
||||
#if _LIBCPP_DEBUG_LEVEL >= 2
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__wrap_iter(const __wrap_iter& __x)
|
||||
: __i(__x.base())
|
||||
{
|
||||
__get_db()->__iterator_copy(this, &__x);
|
||||
}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__wrap_iter& operator=(const __wrap_iter& __x)
|
||||
{
|
||||
if (this != &__x)
|
||||
{
|
||||
__get_db()->__iterator_copy(this, &__x);
|
||||
__i = __x.__i;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
~__wrap_iter()
|
||||
{
|
||||
__get_db()->__erase_i(this);
|
||||
}
|
||||
#endif
|
||||
_LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT
|
||||
{
|
||||
#if _LIBCPP_DEBUG_LEVEL >= 2
|
||||
_LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
|
||||
"Attempted to dereference a non-dereferenceable iterator");
|
||||
#endif
|
||||
return *__i;
|
||||
}
|
||||
: __i(__u.base()) {}
|
||||
_LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT {return *__i;}
|
||||
_LIBCPP_INLINE_VISIBILITY pointer operator->() const _NOEXCEPT {return &(operator*());}
|
||||
_LIBCPP_INLINE_VISIBILITY __wrap_iter& operator++() _NOEXCEPT
|
||||
{
|
||||
#if _LIBCPP_DEBUG_LEVEL >= 2
|
||||
_LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
|
||||
"Attempted to increment non-incrementable iterator");
|
||||
#endif
|
||||
++__i;
|
||||
return *this;
|
||||
}
|
||||
_LIBCPP_INLINE_VISIBILITY __wrap_iter& operator++() _NOEXCEPT {++__i; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY __wrap_iter operator++(int) _NOEXCEPT
|
||||
{__wrap_iter __tmp(*this); ++(*this); return __tmp;}
|
||||
_LIBCPP_INLINE_VISIBILITY __wrap_iter& operator--() _NOEXCEPT
|
||||
{
|
||||
#if _LIBCPP_DEBUG_LEVEL >= 2
|
||||
_LIBCPP_ASSERT(__get_const_db()->__decrementable(this),
|
||||
"Attempted to decrement non-decrementable iterator");
|
||||
#endif
|
||||
--__i;
|
||||
return *this;
|
||||
}
|
||||
{__wrap_iter __tmp(*this); ++__i; return __tmp;}
|
||||
_LIBCPP_INLINE_VISIBILITY __wrap_iter& operator--() _NOEXCEPT {--__i; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY __wrap_iter operator--(int) _NOEXCEPT
|
||||
{__wrap_iter __tmp(*this); --(*this); return __tmp;}
|
||||
{__wrap_iter __tmp(*this); --__i; return __tmp;}
|
||||
_LIBCPP_INLINE_VISIBILITY __wrap_iter operator+ (difference_type __n) const _NOEXCEPT
|
||||
{__wrap_iter __w(*this); __w += __n; return __w;}
|
||||
{return __wrap_iter(__i + __n);}
|
||||
_LIBCPP_INLINE_VISIBILITY __wrap_iter& operator+=(difference_type __n) _NOEXCEPT
|
||||
{
|
||||
#if _LIBCPP_DEBUG_LEVEL >= 2
|
||||
_LIBCPP_ASSERT(__get_const_db()->__addable(this, __n),
|
||||
"Attempted to add/subtract iterator outside of valid range");
|
||||
#endif
|
||||
__i += __n;
|
||||
return *this;
|
||||
}
|
||||
{__i += __n; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY __wrap_iter operator- (difference_type __n) const _NOEXCEPT
|
||||
{return *this + (-__n);}
|
||||
{return __wrap_iter(__i - __n);}
|
||||
_LIBCPP_INLINE_VISIBILITY __wrap_iter& operator-=(difference_type __n) _NOEXCEPT
|
||||
{*this += -__n; return *this;}
|
||||
{__i -= __n; return *this;}
|
||||
_LIBCPP_INLINE_VISIBILITY reference operator[](difference_type __n) const _NOEXCEPT
|
||||
{
|
||||
#if _LIBCPP_DEBUG_LEVEL >= 2
|
||||
_LIBCPP_ASSERT(__get_const_db()->__subscriptable(this, __n),
|
||||
"Attempted to subscript iterator outside of valid range");
|
||||
#endif
|
||||
return __i[__n];
|
||||
}
|
||||
{return __i[__n];}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY iterator_type base() const _NOEXCEPT {return __i;}
|
||||
|
||||
private:
|
||||
_LIBCPP_INLINE_VISIBILITY __wrap_iter(iterator_type __x) _NOEXCEPT : __i(__x) {}
|
||||
#if _LIBCPP_DEBUG_LEVEL >= 2
|
||||
_LIBCPP_INLINE_VISIBILITY __wrap_iter(const void* __p, iterator_type __x) : __i(__x)
|
||||
{
|
||||
__get_db()->__insert_ic(this, __p);
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class _Up> friend class __wrap_iter;
|
||||
template <class _CharT, class _Traits, class _Alloc> friend class basic_string;
|
||||
@@ -1228,11 +1133,11 @@ private:
|
||||
template <class _Iter1>
|
||||
friend
|
||||
__wrap_iter<_Iter1>
|
||||
operator+(typename __wrap_iter<_Iter1>::difference_type, __wrap_iter<_Iter1>) _NOEXCEPT;
|
||||
operator+(typename __wrap_iter<_Iter1>::difference_type, const __wrap_iter<_Iter1>&) _NOEXCEPT;
|
||||
|
||||
template <class _Ip, class _Op> friend _Op copy(_Ip, _Ip, _Op);
|
||||
template <class _I, class _O> friend _O copy(_I, _I, _O);
|
||||
template <class _B1, class _B2> friend _B2 copy_backward(_B1, _B1, _B2);
|
||||
template <class _Ip, class _Op> friend _Op move(_Ip, _Ip, _Op);
|
||||
template <class _I, class _O> friend _O move(_I, _I, _O);
|
||||
template <class _B1, class _B2> friend _B2 move_backward(_B1, _B1, _B2);
|
||||
|
||||
template <class _Tp>
|
||||
@@ -1250,10 +1155,6 @@ inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
|
||||
{
|
||||
#if _LIBCPP_DEBUG_LEVEL >= 2
|
||||
_LIBCPP_ASSERT(__get_const_db()->__comparable(&__x, &__y),
|
||||
"Attempted to compare incomparable iterators");
|
||||
#endif
|
||||
return __x.base() == __y.base();
|
||||
}
|
||||
|
||||
@@ -1262,10 +1163,6 @@ inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
|
||||
{
|
||||
#if _LIBCPP_DEBUG_LEVEL >= 2
|
||||
_LIBCPP_ASSERT(__get_const_db()->__comparable(&__x, &__y),
|
||||
"Attempted to compare incomparable iterators");
|
||||
#endif
|
||||
return __x.base() < __y.base();
|
||||
}
|
||||
|
||||
@@ -1274,7 +1171,7 @@ inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
|
||||
{
|
||||
return !(__x == __y);
|
||||
return __x.base() != __y.base();
|
||||
}
|
||||
|
||||
template <class _Iter1, class _Iter2>
|
||||
@@ -1282,7 +1179,7 @@ inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
|
||||
{
|
||||
return __y < __x;
|
||||
return __x.base() > __y.base();
|
||||
}
|
||||
|
||||
template <class _Iter1, class _Iter2>
|
||||
@@ -1290,7 +1187,7 @@ inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
|
||||
{
|
||||
return !(__x < __y);
|
||||
return __x.base() >= __y.base();
|
||||
}
|
||||
|
||||
template <class _Iter1, class _Iter2>
|
||||
@@ -1298,39 +1195,7 @@ inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
|
||||
{
|
||||
return !(__y < __x);
|
||||
}
|
||||
|
||||
template <class _Iter1>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
|
||||
{
|
||||
return !(__x == __y);
|
||||
}
|
||||
|
||||
template <class _Iter1>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
|
||||
{
|
||||
return __y < __x;
|
||||
}
|
||||
|
||||
template <class _Iter1>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
|
||||
{
|
||||
return !(__x < __y);
|
||||
}
|
||||
|
||||
template <class _Iter1>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
|
||||
{
|
||||
return !(__y < __x);
|
||||
return __x.base() <= __y.base();
|
||||
}
|
||||
|
||||
template <class _Iter1, class _Iter2>
|
||||
@@ -1338,10 +1203,6 @@ inline _LIBCPP_INLINE_VISIBILITY
|
||||
typename __wrap_iter<_Iter1>::difference_type
|
||||
operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
|
||||
{
|
||||
#if _LIBCPP_DEBUG_LEVEL >= 2
|
||||
_LIBCPP_ASSERT(__get_const_db()->__comparable(&__x, &__y),
|
||||
"Attempted to subtract incompatible iterators");
|
||||
#endif
|
||||
return __x.base() - __y.base();
|
||||
}
|
||||
|
||||
@@ -1349,10 +1210,9 @@ template <class _Iter>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
__wrap_iter<_Iter>
|
||||
operator+(typename __wrap_iter<_Iter>::difference_type __n,
|
||||
__wrap_iter<_Iter> __x) _NOEXCEPT
|
||||
const __wrap_iter<_Iter>& __x) _NOEXCEPT
|
||||
{
|
||||
__x += __n;
|
||||
return __x;
|
||||
return __wrap_iter<_Iter>(__x.base() + __n);
|
||||
}
|
||||
|
||||
#ifdef _LIBCPP_DEBUG
|
||||
@@ -1362,42 +1222,34 @@ operator+(typename __wrap_iter<_Iter>::difference_type __n,
|
||||
template <class _Container, class _Iter> class __debug_iter;
|
||||
|
||||
template <class _Container, class _Iter1, class _Iter2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator==(const __debug_iter<_Container, _Iter1>&, const __debug_iter<_Container, _Iter2>&);
|
||||
|
||||
template <class _Container, class _Iter1, class _Iter2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator<(const __debug_iter<_Container, _Iter1>&, const __debug_iter<_Container, _Iter2>&);
|
||||
|
||||
template <class _Container, class _Iter1, class _Iter2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator!=(const __debug_iter<_Container, _Iter1>&, const __debug_iter<_Container, _Iter2>&);
|
||||
|
||||
template <class _Container, class _Iter1, class _Iter2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator>(const __debug_iter<_Container, _Iter1>&, const __debug_iter<_Container, _Iter2>&);
|
||||
|
||||
template <class _Container, class _Iter1, class _Iter2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator>=(const __debug_iter<_Container, _Iter1>&, const __debug_iter<_Container, _Iter2>&);
|
||||
|
||||
template <class _Container, class _Iter1, class _Iter2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator<=(const __debug_iter<_Container, _Iter1>&, const __debug_iter<_Container, _Iter2>&);
|
||||
|
||||
template <class _Container, class _Iter1, class _Iter2>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
typename __debug_iter<_Container, _Iter1>::difference_type
|
||||
operator-(const __debug_iter<_Container, _Iter1>&, const __debug_iter<_Container, _Iter2>&);
|
||||
|
||||
template <class _Container, class _Iter>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__debug_iter<_Container, _Iter>
|
||||
operator+(typename __debug_iter<_Container, _Iter>::difference_type, const __debug_iter<_Container, _Iter>&);
|
||||
|
||||
@@ -1773,88 +1625,88 @@ operator+(typename __debug_iter<_Container, _Iter>::difference_type __n,
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
auto
|
||||
begin(_Cp& __c) -> decltype(__c.begin())
|
||||
begin(_C& __c) -> decltype(__c.begin())
|
||||
{
|
||||
return __c.begin();
|
||||
}
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
auto
|
||||
begin(const _Cp& __c) -> decltype(__c.begin())
|
||||
begin(const _C& __c) -> decltype(__c.begin())
|
||||
{
|
||||
return __c.begin();
|
||||
}
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
auto
|
||||
end(_Cp& __c) -> decltype(__c.end())
|
||||
end(_C& __c) -> decltype(__c.end())
|
||||
{
|
||||
return __c.end();
|
||||
}
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
auto
|
||||
end(const _Cp& __c) -> decltype(__c.end())
|
||||
end(const _C& __c) -> decltype(__c.end())
|
||||
{
|
||||
return __c.end();
|
||||
}
|
||||
|
||||
#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
typename _Cp::iterator
|
||||
begin(_Cp& __c)
|
||||
typename _C::iterator
|
||||
begin(_C& __c)
|
||||
{
|
||||
return __c.begin();
|
||||
}
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
typename _Cp::const_iterator
|
||||
begin(const _Cp& __c)
|
||||
typename _C::const_iterator
|
||||
begin(const _C& __c)
|
||||
{
|
||||
return __c.begin();
|
||||
}
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
typename _Cp::iterator
|
||||
end(_Cp& __c)
|
||||
typename _C::iterator
|
||||
end(_C& __c)
|
||||
{
|
||||
return __c.end();
|
||||
}
|
||||
|
||||
template <class _Cp>
|
||||
template <class _C>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
typename _Cp::const_iterator
|
||||
end(const _Cp& __c)
|
||||
typename _C::const_iterator
|
||||
end(const _C& __c)
|
||||
{
|
||||
return __c.end();
|
||||
}
|
||||
|
||||
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
|
||||
|
||||
template <class _Tp, size_t _Np>
|
||||
template <class _T, size_t _N>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_Tp*
|
||||
begin(_Tp (&__array)[_Np])
|
||||
_T*
|
||||
begin(_T (&__array)[_N])
|
||||
{
|
||||
return __array;
|
||||
}
|
||||
|
||||
template <class _Tp, size_t _Np>
|
||||
template <class _T, size_t _N>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_Tp*
|
||||
end(_Tp (&__array)[_Np])
|
||||
_T*
|
||||
end(_T (&__array)[_N])
|
||||
{
|
||||
return __array + _Np;
|
||||
return __array + _N;
|
||||
}
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
916
include/limits
916
include/limits
File diff suppressed because it is too large
Load Diff
739
include/list
739
include/list
File diff suppressed because it is too large
Load Diff
662
include/locale
662
include/locale
File diff suppressed because it is too large
Load Diff
380
include/map
380
include/map
@@ -375,21 +375,15 @@ swap(multimap<Key, T, Compare, Allocator>& x,
|
||||
#include <functional>
|
||||
#include <initializer_list>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, bool = is_empty<_Compare>::value
|
||||
#if __has_feature(is_final)
|
||||
&& !__is_final(_Compare)
|
||||
#endif
|
||||
>
|
||||
template <class _Key, class _Tp, class _Compare, bool = is_empty<_Compare>::value>
|
||||
class __map_value_compare
|
||||
: private _Compare
|
||||
{
|
||||
typedef pair<typename std::remove_const<_Key>::type, _Tp> _Pp;
|
||||
typedef pair<typename std::remove_const<_Key>::type, _Tp> _P;
|
||||
typedef pair<const _Key, _Tp> _CP;
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -406,25 +400,25 @@ public:
|
||||
bool operator()(const _CP& __x, const _CP& __y) const
|
||||
{return static_cast<const _Compare&>(*this)(__x.first, __y.first);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _CP& __x, const _Pp& __y) const
|
||||
bool operator()(const _CP& __x, const _P& __y) const
|
||||
{return static_cast<const _Compare&>(*this)(__x.first, __y.first);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _CP& __x, const _Key& __y) const
|
||||
{return static_cast<const _Compare&>(*this)(__x.first, __y);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _Pp& __x, const _CP& __y) const
|
||||
bool operator()(const _P& __x, const _CP& __y) const
|
||||
{return static_cast<const _Compare&>(*this)(__x.first, __y.first);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _Pp& __x, const _Pp& __y) const
|
||||
bool operator()(const _P& __x, const _P& __y) const
|
||||
{return static_cast<const _Compare&>(*this)(__x.first, __y.first);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _Pp& __x, const _Key& __y) const
|
||||
bool operator()(const _P& __x, const _Key& __y) const
|
||||
{return static_cast<const _Compare&>(*this)(__x.first, __y);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _Key& __x, const _CP& __y) const
|
||||
{return static_cast<const _Compare&>(*this)(__x, __y.first);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _Key& __x, const _Pp& __y) const
|
||||
bool operator()(const _Key& __x, const _P& __y) const
|
||||
{return static_cast<const _Compare&>(*this)(__x, __y.first);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _Key& __x, const _Key& __y) const
|
||||
@@ -436,7 +430,7 @@ class __map_value_compare<_Key, _Tp, _Compare, false>
|
||||
{
|
||||
_Compare comp;
|
||||
|
||||
typedef pair<typename std::remove_const<_Key>::type, _Tp> _Pp;
|
||||
typedef pair<typename std::remove_const<_Key>::type, _Tp> _P;
|
||||
typedef pair<const _Key, _Tp> _CP;
|
||||
|
||||
public:
|
||||
@@ -455,25 +449,25 @@ public:
|
||||
bool operator()(const _CP& __x, const _CP& __y) const
|
||||
{return comp(__x.first, __y.first);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _CP& __x, const _Pp& __y) const
|
||||
bool operator()(const _CP& __x, const _P& __y) const
|
||||
{return comp(__x.first, __y.first);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _CP& __x, const _Key& __y) const
|
||||
{return comp(__x.first, __y);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _Pp& __x, const _CP& __y) const
|
||||
bool operator()(const _P& __x, const _CP& __y) const
|
||||
{return comp(__x.first, __y.first);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _Pp& __x, const _Pp& __y) const
|
||||
bool operator()(const _P& __x, const _P& __y) const
|
||||
{return comp(__x.first, __y.first);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _Pp& __x, const _Key& __y) const
|
||||
bool operator()(const _P& __x, const _Key& __y) const
|
||||
{return comp(__x.first, __y);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _Key& __x, const _CP& __y) const
|
||||
{return comp(__x, __y.first);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _Key& __x, const _Pp& __y) const
|
||||
bool operator()(const _Key& __x, const _P& __y) const
|
||||
{return comp(__x, __y.first);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool operator()(const _Key& __x, const _Key& __y) const
|
||||
@@ -779,18 +773,6 @@ public:
|
||||
|
||||
map(map&& __m, const allocator_type& __a);
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
map& operator=(map&& __m)
|
||||
_NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
|
||||
{
|
||||
__tree_ = _VSTD::move(__m.__tree_);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
map(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
|
||||
: __tree_(__vc(__comp))
|
||||
@@ -805,6 +787,14 @@ public:
|
||||
insert(__il.begin(), __il.end());
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
map& operator=(map&& __m)
|
||||
_NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
|
||||
{
|
||||
__tree_ = _VSTD::move(__m.__tree_);
|
||||
return *this;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
map& operator=(initializer_list<value_type> __il)
|
||||
{
|
||||
@@ -812,7 +802,7 @@ public:
|
||||
return *this;
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit map(const allocator_type& __a)
|
||||
@@ -880,29 +870,59 @@ public:
|
||||
value_compare value_comp() const {return value_compare(__tree_.value_comp().key_comp());}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
pair<iterator, bool>
|
||||
emplace() {return __tree_.__emplace_unique();}
|
||||
|
||||
template <class _A0,
|
||||
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
pair<iterator, bool>
|
||||
emplace(_A0&& __a0)
|
||||
{return __tree_.__emplace_unique(_VSTD::forward<_A0>(__a0));}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class ..._Args>
|
||||
template <class _A0, class ..._Args,
|
||||
class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
|
||||
pair<iterator, bool>
|
||||
emplace(_Args&& ...__args);
|
||||
|
||||
template <class ..._Args>
|
||||
iterator
|
||||
emplace_hint(const_iterator __p, _Args&& ...__args);
|
||||
emplace(_A0&& __a0, _Args&& ...__args);
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class _Pp,
|
||||
class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
pair<iterator, bool> insert(_Pp&& __p)
|
||||
{return __tree_.__insert_unique(_VSTD::forward<_Pp>(__p));}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator
|
||||
emplace_hint(const_iterator __p)
|
||||
{return __tree_.__emplace_hint_unique(__p.__i_);}
|
||||
|
||||
template <class _Pp,
|
||||
class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
|
||||
template <class _A0,
|
||||
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(const_iterator __pos, _Pp&& __p)
|
||||
{return __tree_.__insert_unique(__pos.__i_, _VSTD::forward<_Pp>(__p));}
|
||||
iterator
|
||||
emplace_hint(const_iterator __p, _A0&& __a0)
|
||||
{return __tree_.__emplace_hint_unique(__p.__i_, _VSTD::forward<_A0>(__a0));}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class _A0, class ..._Args,
|
||||
class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
|
||||
iterator
|
||||
emplace_hint(const_iterator __p, _A0&& __a0, _Args&& ...__args);
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class _P,
|
||||
class = typename enable_if<is_constructible<value_type, _P>::value>::type>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
pair<iterator, bool> insert(_P&& __p)
|
||||
{return __tree_.__insert_unique(_VSTD::forward<_P>(__p));}
|
||||
|
||||
template <class _P,
|
||||
class = typename enable_if<is_constructible<value_type, _P>::value>::type>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(const_iterator __pos, _P&& __p)
|
||||
{return __tree_.__insert_unique(__pos.__i_, _VSTD::forward<_P>(__p));}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
@@ -923,14 +943,10 @@ public:
|
||||
insert(__e.__i_, *__f);
|
||||
}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void insert(initializer_list<value_type> __il)
|
||||
{insert(__il.begin(), __il.end());}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator erase(const_iterator __p) {return __tree_.erase(__p.__i_);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -980,28 +996,18 @@ private:
|
||||
typedef typename __base::__node_const_pointer __node_const_pointer;
|
||||
typedef typename __base::__node_base_pointer __node_base_pointer;
|
||||
typedef typename __base::__node_base_const_pointer __node_base_const_pointer;
|
||||
typedef __map_node_destructor<__node_allocator> _Dp;
|
||||
typedef unique_ptr<__node, _Dp> __node_holder;
|
||||
typedef __map_node_destructor<__node_allocator> _D;
|
||||
typedef unique_ptr<__node, _D> __node_holder;
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
__node_holder __construct_node();
|
||||
template <class _A0>
|
||||
typename enable_if
|
||||
<
|
||||
is_constructible<value_type, _A0>::value,
|
||||
__node_holder
|
||||
>::type
|
||||
__construct_node(_A0&& __a0);
|
||||
template <class _A0>
|
||||
typename enable_if
|
||||
<
|
||||
is_constructible<key_type, _A0>::value,
|
||||
__node_holder
|
||||
>::type
|
||||
__construct_node(_A0&& __a0);
|
||||
template <class _A0,
|
||||
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
|
||||
__node_holder __construct_node(_A0&& __a0);
|
||||
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
||||
template <class _A0, class _A1, class ..._Args>
|
||||
__node_holder __construct_node(_A0&& __a0, _A1&& __a1, _Args&& ...__args);
|
||||
template <class _A0, class ..._Args,
|
||||
class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
|
||||
__node_holder __construct_node(_A0&& __a0, _Args&& ...__args);
|
||||
#endif // _LIBCPP_HAS_NO_VARIADICS
|
||||
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
__node_holder __construct_node(const key_type& __k);
|
||||
@@ -1186,7 +1192,7 @@ typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
|
||||
map<_Key, _Tp, _Compare, _Allocator>::__construct_node()
|
||||
{
|
||||
__node_allocator& __na = __tree_.__node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first));
|
||||
__h.get_deleter().__first_constructed = true;
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
|
||||
@@ -1195,53 +1201,32 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node()
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
||||
template <class _A0>
|
||||
typename enable_if
|
||||
<
|
||||
is_constructible<pair<const _Key, _Tp>, _A0>::value,
|
||||
typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
|
||||
>::type
|
||||
template <class _A0,
|
||||
class>
|
||||
typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
|
||||
map<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
|
||||
{
|
||||
__node_allocator& __na = __tree_.__node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::forward<_A0>(__a0));
|
||||
__h.get_deleter().__first_constructed = true;
|
||||
__h.get_deleter().__second_constructed = true;
|
||||
return __h;
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
||||
template <class _A0>
|
||||
typename enable_if
|
||||
<
|
||||
is_constructible<_Key, _A0>::value,
|
||||
typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
|
||||
>::type
|
||||
map<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
|
||||
{
|
||||
__node_allocator& __na = __tree_.__node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), _VSTD::forward<_A0>(__a0));
|
||||
__h.get_deleter().__first_constructed = true;
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
|
||||
__h.get_deleter().__second_constructed = true;
|
||||
return __h;
|
||||
}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
||||
template <class _A0, class _A1, class ..._Args>
|
||||
template <class _A0, class ..._Args,
|
||||
class>
|
||||
typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
|
||||
map<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _A1&& __a1, _Args&& ...__args)
|
||||
map<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _Args&& ...__args)
|
||||
{
|
||||
__node_allocator& __na = __tree_.__node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_),
|
||||
_VSTD::forward<_A0>(__a0), _VSTD::forward<_A1>(__a1),
|
||||
_VSTD::forward<_Args>(__args)...);
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), _VSTD::forward<_A0>(__a0));
|
||||
__h.get_deleter().__first_constructed = true;
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second), _VSTD::forward<_Args>(__args)...);
|
||||
__h.get_deleter().__second_constructed = true;
|
||||
return __h;
|
||||
}
|
||||
@@ -1255,7 +1240,7 @@ typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
|
||||
map<_Key, _Tp, _Compare, _Allocator>::__construct_node(const key_type& __k)
|
||||
{
|
||||
__node_allocator& __na = __tree_.__node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), __k);
|
||||
__h.get_deleter().__first_constructed = true;
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
|
||||
@@ -1330,11 +1315,14 @@ map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) const
|
||||
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
||||
template <class ..._Args>
|
||||
template <class _A0, class ..._Args,
|
||||
class //= typename enable_if<is_constructible<_Key, _A0>::value>::type
|
||||
>
|
||||
pair<typename map<_Key, _Tp, _Compare, _Allocator>::iterator, bool>
|
||||
map<_Key, _Tp, _Compare, _Allocator>::emplace(_Args&& ...__args)
|
||||
map<_Key, _Tp, _Compare, _Allocator>::emplace(_A0&& __a0, _Args&& ...__args)
|
||||
{
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_A0>(__a0),
|
||||
_VSTD::forward<_Args>(__args)...);
|
||||
pair<iterator, bool> __r = __tree_.__node_insert_unique(__h.get());
|
||||
if (__r.second)
|
||||
__h.release();
|
||||
@@ -1342,12 +1330,15 @@ map<_Key, _Tp, _Compare, _Allocator>::emplace(_Args&& ...__args)
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
||||
template <class ..._Args>
|
||||
template <class _A0, class ..._Args,
|
||||
class //= typename enable_if<is_constructible<_Key, _A0>::value>::type
|
||||
>
|
||||
typename map<_Key, _Tp, _Compare, _Allocator>::iterator
|
||||
map<_Key, _Tp, _Compare, _Allocator>::emplace_hint(const_iterator __p,
|
||||
_Args&& ...__args)
|
||||
_A0&& __a0, _Args&& ...__args)
|
||||
{
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_A0>(__a0),
|
||||
_VSTD::forward<_Args>(__args)...);
|
||||
iterator __r = __tree_.__node_insert_unique(__p.__i_, __h.get());
|
||||
if (__r.__i_.__ptr_ == __h.get())
|
||||
__h.release();
|
||||
@@ -1531,18 +1522,6 @@ public:
|
||||
|
||||
multimap(multimap&& __m, const allocator_type& __a);
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
multimap& operator=(multimap&& __m)
|
||||
_NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
|
||||
{
|
||||
__tree_ = _VSTD::move(__m.__tree_);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
multimap(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
|
||||
: __tree_(__vc(__comp))
|
||||
@@ -1557,14 +1536,21 @@ public:
|
||||
insert(__il.begin(), __il.end());
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
multimap& operator=(multimap&& __m)
|
||||
_NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
|
||||
{
|
||||
__tree_ = _VSTD::move(__m.__tree_);
|
||||
return *this;
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
multimap& operator=(initializer_list<value_type> __il)
|
||||
{
|
||||
__tree_.__assign_multi(__il.begin(), __il.end());
|
||||
return *this;
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit multimap(const allocator_type& __a)
|
||||
@@ -1624,29 +1610,57 @@ public:
|
||||
{return value_compare(__tree_.value_comp().key_comp());}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator emplace() {return __tree_.__emplace_multi();}
|
||||
|
||||
template <class _A0,
|
||||
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator
|
||||
emplace(_A0&& __a0)
|
||||
{return __tree_.__emplace_multi(_VSTD::forward<_A0>(__a0));}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class ..._Args>
|
||||
template <class _A0, class ..._Args,
|
||||
class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
|
||||
iterator
|
||||
emplace(_Args&& ...__args);
|
||||
|
||||
template <class ..._Args>
|
||||
iterator
|
||||
emplace_hint(const_iterator __p, _Args&& ...__args);
|
||||
emplace(_A0&& __a0, _Args&& ...__args);
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class _Pp,
|
||||
class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(_Pp&& __p)
|
||||
{return __tree_.__insert_multi(_VSTD::forward<_Pp>(__p));}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator emplace_hint(const_iterator __p)
|
||||
{return __tree_.__emplace_hint_multi(__p.__i_);}
|
||||
|
||||
template <class _Pp,
|
||||
class = typename enable_if<is_constructible<value_type, _Pp>::value>::type>
|
||||
template <class _A0,
|
||||
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(const_iterator __pos, _Pp&& __p)
|
||||
{return __tree_.__insert_multi(__pos.__i_, _VSTD::forward<_Pp>(__p));}
|
||||
iterator
|
||||
emplace_hint(const_iterator __p, _A0&& __a0)
|
||||
{return __tree_.__emplace_hint_multi(__p.__i_, _VSTD::forward<_A0>(__a0));}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class _A0, class ..._Args,
|
||||
class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
|
||||
iterator
|
||||
emplace_hint(const_iterator __p, _A0&& __a0, _Args&& ...__args);
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class _P,
|
||||
class = typename enable_if<is_constructible<value_type, _P>::value>::type>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(_P&& __p)
|
||||
{return __tree_.__insert_multi(_VSTD::forward<_P>(__p));}
|
||||
|
||||
template <class _P,
|
||||
class = typename enable_if<is_constructible<value_type, _P>::value>::type>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(const_iterator __pos, _P&& __p)
|
||||
{return __tree_.__insert_multi(__pos.__i_, _VSTD::forward<_P>(__p));}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
@@ -1665,14 +1679,10 @@ public:
|
||||
__tree_.__insert_multi(__e.__i_, *__f);
|
||||
}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void insert(initializer_list<value_type> __il)
|
||||
{insert(__il.begin(), __il.end());}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator erase(const_iterator __p) {return __tree_.erase(__p.__i_);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -1719,28 +1729,18 @@ private:
|
||||
typedef typename __base::__node_allocator __node_allocator;
|
||||
typedef typename __base::__node_pointer __node_pointer;
|
||||
typedef typename __base::__node_const_pointer __node_const_pointer;
|
||||
typedef __map_node_destructor<__node_allocator> _Dp;
|
||||
typedef unique_ptr<__node, _Dp> __node_holder;
|
||||
typedef __map_node_destructor<__node_allocator> _D;
|
||||
typedef unique_ptr<__node, _D> __node_holder;
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
__node_holder __construct_node();
|
||||
template <class _A0>
|
||||
typename enable_if
|
||||
<
|
||||
is_constructible<value_type, _A0>::value,
|
||||
__node_holder
|
||||
>::type
|
||||
__construct_node(_A0&& __a0);
|
||||
template <class _A0>
|
||||
typename enable_if
|
||||
<
|
||||
is_constructible<key_type, _A0>::value,
|
||||
__node_holder
|
||||
>::type
|
||||
__construct_node(_A0&& __a0);
|
||||
template <class _A0,
|
||||
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
|
||||
__node_holder __construct_node(_A0&& __a0);
|
||||
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
||||
template <class _A0, class _A1, class ..._Args>
|
||||
__node_holder __construct_node(_A0&& __a0, _A1&& __a1, _Args&& ...__args);
|
||||
template <class _A0, class ..._Args,
|
||||
class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
|
||||
__node_holder __construct_node(_A0&& __a0, _Args&& ...__args);
|
||||
#endif // _LIBCPP_HAS_NO_VARIADICS
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
};
|
||||
@@ -1765,7 +1765,7 @@ typename multimap<_Key, _Tp, _Compare, _Allocator>::__node_holder
|
||||
multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node()
|
||||
{
|
||||
__node_allocator& __na = __tree_.__node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first));
|
||||
__h.get_deleter().__first_constructed = true;
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
|
||||
@@ -1774,53 +1774,34 @@ multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node()
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
||||
template <class _A0>
|
||||
typename enable_if
|
||||
<
|
||||
is_constructible<pair<const _Key, _Tp>, _A0>::value,
|
||||
typename multimap<_Key, _Tp, _Compare, _Allocator>::__node_holder
|
||||
>::type
|
||||
template <class _A0,
|
||||
class // = typename enable_if<is_constructible<value_type, _A0>::value>::type
|
||||
>
|
||||
typename multimap<_Key, _Tp, _Compare, _Allocator>::__node_holder
|
||||
multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
|
||||
{
|
||||
__node_allocator& __na = __tree_.__node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::forward<_A0>(__a0));
|
||||
__h.get_deleter().__first_constructed = true;
|
||||
__h.get_deleter().__second_constructed = true;
|
||||
return __h;
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
||||
template <class _A0>
|
||||
typename enable_if
|
||||
<
|
||||
is_constructible<_Key, _A0>::value,
|
||||
typename multimap<_Key, _Tp, _Compare, _Allocator>::__node_holder
|
||||
>::type
|
||||
multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
|
||||
{
|
||||
__node_allocator& __na = __tree_.__node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), _VSTD::forward<_A0>(__a0));
|
||||
__h.get_deleter().__first_constructed = true;
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
|
||||
__h.get_deleter().__second_constructed = true;
|
||||
return __h;
|
||||
}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
||||
template <class _A0, class _A1, class ..._Args>
|
||||
template <class _A0, class ..._Args,
|
||||
class // = typename enable_if<is_constructible<key_type, _A0>::value>::type
|
||||
>
|
||||
typename multimap<_Key, _Tp, _Compare, _Allocator>::__node_holder
|
||||
multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _A1&& __a1, _Args&& ...__args)
|
||||
multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _Args&& ...__args)
|
||||
{
|
||||
__node_allocator& __na = __tree_.__node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_),
|
||||
_VSTD::forward<_A0>(__a0), _VSTD::forward<_A1>(__a1),
|
||||
_VSTD::forward<_Args>(__args)...);
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), _VSTD::forward<_A0>(__a0));
|
||||
__h.get_deleter().__first_constructed = true;
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second), _VSTD::forward<_Args>(__args)...);
|
||||
__h.get_deleter().__second_constructed = true;
|
||||
return __h;
|
||||
}
|
||||
@@ -1831,23 +1812,30 @@ multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _A1&& __
|
||||
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
||||
template <class ..._Args>
|
||||
template <class _A0, class ..._Args,
|
||||
class //= typename enable_if<is_constructible<_Key, _A0>::value>::type
|
||||
>
|
||||
typename multimap<_Key, _Tp, _Compare, _Allocator>::iterator
|
||||
multimap<_Key, _Tp, _Compare, _Allocator>::emplace(_Args&& ...__args)
|
||||
multimap<_Key, _Tp, _Compare, _Allocator>::emplace(_A0&& __a0, _Args&& ...__args)
|
||||
{
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_A0>(__a0),
|
||||
_VSTD::forward<_Args>(__args)...);
|
||||
iterator __r = __tree_.__node_insert_multi(__h.get());
|
||||
__h.release();
|
||||
return __r;
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Compare, class _Allocator>
|
||||
template <class ..._Args>
|
||||
template <class _A0, class ..._Args,
|
||||
class //= typename enable_if<is_constructible<_Key, _A0>::value>::type
|
||||
>
|
||||
typename multimap<_Key, _Tp, _Compare, _Allocator>::iterator
|
||||
multimap<_Key, _Tp, _Compare, _Allocator>::emplace_hint(const_iterator __p,
|
||||
_A0&& __a0,
|
||||
_Args&& ...__args)
|
||||
{
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
|
||||
__node_holder __h = __construct_node(_VSTD::forward<_A0>(__a0),
|
||||
_VSTD::forward<_Args>(__args)...);
|
||||
iterator __r = __tree_.__node_insert_multi(__p.__i_, __h.get());
|
||||
__h.release();
|
||||
return __r;
|
||||
|
||||
1702
include/memory
1702
include/memory
File diff suppressed because it is too large
Load Diff
@@ -20,7 +20,7 @@ namespace std
|
||||
class mutex
|
||||
{
|
||||
public:
|
||||
constexpr mutex() noexcept;
|
||||
mutex();
|
||||
~mutex();
|
||||
|
||||
mutex(const mutex&) = delete;
|
||||
@@ -44,7 +44,7 @@ public:
|
||||
recursive_mutex& operator=(const recursive_mutex&) = delete;
|
||||
|
||||
void lock();
|
||||
bool try_lock() noexcept;
|
||||
bool try_lock();
|
||||
void unlock();
|
||||
|
||||
typedef pthread_mutex_t* native_handle_type;
|
||||
@@ -79,7 +79,7 @@ public:
|
||||
recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
|
||||
|
||||
void lock();
|
||||
bool try_lock() noexcept;
|
||||
bool try_lock();
|
||||
template <class Rep, class Period>
|
||||
bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
|
||||
template <class Clock, class Duration>
|
||||
@@ -114,9 +114,9 @@ class unique_lock
|
||||
{
|
||||
public:
|
||||
typedef Mutex mutex_type;
|
||||
unique_lock() noexcept;
|
||||
unique_lock();
|
||||
explicit unique_lock(mutex_type& m);
|
||||
unique_lock(mutex_type& m, defer_lock_t) noexcept;
|
||||
unique_lock(mutex_type& m, defer_lock_t);
|
||||
unique_lock(mutex_type& m, try_to_lock_t);
|
||||
unique_lock(mutex_type& m, adopt_lock_t);
|
||||
template <class Clock, class Duration>
|
||||
@@ -128,8 +128,8 @@ public:
|
||||
unique_lock(unique_lock const&) = delete;
|
||||
unique_lock& operator=(unique_lock const&) = delete;
|
||||
|
||||
unique_lock(unique_lock&& u) noexcept;
|
||||
unique_lock& operator=(unique_lock&& u) noexcept;
|
||||
unique_lock(unique_lock&& u);
|
||||
unique_lock& operator=(unique_lock&& u);
|
||||
|
||||
void lock();
|
||||
bool try_lock();
|
||||
@@ -141,16 +141,16 @@ public:
|
||||
|
||||
void unlock();
|
||||
|
||||
void swap(unique_lock& u) noexcept;
|
||||
mutex_type* release() noexcept;
|
||||
void swap(unique_lock& u);
|
||||
mutex_type* release();
|
||||
|
||||
bool owns_lock() const noexcept;
|
||||
explicit operator bool () const noexcept;
|
||||
mutex_type* mutex() const noexcept;
|
||||
bool owns_lock() const;
|
||||
explicit operator bool () const;
|
||||
mutex_type* mutex() const;
|
||||
};
|
||||
|
||||
template <class Mutex>
|
||||
void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
|
||||
void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y);
|
||||
|
||||
template <class L1, class L2, class... L3>
|
||||
int try_lock(L1&, L2&, L3&...);
|
||||
@@ -159,7 +159,7 @@ template <class L1, class L2, class... L3>
|
||||
|
||||
struct once_flag
|
||||
{
|
||||
constexpr once_flag() noexcept;
|
||||
constexpr once_flag();
|
||||
|
||||
once_flag(const once_flag&) = delete;
|
||||
once_flag& operator=(const once_flag&) = delete;
|
||||
@@ -179,11 +179,7 @@ template<class Callable, class ...Args>
|
||||
#include <tuple>
|
||||
#endif
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -201,8 +197,8 @@ private:
|
||||
|
||||
public:
|
||||
void lock();
|
||||
bool try_lock() _NOEXCEPT;
|
||||
void unlock() _NOEXCEPT;
|
||||
bool try_lock();
|
||||
void unlock();
|
||||
|
||||
typedef pthread_mutex_t* native_handle_type;
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -224,14 +220,14 @@ private:
|
||||
|
||||
public:
|
||||
void lock();
|
||||
bool try_lock() _NOEXCEPT;
|
||||
bool try_lock();
|
||||
template <class _Rep, class _Period>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
|
||||
{return try_lock_until(chrono::steady_clock::now() + __d);}
|
||||
template <class _Clock, class _Duration>
|
||||
bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
|
||||
void unlock() _NOEXCEPT;
|
||||
void unlock();
|
||||
};
|
||||
|
||||
template <class _Clock, class _Duration>
|
||||
@@ -267,14 +263,14 @@ private:
|
||||
|
||||
public:
|
||||
void lock();
|
||||
bool try_lock() _NOEXCEPT;
|
||||
bool try_lock();
|
||||
template <class _Rep, class _Period>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
|
||||
{return try_lock_until(chrono::steady_clock::now() + __d);}
|
||||
template <class _Clock, class _Duration>
|
||||
bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
|
||||
void unlock() _NOEXCEPT;
|
||||
void unlock();
|
||||
};
|
||||
|
||||
template <class _Clock, class _Duration>
|
||||
@@ -425,27 +421,25 @@ lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
struct _LIBCPP_VISIBLE once_flag;
|
||||
struct once_flag;
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template<class _Callable, class... _Args>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void call_once(once_flag&, _Callable&&, _Args&&...);
|
||||
void call_once(once_flag&, _Callable&&, _Args&&...);
|
||||
|
||||
#else // _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template<class _Callable>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void call_once(once_flag&, _Callable);
|
||||
void call_once(once_flag&, _Callable);
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
struct _LIBCPP_VISIBLE once_flag
|
||||
{
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
once_flag() _NOEXCEPT : __state_(0) {}
|
||||
// constexpr
|
||||
once_flag() {}
|
||||
|
||||
private:
|
||||
once_flag(const once_flag&); // = delete;
|
||||
@@ -466,23 +460,23 @@ private:
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class _Fp>
|
||||
template <class _F>
|
||||
class __call_once_param
|
||||
{
|
||||
_Fp __f_;
|
||||
_F __f_;
|
||||
public:
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit __call_once_param(_Fp&& __f) : __f_(_VSTD::move(__f)) {}
|
||||
explicit __call_once_param(_F&& __f) : __f_(_VSTD::move(__f)) {}
|
||||
#else
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit __call_once_param(const _Fp& __f) : __f_(__f) {}
|
||||
explicit __call_once_param(const _F& __f) : __f_(__f) {}
|
||||
#endif
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void operator()()
|
||||
{
|
||||
typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
|
||||
typedef typename __make_tuple_indices<tuple_size<_F>::value, 1>::type _Index;
|
||||
__execute(_Index());
|
||||
}
|
||||
|
||||
@@ -497,17 +491,17 @@ private:
|
||||
|
||||
#else
|
||||
|
||||
template <class _Fp>
|
||||
template <class _F>
|
||||
class __call_once_param
|
||||
{
|
||||
_Fp __f_;
|
||||
_F __f_;
|
||||
public:
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit __call_once_param(_Fp&& __f) : __f_(_VSTD::move(__f)) {}
|
||||
explicit __call_once_param(_F&& __f) : __f_(_VSTD::move(__f)) {}
|
||||
#else
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
explicit __call_once_param(const _Fp& __f) : __f_(__f) {}
|
||||
explicit __call_once_param(const _F& __f) : __f_(__f) {}
|
||||
#endif
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -519,11 +513,11 @@ public:
|
||||
|
||||
#endif
|
||||
|
||||
template <class _Fp>
|
||||
template <class _F>
|
||||
void
|
||||
__call_once_proxy(void* __vp)
|
||||
{
|
||||
__call_once_param<_Fp>* __p = static_cast<__call_once_param<_Fp>*>(__vp);
|
||||
__call_once_param<_F>* __p = static_cast<__call_once_param<_F>*>(__vp);
|
||||
(*__p)();
|
||||
}
|
||||
|
||||
@@ -536,12 +530,12 @@ inline _LIBCPP_INLINE_VISIBILITY
|
||||
void
|
||||
call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args)
|
||||
{
|
||||
if (__flag.__state_ != ~0ul)
|
||||
if (__builtin_expect(__flag.__state_ , ~0ul) != ~0ul)
|
||||
{
|
||||
typedef tuple<typename decay<_Callable>::type, typename decay<_Args>::type...> _Gp;
|
||||
__call_once_param<_Gp> __p(_Gp(__decay_copy(_VSTD::forward<_Callable>(__func)),
|
||||
typedef tuple<typename decay<_Callable>::type, typename decay<_Args>::type...> _G;
|
||||
__call_once_param<_G> __p(_G(__decay_copy(_VSTD::forward<_Callable>(__func)),
|
||||
__decay_copy(_VSTD::forward<_Args>(__args))...));
|
||||
__call_once(__flag.__state_, &__p, &__call_once_proxy<_Gp>);
|
||||
__call_once(__flag.__state_, &__p, &__call_once_proxy<_G>);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -56,9 +56,7 @@ void operator delete[](void* ptr, void*) noexcept;
|
||||
#include <exception>
|
||||
#include <cstddef>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
namespace std // purposefully not using versioning namespace
|
||||
{
|
||||
@@ -96,7 +94,7 @@ _LIBCPP_VISIBLE void* operator new(std::size_t __sz)
|
||||
throw(std::bad_alloc)
|
||||
#endif
|
||||
;
|
||||
_LIBCPP_VISIBLE void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
|
||||
_LIBCPP_VISIBLE void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT;
|
||||
_LIBCPP_VISIBLE void operator delete(void* __p) _NOEXCEPT;
|
||||
_LIBCPP_VISIBLE void operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT;
|
||||
|
||||
@@ -105,7 +103,7 @@ _LIBCPP_VISIBLE void* operator new[](std::size_t __sz)
|
||||
throw(std::bad_alloc)
|
||||
#endif
|
||||
;
|
||||
_LIBCPP_VISIBLE void* operator new[](std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _NOALIAS;
|
||||
_LIBCPP_VISIBLE void* operator new[](std::size_t __sz, const std::nothrow_t&) _NOEXCEPT;
|
||||
_LIBCPP_VISIBLE void operator delete[](void* __p) _NOEXCEPT;
|
||||
_LIBCPP_VISIBLE void operator delete[](void* __p, const std::nothrow_t&) _NOEXCEPT;
|
||||
|
||||
|
||||
@@ -60,9 +60,7 @@ template <class ForwardIterator, class T>
|
||||
#include <__config>
|
||||
#include <iterator>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -186,10 +184,10 @@ adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterat
|
||||
template <class _ForwardIterator, class _Tp>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
void
|
||||
iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value_)
|
||||
iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
|
||||
{
|
||||
for (; __first != __last; ++__first, ++__value_)
|
||||
*__first = __value_;
|
||||
for (; __first != __last; ++__first, ++__value)
|
||||
*__first = __value;
|
||||
}
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
132
include/ostream
132
include/ostream
@@ -133,9 +133,7 @@ template <class charT, class traits, class T>
|
||||
#include <iterator>
|
||||
#include <bitset>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -169,7 +167,7 @@ protected:
|
||||
public:
|
||||
|
||||
// 27.7.2.4 Prefix/suffix:
|
||||
class _LIBCPP_VISIBLE sentry;
|
||||
class sentry;
|
||||
|
||||
// 27.7.2.6 Formatted output:
|
||||
basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&));
|
||||
@@ -220,7 +218,7 @@ public:
|
||||
~sentry();
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
_LIBCPP_EXPLICIT
|
||||
// explicit
|
||||
operator bool() const {return __ok_;}
|
||||
};
|
||||
|
||||
@@ -342,11 +340,11 @@ basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_typ
|
||||
try
|
||||
{
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
typedef istreambuf_iterator<_CharT, _Traits> _Ip;
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _Op;
|
||||
_Ip __i(__sb);
|
||||
_Ip __eof;
|
||||
_Op __o(*this);
|
||||
typedef istreambuf_iterator<_CharT, _Traits> _I;
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _O;
|
||||
_I __i(__sb);
|
||||
_I __eof;
|
||||
_O __o(*this);
|
||||
size_t __c = 0;
|
||||
for (; __i != __eof; ++__i, ++__o, ++__c)
|
||||
{
|
||||
@@ -388,8 +386,8 @@ basic_ostream<_CharT, _Traits>::operator<<(bool __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
||||
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F;
|
||||
const _F& __f = use_facet<_F>(this->getloc());
|
||||
if (__f.put(*this, *this, this->fill(), __n).failed())
|
||||
this->setstate(ios_base::badbit | ios_base::failbit);
|
||||
}
|
||||
@@ -415,8 +413,8 @@ basic_ostream<_CharT, _Traits>::operator<<(short __n)
|
||||
if (__s)
|
||||
{
|
||||
ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
||||
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F;
|
||||
const _F& __f = use_facet<_F>(this->getloc());
|
||||
if (__f.put(*this, *this, this->fill(),
|
||||
__flags == ios_base::oct || __flags == ios_base::hex ?
|
||||
static_cast<long>(static_cast<unsigned short>(__n)) :
|
||||
@@ -444,8 +442,8 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
||||
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F;
|
||||
const _F& __f = use_facet<_F>(this->getloc());
|
||||
if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
|
||||
this->setstate(ios_base::badbit | ios_base::failbit);
|
||||
}
|
||||
@@ -471,8 +469,8 @@ basic_ostream<_CharT, _Traits>::operator<<(int __n)
|
||||
if (__s)
|
||||
{
|
||||
ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
||||
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F;
|
||||
const _F& __f = use_facet<_F>(this->getloc());
|
||||
if (__f.put(*this, *this, this->fill(),
|
||||
__flags == ios_base::oct || __flags == ios_base::hex ?
|
||||
static_cast<long>(static_cast<unsigned int>(__n)) :
|
||||
@@ -500,8 +498,8 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
||||
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F;
|
||||
const _F& __f = use_facet<_F>(this->getloc());
|
||||
if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
|
||||
this->setstate(ios_base::badbit | ios_base::failbit);
|
||||
}
|
||||
@@ -526,8 +524,8 @@ basic_ostream<_CharT, _Traits>::operator<<(long __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
||||
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F;
|
||||
const _F& __f = use_facet<_F>(this->getloc());
|
||||
if (__f.put(*this, *this, this->fill(), __n).failed())
|
||||
this->setstate(ios_base::badbit | ios_base::failbit);
|
||||
}
|
||||
@@ -552,8 +550,8 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
||||
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F;
|
||||
const _F& __f = use_facet<_F>(this->getloc());
|
||||
if (__f.put(*this, *this, this->fill(), __n).failed())
|
||||
this->setstate(ios_base::badbit | ios_base::failbit);
|
||||
}
|
||||
@@ -578,8 +576,8 @@ basic_ostream<_CharT, _Traits>::operator<<(long long __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
||||
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F;
|
||||
const _F& __f = use_facet<_F>(this->getloc());
|
||||
if (__f.put(*this, *this, this->fill(), __n).failed())
|
||||
this->setstate(ios_base::badbit | ios_base::failbit);
|
||||
}
|
||||
@@ -604,8 +602,8 @@ basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
||||
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F;
|
||||
const _F& __f = use_facet<_F>(this->getloc());
|
||||
if (__f.put(*this, *this, this->fill(), __n).failed())
|
||||
this->setstate(ios_base::badbit | ios_base::failbit);
|
||||
}
|
||||
@@ -630,8 +628,8 @@ basic_ostream<_CharT, _Traits>::operator<<(float __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
||||
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F;
|
||||
const _F& __f = use_facet<_F>(this->getloc());
|
||||
if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed())
|
||||
this->setstate(ios_base::badbit | ios_base::failbit);
|
||||
}
|
||||
@@ -656,8 +654,8 @@ basic_ostream<_CharT, _Traits>::operator<<(double __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
||||
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F;
|
||||
const _F& __f = use_facet<_F>(this->getloc());
|
||||
if (__f.put(*this, *this, this->fill(), __n).failed())
|
||||
this->setstate(ios_base::badbit | ios_base::failbit);
|
||||
}
|
||||
@@ -682,8 +680,8 @@ basic_ostream<_CharT, _Traits>::operator<<(long double __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
||||
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F;
|
||||
const _F& __f = use_facet<_F>(this->getloc());
|
||||
if (__f.put(*this, *this, this->fill(), __n).failed())
|
||||
this->setstate(ios_base::badbit | ios_base::failbit);
|
||||
}
|
||||
@@ -708,8 +706,8 @@ basic_ostream<_CharT, _Traits>::operator<<(const void* __n)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
||||
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
||||
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F;
|
||||
const _F& __f = use_facet<_F>(this->getloc());
|
||||
if (__f.put(*this, *this, this->fill(), __n).failed())
|
||||
this->setstate(ios_base::badbit | ios_base::failbit);
|
||||
}
|
||||
@@ -734,8 +732,8 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c)
|
||||
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
|
||||
if (__s)
|
||||
{
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
|
||||
if (__pad_and_output(_Ip(__os),
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _I;
|
||||
if (__pad_and_output(_I(__os),
|
||||
&__c,
|
||||
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
||||
&__c + 1 :
|
||||
@@ -767,8 +765,8 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn)
|
||||
if (__s)
|
||||
{
|
||||
_CharT __c = __os.widen(__cn);
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
|
||||
if (__pad_and_output(_Ip(__os),
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _I;
|
||||
if (__pad_and_output(_I(__os),
|
||||
&__c,
|
||||
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
||||
&__c + 1 :
|
||||
@@ -799,8 +797,8 @@ operator<<(basic_ostream<char, _Traits>& __os, char __c)
|
||||
typename basic_ostream<char, _Traits>::sentry __s(__os);
|
||||
if (__s)
|
||||
{
|
||||
typedef ostreambuf_iterator<char, _Traits> _Ip;
|
||||
if (__pad_and_output(_Ip(__os),
|
||||
typedef ostreambuf_iterator<char, _Traits> _I;
|
||||
if (__pad_and_output(_I(__os),
|
||||
&__c,
|
||||
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
||||
&__c + 1 :
|
||||
@@ -831,8 +829,8 @@ operator<<(basic_ostream<char, _Traits>& __os, signed char __c)
|
||||
typename basic_ostream<char, _Traits>::sentry __s(__os);
|
||||
if (__s)
|
||||
{
|
||||
typedef ostreambuf_iterator<char, _Traits> _Ip;
|
||||
if (__pad_and_output(_Ip(__os),
|
||||
typedef ostreambuf_iterator<char, _Traits> _I;
|
||||
if (__pad_and_output(_I(__os),
|
||||
(char*)&__c,
|
||||
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
||||
(char*)&__c + 1 :
|
||||
@@ -863,8 +861,8 @@ operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c)
|
||||
typename basic_ostream<char, _Traits>::sentry __s(__os);
|
||||
if (__s)
|
||||
{
|
||||
typedef ostreambuf_iterator<char, _Traits> _Ip;
|
||||
if (__pad_and_output(_Ip(__os),
|
||||
typedef ostreambuf_iterator<char, _Traits> _I;
|
||||
if (__pad_and_output(_I(__os),
|
||||
(char*)&__c,
|
||||
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
||||
(char*)&__c + 1 :
|
||||
@@ -895,9 +893,9 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str)
|
||||
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
|
||||
if (__s)
|
||||
{
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _I;
|
||||
size_t __len = _Traits::length(__str);
|
||||
if (__pad_and_output(_Ip(__os),
|
||||
if (__pad_and_output(_I(__os),
|
||||
__str,
|
||||
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
||||
__str + __len :
|
||||
@@ -928,7 +926,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn)
|
||||
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
|
||||
if (__s)
|
||||
{
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _I;
|
||||
size_t __len = char_traits<char>::length(__strn);
|
||||
const int __bs = 100;
|
||||
_CharT __wbb[__bs];
|
||||
@@ -943,7 +941,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn)
|
||||
}
|
||||
for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)
|
||||
*__p = __os.widen(*__strn);
|
||||
if (__pad_and_output(_Ip(__os),
|
||||
if (__pad_and_output(_I(__os),
|
||||
__wb,
|
||||
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
||||
__wb + __len :
|
||||
@@ -974,9 +972,9 @@ operator<<(basic_ostream<char, _Traits>& __os, const char* __str)
|
||||
typename basic_ostream<char, _Traits>::sentry __s(__os);
|
||||
if (__s)
|
||||
{
|
||||
typedef ostreambuf_iterator<char, _Traits> _Ip;
|
||||
typedef ostreambuf_iterator<char, _Traits> _I;
|
||||
size_t __len = _Traits::length(__str);
|
||||
if (__pad_and_output(_Ip(__os),
|
||||
if (__pad_and_output(_I(__os),
|
||||
__str,
|
||||
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
||||
__str + __len :
|
||||
@@ -1007,9 +1005,9 @@ operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str)
|
||||
typename basic_ostream<char, _Traits>::sentry __s(__os);
|
||||
if (__s)
|
||||
{
|
||||
typedef ostreambuf_iterator<char, _Traits> _Ip;
|
||||
typedef ostreambuf_iterator<char, _Traits> _I;
|
||||
size_t __len = _Traits::length((const char*)__str);
|
||||
if (__pad_and_output(_Ip(__os),
|
||||
if (__pad_and_output(_I(__os),
|
||||
(const char*)__str,
|
||||
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
||||
(const char*)__str + __len :
|
||||
@@ -1040,9 +1038,9 @@ operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str)
|
||||
typename basic_ostream<char, _Traits>::sentry __s(__os);
|
||||
if (__s)
|
||||
{
|
||||
typedef ostreambuf_iterator<char, _Traits> _Ip;
|
||||
typedef ostreambuf_iterator<char, _Traits> _I;
|
||||
size_t __len = _Traits::length((const char*)__str);
|
||||
if (__pad_and_output(_Ip(__os),
|
||||
if (__pad_and_output(_I(__os),
|
||||
(const char*)__str,
|
||||
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
||||
(const char*)__str + __len :
|
||||
@@ -1073,8 +1071,8 @@ basic_ostream<_CharT, _Traits>::put(char_type __c)
|
||||
sentry __s(*this);
|
||||
if (__s)
|
||||
{
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _Op;
|
||||
_Op __o(*this);
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _O;
|
||||
_O __o(*this);
|
||||
*__o = __c;
|
||||
if (__o.failed())
|
||||
this->setstate(ios_base::badbit);
|
||||
@@ -1100,8 +1098,8 @@ basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n)
|
||||
sentry __sen(*this);
|
||||
if (__sen && __n)
|
||||
{
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _Op;
|
||||
_Op __o(*this);
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _O;
|
||||
_O __o(*this);
|
||||
for (; __n; --__n, ++__o, ++__s)
|
||||
{
|
||||
*__o = *__s;
|
||||
@@ -1218,12 +1216,12 @@ typename enable_if
|
||||
<
|
||||
!is_lvalue_reference<_Stream>::value &&
|
||||
is_base_of<ios_base, _Stream>::value,
|
||||
_Stream&&
|
||||
_Stream&
|
||||
>::type
|
||||
operator<<(_Stream&& __os, const _Tp& __x)
|
||||
{
|
||||
__os << __x;
|
||||
return _VSTD::move(__os);
|
||||
return __os;
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
@@ -1240,9 +1238,9 @@ operator<<(basic_ostream<_CharT, _Traits>& __os,
|
||||
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
|
||||
if (__s)
|
||||
{
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
|
||||
typedef ostreambuf_iterator<_CharT, _Traits> _I;
|
||||
size_t __len = __str.size();
|
||||
if (__pad_and_output(_Ip(__os),
|
||||
if (__pad_and_output(_I(__os),
|
||||
__str.data(),
|
||||
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
||||
__str.data() + __len :
|
||||
@@ -1270,10 +1268,10 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec)
|
||||
return __os << __ec.category().name() << ':' << __ec.value();
|
||||
}
|
||||
|
||||
template<class _CharT, class _Traits, class _Yp>
|
||||
template<class _CharT, class _Traits, class _Y>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p)
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Y> const& __p)
|
||||
{
|
||||
return __os << __p.get();
|
||||
}
|
||||
@@ -1287,8 +1285,8 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
|
||||
use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
|
||||
}
|
||||
|
||||
_LIBCPP_EXTERN_TEMPLATE(class basic_ostream<char>)
|
||||
_LIBCPP_EXTERN_TEMPLATE(class basic_ostream<wchar_t>)
|
||||
extern template class basic_ostream<char>;
|
||||
extern template class basic_ostream<wchar_t>;
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
|
||||
@@ -171,21 +171,17 @@ template <class T, class Container, class Compare>
|
||||
#include <functional>
|
||||
#include <algorithm>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _Tp, class _Container> class _LIBCPP_VISIBLE queue;
|
||||
template <class _Tp, class _Container> class queue;
|
||||
|
||||
template <class _Tp, class _Container>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);
|
||||
|
||||
template <class _Tp, class _Container>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);
|
||||
|
||||
|
||||
1032
include/random
1032
include/random
File diff suppressed because it is too large
Load Diff
@@ -70,11 +70,7 @@ typedef ratio<1000000000000000000000000, 1> yotta; // not supported
|
||||
#include <climits>
|
||||
#include <type_traits>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -92,12 +88,6 @@ struct __static_gcd<_Xp, 0>
|
||||
static const intmax_t value = _Xp;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct __static_gcd<0, 0>
|
||||
{
|
||||
static const intmax_t value = 1;
|
||||
};
|
||||
|
||||
// __static_lcm
|
||||
|
||||
template <intmax_t _Xp, intmax_t _Yp>
|
||||
@@ -414,27 +404,27 @@ struct __ratio_less1
|
||||
static const bool value = _Odd ? _Q2 < _Q1 : _Q1 < _Q2;
|
||||
};
|
||||
|
||||
template <class _R1, class _R2, bool _Odd, intmax_t _Qp>
|
||||
struct __ratio_less1<_R1, _R2, _Odd, _Qp, 0, _Qp, 0>
|
||||
template <class _R1, class _R2, bool _Odd, intmax_t _Q>
|
||||
struct __ratio_less1<_R1, _R2, _Odd, _Q, 0, _Q, 0>
|
||||
{
|
||||
static const bool value = false;
|
||||
};
|
||||
|
||||
template <class _R1, class _R2, bool _Odd, intmax_t _Qp, intmax_t _M2>
|
||||
struct __ratio_less1<_R1, _R2, _Odd, _Qp, 0, _Qp, _M2>
|
||||
template <class _R1, class _R2, bool _Odd, intmax_t _Q, intmax_t _M2>
|
||||
struct __ratio_less1<_R1, _R2, _Odd, _Q, 0, _Q, _M2>
|
||||
{
|
||||
static const bool value = !_Odd;
|
||||
};
|
||||
|
||||
template <class _R1, class _R2, bool _Odd, intmax_t _Qp, intmax_t _M1>
|
||||
struct __ratio_less1<_R1, _R2, _Odd, _Qp, _M1, _Qp, 0>
|
||||
template <class _R1, class _R2, bool _Odd, intmax_t _Q, intmax_t _M1>
|
||||
struct __ratio_less1<_R1, _R2, _Odd, _Q, _M1, _Q, 0>
|
||||
{
|
||||
static const bool value = _Odd;
|
||||
};
|
||||
|
||||
template <class _R1, class _R2, bool _Odd, intmax_t _Qp, intmax_t _M1,
|
||||
template <class _R1, class _R2, bool _Odd, intmax_t _Q, intmax_t _M1,
|
||||
intmax_t _M2>
|
||||
struct __ratio_less1<_R1, _R2, _Odd, _Qp, _M1, _Qp, _M2>
|
||||
struct __ratio_less1<_R1, _R2, _Odd, _Q, _M1, _Q, _M2>
|
||||
{
|
||||
static const bool value = __ratio_less1<ratio<_R1::den, _M1>,
|
||||
ratio<_R2::den, _M2>, !_Odd>::value;
|
||||
|
||||
186
include/regex
186
include/regex
@@ -147,7 +147,7 @@ public:
|
||||
explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript);
|
||||
basic_regex(const charT* p, size_t len, flag_type f);
|
||||
basic_regex(const basic_regex&);
|
||||
basic_regex(basic_regex&&) noexcept;
|
||||
basic_regex(basic_regex&&);
|
||||
template <class ST, class SA>
|
||||
explicit basic_regex(const basic_string<charT, ST, SA>& p,
|
||||
flag_type f = regex_constants::ECMAScript);
|
||||
@@ -159,7 +159,7 @@ public:
|
||||
~basic_regex();
|
||||
|
||||
basic_regex& operator=(const basic_regex&);
|
||||
basic_regex& operator=(basic_regex&&) noexcept;
|
||||
basic_regex& operator=(basic_regex&&);
|
||||
basic_regex& operator=(const charT* ptr);
|
||||
basic_regex& operator=(initializer_list<charT> il);
|
||||
template <class ST, class SA>
|
||||
@@ -167,7 +167,7 @@ public:
|
||||
|
||||
// assign:
|
||||
basic_regex& assign(const basic_regex& that);
|
||||
basic_regex& assign(basic_regex&& that) noexcept;
|
||||
basic_regex& assign(basic_regex&& that);
|
||||
basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
|
||||
basic_regex& assign(const charT* p, size_t len, flag_type f);
|
||||
template <class string_traits, class A>
|
||||
@@ -449,7 +449,7 @@ public:
|
||||
// construct/copy/destroy:
|
||||
explicit match_results(const Allocator& a = Allocator());
|
||||
match_results(const match_results& m);
|
||||
match_results(match_results&& m) noexcept;
|
||||
match_results(match_results&& m);
|
||||
match_results& operator=(const match_results& m);
|
||||
match_results& operator=(match_results&& m);
|
||||
~match_results();
|
||||
@@ -732,11 +732,7 @@ typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
|
||||
#include <vector>
|
||||
#include <deque>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -760,7 +756,7 @@ enum syntax_option_type
|
||||
};
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
/*constexpr*/
|
||||
syntax_option_type
|
||||
operator~(syntax_option_type __x)
|
||||
{
|
||||
@@ -768,7 +764,7 @@ operator~(syntax_option_type __x)
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
/*constexpr*/
|
||||
syntax_option_type
|
||||
operator&(syntax_option_type __x, syntax_option_type __y)
|
||||
{
|
||||
@@ -776,7 +772,7 @@ operator&(syntax_option_type __x, syntax_option_type __y)
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
/*constexpr*/
|
||||
syntax_option_type
|
||||
operator|(syntax_option_type __x, syntax_option_type __y)
|
||||
{
|
||||
@@ -784,7 +780,7 @@ operator|(syntax_option_type __x, syntax_option_type __y)
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
/*constexpr*/
|
||||
syntax_option_type
|
||||
operator^(syntax_option_type __x, syntax_option_type __y)
|
||||
{
|
||||
@@ -792,6 +788,7 @@ operator^(syntax_option_type __x, syntax_option_type __y)
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
/*constexpr*/
|
||||
syntax_option_type&
|
||||
operator&=(syntax_option_type& __x, syntax_option_type __y)
|
||||
{
|
||||
@@ -800,6 +797,7 @@ operator&=(syntax_option_type& __x, syntax_option_type __y)
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
/*constexpr*/
|
||||
syntax_option_type&
|
||||
operator|=(syntax_option_type& __x, syntax_option_type __y)
|
||||
{
|
||||
@@ -808,6 +806,7 @@ operator|=(syntax_option_type& __x, syntax_option_type __y)
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
/*constexpr*/
|
||||
syntax_option_type&
|
||||
operator^=(syntax_option_type& __x, syntax_option_type __y)
|
||||
{
|
||||
@@ -836,7 +835,7 @@ enum match_flag_type
|
||||
};
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
/*constexpr*/
|
||||
match_flag_type
|
||||
operator~(match_flag_type __x)
|
||||
{
|
||||
@@ -844,7 +843,7 @@ operator~(match_flag_type __x)
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
/*constexpr*/
|
||||
match_flag_type
|
||||
operator&(match_flag_type __x, match_flag_type __y)
|
||||
{
|
||||
@@ -852,7 +851,7 @@ operator&(match_flag_type __x, match_flag_type __y)
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
/*constexpr*/
|
||||
match_flag_type
|
||||
operator|(match_flag_type __x, match_flag_type __y)
|
||||
{
|
||||
@@ -860,7 +859,7 @@ operator|(match_flag_type __x, match_flag_type __y)
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR
|
||||
/*constexpr*/
|
||||
match_flag_type
|
||||
operator^(match_flag_type __x, match_flag_type __y)
|
||||
{
|
||||
@@ -868,6 +867,7 @@ operator^(match_flag_type __x, match_flag_type __y)
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
/*constexpr*/
|
||||
match_flag_type&
|
||||
operator&=(match_flag_type& __x, match_flag_type __y)
|
||||
{
|
||||
@@ -876,6 +876,7 @@ operator&=(match_flag_type& __x, match_flag_type __y)
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
/*constexpr*/
|
||||
match_flag_type&
|
||||
operator|=(match_flag_type& __x, match_flag_type __y)
|
||||
{
|
||||
@@ -884,6 +885,7 @@ operator|=(match_flag_type& __x, match_flag_type __y)
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
/*constexpr*/
|
||||
match_flag_type&
|
||||
operator^=(match_flag_type& __x, match_flag_type __y)
|
||||
{
|
||||
@@ -1231,11 +1233,11 @@ regex_traits<_CharT>::__value(wchar_t __ch, int __radix) const
|
||||
|
||||
template <class _CharT> class __node;
|
||||
|
||||
template <class _BidirectionalIterator> class _LIBCPP_VISIBLE sub_match;
|
||||
template <class _BidirectionalIterator> class sub_match;
|
||||
|
||||
template <class _BidirectionalIterator,
|
||||
class _Allocator = allocator<sub_match<_BidirectionalIterator> > >
|
||||
class _LIBCPP_VISIBLE match_results;
|
||||
class match_results;
|
||||
|
||||
template <class _CharT>
|
||||
struct __state
|
||||
@@ -2433,16 +2435,16 @@ private:
|
||||
|
||||
public:
|
||||
// constants:
|
||||
static const regex_constants::syntax_option_type icase = regex_constants::icase;
|
||||
static const regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
|
||||
static const regex_constants::syntax_option_type optimize = regex_constants::optimize;
|
||||
static const regex_constants::syntax_option_type collate = regex_constants::collate;
|
||||
static const regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
|
||||
static const regex_constants::syntax_option_type basic = regex_constants::basic;
|
||||
static const regex_constants::syntax_option_type extended = regex_constants::extended;
|
||||
static const regex_constants::syntax_option_type awk = regex_constants::awk;
|
||||
static const regex_constants::syntax_option_type grep = regex_constants::grep;
|
||||
static const regex_constants::syntax_option_type egrep = regex_constants::egrep;
|
||||
static const/*expr*/ regex_constants::syntax_option_type icase = regex_constants::icase;
|
||||
static const/*expr*/ regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
|
||||
static const/*expr*/ regex_constants::syntax_option_type optimize = regex_constants::optimize;
|
||||
static const/*expr*/ regex_constants::syntax_option_type collate = regex_constants::collate;
|
||||
static const/*expr*/ regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
|
||||
static const/*expr*/ regex_constants::syntax_option_type basic = regex_constants::basic;
|
||||
static const/*expr*/ regex_constants::syntax_option_type extended = regex_constants::extended;
|
||||
static const/*expr*/ regex_constants::syntax_option_type awk = regex_constants::awk;
|
||||
static const/*expr*/ regex_constants::syntax_option_type grep = regex_constants::grep;
|
||||
static const/*expr*/ regex_constants::syntax_option_type egrep = regex_constants::egrep;
|
||||
|
||||
// construct/copy/destroy:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -2476,14 +2478,12 @@ public:
|
||||
: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
|
||||
__end_(0)
|
||||
{__parse(__first, __last);}
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_regex(initializer_list<value_type> __il,
|
||||
flag_type __f = regex_constants::ECMAScript)
|
||||
: __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
|
||||
__end_(0)
|
||||
{__parse(__il.begin(), __il.end());}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
// ~basic_regex() = default;
|
||||
|
||||
@@ -2492,11 +2492,9 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_regex& operator=(const value_type* __p)
|
||||
{return assign(__p);}
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_regex& operator=(initializer_list<value_type> __il)
|
||||
{return assign(__il);}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
template <class _ST, class _SA>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_regex& operator=(const basic_string<value_type, _ST, _SA>& __p)
|
||||
@@ -2506,11 +2504,6 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_regex& assign(const basic_regex& __that)
|
||||
{return *this = __that;}
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_regex& assign(basic_regex&& __that) _NOEXCEPT
|
||||
{return *this = _VSTD::move(__that);}
|
||||
#endif
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_regex& assign(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
|
||||
{return assign(__p, __p + __traits_.length(__p), __f);}
|
||||
@@ -2562,18 +2555,13 @@ public:
|
||||
{
|
||||
__member_init(__f);
|
||||
__parse(__first, __last);
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_regex& assign(initializer_list<value_type> __il,
|
||||
flag_type __f = regex_constants::ECMAScript)
|
||||
{return assign(__il.begin(), __il.end(), __f);}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
// const operations:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
unsigned mark_count() const {return __marked_count_;}
|
||||
@@ -2794,75 +2782,54 @@ private:
|
||||
match_results<const _CharT*, _Allocator>& __m,
|
||||
regex_constants::match_flag_type __flags, bool) const;
|
||||
|
||||
template <class _Bp, class _Ap, class _Cp, class _Tp>
|
||||
template <class _B, class _A, class _C, class _T>
|
||||
friend
|
||||
bool
|
||||
regex_search(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&,
|
||||
regex_search(_B, _B, match_results<_B, _A>&, const basic_regex<_C, _T>&,
|
||||
regex_constants::match_flag_type);
|
||||
|
||||
template <class _Ap, class _Cp, class _Tp>
|
||||
template <class _A, class _C, class _T>
|
||||
friend
|
||||
bool
|
||||
regex_search(const _Cp*, const _Cp*, match_results<const _Cp*, _Ap>&,
|
||||
const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
|
||||
regex_search(const _C*, const _C*, match_results<const _C*, _A>&,
|
||||
const basic_regex<_C, _T>&, regex_constants::match_flag_type);
|
||||
|
||||
template <class _Bp, class _Cp, class _Tp>
|
||||
template <class _B, class _C, class _T>
|
||||
friend
|
||||
bool
|
||||
regex_search(_Bp, _Bp, const basic_regex<_Cp, _Tp>&,
|
||||
regex_search(_B, _B, const basic_regex<_C, _T>&,
|
||||
regex_constants::match_flag_type);
|
||||
|
||||
template <class _Cp, class _Tp>
|
||||
template <class _C, class _T>
|
||||
friend
|
||||
bool
|
||||
regex_search(const _Cp*, const _Cp*,
|
||||
const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
|
||||
regex_search(const _C*, const _C*,
|
||||
const basic_regex<_C, _T>&, regex_constants::match_flag_type);
|
||||
|
||||
template <class _Cp, class _Ap, class _Tp>
|
||||
template <class _C, class _A, class _T>
|
||||
friend
|
||||
bool
|
||||
regex_search(const _Cp*, match_results<const _Cp*, _Ap>&, const basic_regex<_Cp, _Tp>&,
|
||||
regex_search(const _C*, match_results<const _C*, _A>&, const basic_regex<_C, _T>&,
|
||||
regex_constants::match_flag_type);
|
||||
|
||||
template <class _ST, class _SA, class _Cp, class _Tp>
|
||||
template <class _ST, class _SA, class _C, class _T>
|
||||
friend
|
||||
bool
|
||||
regex_search(const basic_string<_Cp, _ST, _SA>& __s,
|
||||
const basic_regex<_Cp, _Tp>& __e,
|
||||
regex_search(const basic_string<_C, _ST, _SA>& __s,
|
||||
const basic_regex<_C, _T>& __e,
|
||||
regex_constants::match_flag_type __flags);
|
||||
|
||||
template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
|
||||
template <class _ST, class _SA, class _A, class _C, class _T>
|
||||
friend
|
||||
bool
|
||||
regex_search(const basic_string<_Cp, _ST, _SA>& __s,
|
||||
match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
|
||||
const basic_regex<_Cp, _Tp>& __e,
|
||||
regex_search(const basic_string<_C, _ST, _SA>& __s,
|
||||
match_results<typename basic_string<_C, _ST, _SA>::const_iterator, _A>&,
|
||||
const basic_regex<_C, _T>& __e,
|
||||
regex_constants::match_flag_type __flags);
|
||||
|
||||
template <class, class> friend class __lookahead;
|
||||
};
|
||||
|
||||
template <class _CharT, class _Traits>
|
||||
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::icase;
|
||||
template <class _CharT, class _Traits>
|
||||
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::nosubs;
|
||||
template <class _CharT, class _Traits>
|
||||
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::optimize;
|
||||
template <class _CharT, class _Traits>
|
||||
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::collate;
|
||||
template <class _CharT, class _Traits>
|
||||
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::ECMAScript;
|
||||
template <class _CharT, class _Traits>
|
||||
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::basic;
|
||||
template <class _CharT, class _Traits>
|
||||
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::extended;
|
||||
template <class _CharT, class _Traits>
|
||||
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::awk;
|
||||
template <class _CharT, class _Traits>
|
||||
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::grep;
|
||||
template <class _CharT, class _Traits>
|
||||
const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::egrep;
|
||||
|
||||
template <class _CharT, class _Traits>
|
||||
void
|
||||
basic_regex<_CharT, _Traits>::swap(basic_regex& __r)
|
||||
@@ -4425,7 +4392,7 @@ basic_regex<_CharT, _Traits>::__parse_character_escape(_ForwardIterator __first,
|
||||
if (__hd == -1)
|
||||
throw regex_error(regex_constants::error_escape);
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
__sum = 16 * __sum + static_cast<unsigned>(__hd);
|
||||
__sum = 16 * __sum + __hd;
|
||||
++__first;
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
if (__first == __last)
|
||||
@@ -4436,7 +4403,7 @@ basic_regex<_CharT, _Traits>::__parse_character_escape(_ForwardIterator __first,
|
||||
if (__hd == -1)
|
||||
throw regex_error(regex_constants::error_escape);
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
__sum = 16 * __sum + static_cast<unsigned>(__hd);
|
||||
__sum = 16 * __sum + __hd;
|
||||
// drop through
|
||||
case 'x':
|
||||
++__first;
|
||||
@@ -4449,7 +4416,7 @@ basic_regex<_CharT, _Traits>::__parse_character_escape(_ForwardIterator __first,
|
||||
if (__hd == -1)
|
||||
throw regex_error(regex_constants::error_escape);
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
__sum = 16 * __sum + static_cast<unsigned>(__hd);
|
||||
__sum = 16 * __sum + __hd;
|
||||
++__first;
|
||||
#ifndef _LIBCPP_NO_EXCEPTIONS
|
||||
if (__first == __last)
|
||||
@@ -4460,7 +4427,7 @@ basic_regex<_CharT, _Traits>::__parse_character_escape(_ForwardIterator __first,
|
||||
if (__hd == -1)
|
||||
throw regex_error(regex_constants::error_escape);
|
||||
#endif // _LIBCPP_NO_EXCEPTIONS
|
||||
__sum = 16 * __sum + static_cast<unsigned>(__hd);
|
||||
__sum = 16 * __sum + __hd;
|
||||
if (__str)
|
||||
*__str = _CharT(__sum);
|
||||
else
|
||||
@@ -4761,7 +4728,7 @@ public:
|
||||
bool matched;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
_LIBCPP_CONSTEXPR sub_match() : matched() {}
|
||||
/*constexpr*/ sub_match() : matched() {}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
difference_type length() const
|
||||
@@ -5235,11 +5202,11 @@ public:
|
||||
const_reference suffix() const {return __suffix_;}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const_iterator begin() const {return empty() ? __matches_.end() : __matches_.begin();}
|
||||
const_iterator begin() const {return empty() ? __matches_.end() : __matches_.begin() + 1;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const_iterator end() const {return __matches_.end();}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const_iterator cbegin() const {return empty() ? __matches_.end() : __matches_.begin();}
|
||||
const_iterator cbegin() const {return empty() ? __matches_.end() : __matches_.begin() + 1;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
const_iterator cend() const {return __matches_.end();}
|
||||
|
||||
@@ -5284,12 +5251,12 @@ public:
|
||||
// swap:
|
||||
void swap(match_results& __m);
|
||||
|
||||
template <class _Bp, class _Ap>
|
||||
template <class _B, class _A>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __assign(_BidirectionalIterator __f, _BidirectionalIterator __l,
|
||||
const match_results<_Bp, _Ap>& __m, bool __no_update_pos)
|
||||
const match_results<_B, _A>& __m, bool __no_update_pos)
|
||||
{
|
||||
_Bp __mf = __m.prefix().first;
|
||||
_B __mf = __m.prefix().first;
|
||||
__matches_.resize(__m.size());
|
||||
for (size_type __i = 0; __i < __matches_.size(); ++__i)
|
||||
{
|
||||
@@ -5318,16 +5285,16 @@ private:
|
||||
|
||||
template <class, class> friend class basic_regex;
|
||||
|
||||
template <class _Bp, class _Ap, class _Cp, class _Tp>
|
||||
template <class _B, class _A, class _C, class _T>
|
||||
friend
|
||||
bool
|
||||
regex_match(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&,
|
||||
regex_match(_B, _B, match_results<_B, _A>&, const basic_regex<_C, _T>&,
|
||||
regex_constants::match_flag_type);
|
||||
|
||||
template <class _Bp, class _Ap>
|
||||
template <class _B, class _A>
|
||||
friend
|
||||
bool
|
||||
operator==(const match_results<_Bp, _Ap>&, const match_results<_Bp, _Ap>&);
|
||||
operator==(const match_results<_B, _A>&, const match_results<_B, _A>&);
|
||||
|
||||
template <class, class> friend class __lookahead;
|
||||
};
|
||||
@@ -5517,6 +5484,8 @@ basic_regex<_CharT, _Traits>::__match_at_start_ecma(
|
||||
regex_constants::match_flag_type __flags, bool __at_first) const
|
||||
{
|
||||
vector<__state> __states;
|
||||
ptrdiff_t __j = 0;
|
||||
ptrdiff_t _N = _VSTD::distance(__first, __last);
|
||||
__node* __st = __start_.get();
|
||||
if (__st)
|
||||
{
|
||||
@@ -5530,6 +5499,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_ecma(
|
||||
__states.back().__node_ = __st;
|
||||
__states.back().__flags_ = __flags;
|
||||
__states.back().__at_first_ = __at_first;
|
||||
bool __matched = false;
|
||||
do
|
||||
{
|
||||
__state& __s = __states.back();
|
||||
@@ -5581,7 +5551,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
|
||||
{
|
||||
deque<__state> __states;
|
||||
ptrdiff_t __highest_j = 0;
|
||||
ptrdiff_t _Np = _VSTD::distance(__first, __last);
|
||||
ptrdiff_t _N = _VSTD::distance(__first, __last);
|
||||
__node* __st = __start_.get();
|
||||
if (__st)
|
||||
{
|
||||
@@ -5606,7 +5576,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
|
||||
if (!__matched || __highest_j < __s.__current_ - __s.__first_)
|
||||
__highest_j = __s.__current_ - __s.__first_;
|
||||
__matched = true;
|
||||
if (__highest_j == _Np)
|
||||
if (__highest_j == _N)
|
||||
__states.clear();
|
||||
else
|
||||
__states.pop_back();
|
||||
@@ -5661,7 +5631,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
|
||||
__state __best_state;
|
||||
ptrdiff_t __j = 0;
|
||||
ptrdiff_t __highest_j = 0;
|
||||
ptrdiff_t _Np = _VSTD::distance(__first, __last);
|
||||
ptrdiff_t _N = _VSTD::distance(__first, __last);
|
||||
__node* __st = __start_.get();
|
||||
if (__st)
|
||||
{
|
||||
@@ -5691,7 +5661,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
|
||||
__best_state = __s;
|
||||
}
|
||||
__matched = true;
|
||||
if (__highest_j == _Np)
|
||||
if (__highest_j == _N)
|
||||
__states.clear();
|
||||
else
|
||||
__states.pop_back();
|
||||
@@ -6099,18 +6069,16 @@ public:
|
||||
const regex_type& __re, const vector<int>& __submatches,
|
||||
regex_constants::match_flag_type __m =
|
||||
regex_constants::match_default);
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
|
||||
const regex_type& __re,
|
||||
initializer_list<int> __submatches,
|
||||
regex_constants::match_flag_type __m =
|
||||
regex_constants::match_default);
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
template <size_t _Np>
|
||||
template <size_t _N>
|
||||
regex_token_iterator(_BidirectionalIterator __a,
|
||||
_BidirectionalIterator __b,
|
||||
const regex_type& __re,
|
||||
const int (&__submatches)[_Np],
|
||||
const int (&__submatches)[_N],
|
||||
regex_constants::match_flag_type __m =
|
||||
regex_constants::match_default);
|
||||
regex_token_iterator(const regex_token_iterator&);
|
||||
@@ -6194,8 +6162,6 @@ regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
|
||||
__init(__a, __b);
|
||||
}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _BidirectionalIterator, class _CharT, class _Traits>
|
||||
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
|
||||
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
|
||||
@@ -6209,18 +6175,16 @@ regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
|
||||
__init(__a, __b);
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _BidirectionalIterator, class _CharT, class _Traits>
|
||||
template <size_t _Np>
|
||||
template <size_t _N>
|
||||
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
|
||||
regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
|
||||
const regex_type& __re,
|
||||
const int (&__submatches)[_Np],
|
||||
const int (&__submatches)[_N],
|
||||
regex_constants::match_flag_type __m)
|
||||
: __position_(__a, __b, __re, __m),
|
||||
_N_(0),
|
||||
__subs_(__submatches, __submatches + _Np)
|
||||
__subs_(__submatches, __submatches + _N)
|
||||
{
|
||||
__init(__a, __b);
|
||||
}
|
||||
|
||||
@@ -106,9 +106,7 @@ template <class OuterA1, class OuterA2, class... InnerAllocs>
|
||||
#include <__config>
|
||||
#include <memory>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
10
include/set
10
include/set
@@ -338,9 +338,7 @@ swap(multiset<Key, Compare, Allocator>& x, multiset<Key, Compare, Allocator>& y)
|
||||
#include <__tree>
|
||||
#include <functional>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -439,7 +437,6 @@ public:
|
||||
set(set&& __s, const allocator_type& __a);
|
||||
#endif
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
set(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
|
||||
: __tree_(__comp)
|
||||
@@ -461,7 +458,6 @@ public:
|
||||
__tree_.__assign_unique(__il.begin(), __il.end());
|
||||
return *this;
|
||||
}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -546,11 +542,9 @@ public:
|
||||
__tree_.__insert_unique(__e, *__f);
|
||||
}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void insert(initializer_list<value_type> __il)
|
||||
{insert(__il.begin(), __il.end());}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator erase(const_iterator __p) {return __tree_.erase(__p);}
|
||||
@@ -777,7 +771,6 @@ public:
|
||||
multiset(multiset&& __s, const allocator_type& __a);
|
||||
#endif
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
multiset(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
|
||||
: __tree_(__comp)
|
||||
@@ -799,7 +792,6 @@ public:
|
||||
__tree_.__assign_multi(__il.begin(), __il.end());
|
||||
return *this;
|
||||
}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -884,11 +876,9 @@ public:
|
||||
__tree_.__insert_multi(__e, *__f);
|
||||
}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void insert(initializer_list<value_type> __il)
|
||||
{insert(__il.begin(), __il.end());}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator erase(const_iterator __p) {return __tree_.erase(__p);}
|
||||
|
||||
@@ -175,11 +175,7 @@ typedef basic_stringstream<wchar_t> wstringstream;
|
||||
#include <istream>
|
||||
#include <string>
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
@@ -85,21 +85,17 @@ template <class T, class Container>
|
||||
#include <__config>
|
||||
#include <deque>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
template <class _Tp, class _Container> class _LIBCPP_VISIBLE stack;
|
||||
template <class _Tp, class _Container> class stack;
|
||||
|
||||
template <class _Tp, class _Container>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
|
||||
|
||||
template <class _Tp, class _Container>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool
|
||||
operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
|
||||
|
||||
|
||||
@@ -46,9 +46,7 @@ public:
|
||||
#include <exception>
|
||||
#include <iosfwd> // for string forward decl
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
namespace std // purposefully not using versioning namespace
|
||||
{
|
||||
|
||||
@@ -112,9 +112,7 @@ protected:
|
||||
#include <iosfwd>
|
||||
#include <ios>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -461,15 +459,15 @@ basic_streambuf<_CharT, _Traits>::setbuf(char_type*, streamsize)
|
||||
|
||||
template <class _CharT, class _Traits>
|
||||
typename basic_streambuf<_CharT, _Traits>::pos_type
|
||||
basic_streambuf<_CharT, _Traits>::seekoff(off_type, ios_base::seekdir,
|
||||
ios_base::openmode)
|
||||
basic_streambuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way,
|
||||
ios_base::openmode __which)
|
||||
{
|
||||
return pos_type(off_type(-1));
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits>
|
||||
typename basic_streambuf<_CharT, _Traits>::pos_type
|
||||
basic_streambuf<_CharT, _Traits>::seekpos(pos_type, ios_base::openmode)
|
||||
basic_streambuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode __which)
|
||||
{
|
||||
return pos_type(off_type(-1));
|
||||
}
|
||||
@@ -540,7 +538,7 @@ basic_streambuf<_CharT, _Traits>::xsputn(const char_type* __s, streamsize __n)
|
||||
{
|
||||
if (__nout_ < __eout_)
|
||||
*__nout_++ = *__s;
|
||||
else if (overflow(traits_type::to_int_type(*__s)) == __eof)
|
||||
else if (overflow(*__s) == __eof)
|
||||
break;
|
||||
}
|
||||
return __i;
|
||||
@@ -548,16 +546,16 @@ basic_streambuf<_CharT, _Traits>::xsputn(const char_type* __s, streamsize __n)
|
||||
|
||||
template <class _CharT, class _Traits>
|
||||
typename basic_streambuf<_CharT, _Traits>::int_type
|
||||
basic_streambuf<_CharT, _Traits>::overflow(int_type)
|
||||
basic_streambuf<_CharT, _Traits>::overflow(int_type __c)
|
||||
{
|
||||
return traits_type::eof();
|
||||
}
|
||||
|
||||
_LIBCPP_EXTERN_TEMPLATE(class basic_streambuf<char>)
|
||||
_LIBCPP_EXTERN_TEMPLATE(class basic_streambuf<wchar_t>)
|
||||
extern template class basic_streambuf<char>;
|
||||
extern template class basic_streambuf<wchar_t>;
|
||||
|
||||
_LIBCPP_EXTERN_TEMPLATE(class basic_ios<char>)
|
||||
_LIBCPP_EXTERN_TEMPLATE(class basic_ios<wchar_t>)
|
||||
extern template class basic_ios<char>;
|
||||
extern template class basic_ios<wchar_t>;
|
||||
|
||||
_LIBCPP_END_NAMESPACE_STD
|
||||
|
||||
|
||||
337
include/string
337
include/string
@@ -51,8 +51,8 @@ struct char_traits
|
||||
typedef mbstate_t state_type;
|
||||
|
||||
static void assign(char_type& c1, const char_type& c2) noexcept;
|
||||
static constexpr bool eq(char_type c1, char_type c2) noexcept;
|
||||
static constexpr bool lt(char_type c1, char_type c2) noexcept;
|
||||
static bool eq(char_type c1, char_type c2) noexcept;
|
||||
static bool lt(char_type c1, char_type c2) noexcept;
|
||||
|
||||
static int compare(const char_type* s1, const char_type* s2, size_t n);
|
||||
static size_t length(const char_type* s);
|
||||
@@ -61,11 +61,11 @@ struct char_traits
|
||||
static char_type* copy(char_type* s1, const char_type* s2, size_t n);
|
||||
static char_type* assign(char_type* s, size_t n, char_type a);
|
||||
|
||||
static constexpr int_type not_eof(int_type c) noexcept;
|
||||
static constexpr char_type to_char_type(int_type c) noexcept;
|
||||
static constexpr int_type to_int_type(char_type c) noexcept;
|
||||
static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept;
|
||||
static constexpr int_type eof() noexcept;
|
||||
static int_type not_eof(int_type c) noexcept;
|
||||
static char_type to_char_type(int_type c) noexcept;
|
||||
static int_type to_int_type(char_type c) noexcept;
|
||||
static bool eq_int_type(int_type c1, int_type c2) noexcept;
|
||||
static int_type eof() noexcept;
|
||||
};
|
||||
|
||||
template <> struct char_traits<char>;
|
||||
@@ -446,11 +446,7 @@ template <> struct hash<wstring>;
|
||||
#include <cassert>
|
||||
#endif
|
||||
|
||||
#include <__undef_min_max>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -506,10 +502,10 @@ struct _LIBCPP_VISIBLE char_traits
|
||||
static void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT
|
||||
{__c1 = __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
static bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
{return __c1 == __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
static bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
{return __c1 < __c2;}
|
||||
|
||||
static int compare(const char_type* __s1, const char_type* __s2, size_t __n);
|
||||
@@ -519,20 +515,19 @@ struct _LIBCPP_VISIBLE char_traits
|
||||
static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n);
|
||||
static char_type* assign(char_type* __s, size_t __n, char_type __a);
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
|
||||
_LIBCPP_INLINE_VISIBILITY static int_type not_eof(int_type __c) _NOEXCEPT
|
||||
{return eq_int_type(__c, eof()) ? ~eof() : __c;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
|
||||
static char_type to_char_type(int_type __c) _NOEXCEPT
|
||||
{return char_type(__c);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
|
||||
static int_type to_int_type(char_type __c) _NOEXCEPT
|
||||
{return int_type(__c);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
||||
static bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
||||
{return __c1 == __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
|
||||
static int_type eof() _NOEXCEPT
|
||||
{return int_type(EOF);}
|
||||
};
|
||||
|
||||
@@ -632,10 +627,10 @@ struct _LIBCPP_VISIBLE char_traits<char>
|
||||
static void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT
|
||||
{__c1 = __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
static bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
{return __c1 == __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
static bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
{return (unsigned char)__c1 < (unsigned char)__c2;}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -656,20 +651,19 @@ struct _LIBCPP_VISIBLE char_traits<char>
|
||||
static char_type* assign(char_type* __s, size_t __n, char_type __a)
|
||||
{return (char_type*)memset(__s, to_int_type(__a), __n);}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
|
||||
_LIBCPP_INLINE_VISIBILITY static int_type not_eof(int_type __c) _NOEXCEPT
|
||||
{return eq_int_type(__c, eof()) ? ~eof() : __c;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
|
||||
static char_type to_char_type(int_type __c) _NOEXCEPT
|
||||
{return char_type(__c);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
|
||||
static int_type to_int_type(char_type __c) _NOEXCEPT
|
||||
{return int_type((unsigned char)__c);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
||||
static bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
||||
{return __c1 == __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
|
||||
static int_type eof() _NOEXCEPT
|
||||
{return int_type(EOF);}
|
||||
};
|
||||
|
||||
@@ -688,10 +682,10 @@ struct _LIBCPP_VISIBLE char_traits<wchar_t>
|
||||
static void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT
|
||||
{__c1 = __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
static bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
{return __c1 == __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
static bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
{return __c1 < __c2;}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -714,19 +708,19 @@ struct _LIBCPP_VISIBLE char_traits<wchar_t>
|
||||
{return (char_type*)wmemset(__s, __a, __n);}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
|
||||
static int_type not_eof(int_type __c) _NOEXCEPT
|
||||
{return eq_int_type(__c, eof()) ? ~eof() : __c;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
|
||||
static char_type to_char_type(int_type __c) _NOEXCEPT
|
||||
{return char_type(__c);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
|
||||
static int_type to_int_type(char_type __c) _NOEXCEPT
|
||||
{return int_type(__c);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
||||
static bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
||||
{return __c1 == __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
|
||||
static int_type eof() _NOEXCEPT
|
||||
{return int_type(WEOF);}
|
||||
};
|
||||
|
||||
@@ -745,10 +739,10 @@ struct _LIBCPP_VISIBLE char_traits<char16_t>
|
||||
static void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT
|
||||
{__c1 = __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
static bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
{return __c1 == __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
static bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
{return __c1 < __c2;}
|
||||
|
||||
static int compare(const char_type* __s1, const char_type* __s2, size_t __n);
|
||||
@@ -759,19 +753,19 @@ struct _LIBCPP_VISIBLE char_traits<char16_t>
|
||||
static char_type* assign(char_type* __s, size_t __n, char_type __a);
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
|
||||
static int_type not_eof(int_type __c) _NOEXCEPT
|
||||
{return eq_int_type(__c, eof()) ? ~eof() : __c;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
|
||||
static char_type to_char_type(int_type __c) _NOEXCEPT
|
||||
{return char_type(__c);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
|
||||
static int_type to_int_type(char_type __c) _NOEXCEPT
|
||||
{return int_type(__c);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
||||
static bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
||||
{return __c1 == __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
|
||||
static int_type eof() _NOEXCEPT
|
||||
{return int_type(0xDFFF);}
|
||||
};
|
||||
|
||||
@@ -865,10 +859,10 @@ struct _LIBCPP_VISIBLE char_traits<char32_t>
|
||||
static void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT
|
||||
{__c1 = __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
static bool eq(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
{return __c1 == __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
static bool lt(char_type __c1, char_type __c2) _NOEXCEPT
|
||||
{return __c1 < __c2;}
|
||||
|
||||
static int compare(const char_type* __s1, const char_type* __s2, size_t __n);
|
||||
@@ -879,19 +873,19 @@ struct _LIBCPP_VISIBLE char_traits<char32_t>
|
||||
static char_type* assign(char_type* __s, size_t __n, char_type __a);
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT
|
||||
static int_type not_eof(int_type __c) _NOEXCEPT
|
||||
{return eq_int_type(__c, eof()) ? ~eof() : __c;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
|
||||
static char_type to_char_type(int_type __c) _NOEXCEPT
|
||||
{return char_type(__c);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
|
||||
static int_type to_int_type(char_type __c) _NOEXCEPT
|
||||
{return int_type(__c);}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
||||
static bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
|
||||
{return __c1 == __c2;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
|
||||
static int_type eof() _NOEXCEPT
|
||||
{return int_type(0xFFFFFFFF);}
|
||||
};
|
||||
|
||||
@@ -1027,14 +1021,7 @@ __basic_string_common<__b>::__throw_out_of_range() const
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning( push )
|
||||
#pragma warning( disable: 4231 )
|
||||
#endif // _MSC_VER
|
||||
_LIBCPP_EXTERN_TEMPLATE(class __basic_string_common<true>)
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning( pop )
|
||||
#endif // _MSC_VER
|
||||
extern template class __basic_string_common<true>;
|
||||
|
||||
template<class _CharT, class _Traits, class _Allocator>
|
||||
class _LIBCPP_VISIBLE basic_string
|
||||
@@ -1081,7 +1068,7 @@ private:
|
||||
enum {__long_mask = ~(size_type(~0) >> 1)};
|
||||
#else // _LIBCPP_BIG_ENDIAN
|
||||
enum {__short_mask = 0x01};
|
||||
enum {__long_mask = 0x1ul};
|
||||
enum {__long_mask = 0x1};
|
||||
#endif // _LIBCPP_BIG_ENDIAN
|
||||
|
||||
enum {__mask = size_type(~0) >> 1};
|
||||
@@ -1094,14 +1081,14 @@ private:
|
||||
union
|
||||
{
|
||||
unsigned char __size_;
|
||||
value_type __lx;
|
||||
value_type _;
|
||||
};
|
||||
value_type __data_[__min_cap];
|
||||
};
|
||||
|
||||
union __lx{__long __lx; __short __lxx;};
|
||||
union _{__long _; __short __;};
|
||||
|
||||
enum {__n_words = sizeof(__lx) / sizeof(size_type)};
|
||||
enum {__n_words = sizeof(_) / sizeof(size_type)};
|
||||
|
||||
struct __raw
|
||||
{
|
||||
@@ -1163,12 +1150,10 @@ public:
|
||||
template<class _InputIterator>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a);
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_string(initializer_list<value_type> __il);
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_string(initializer_list<value_type> __il, const allocator_type& __a);
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
~basic_string();
|
||||
|
||||
@@ -1181,10 +1166,8 @@ public:
|
||||
#endif
|
||||
_LIBCPP_INLINE_VISIBILITY basic_string& operator=(const_pointer __s) {return assign(__s);}
|
||||
basic_string& operator=(value_type __c);
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
#ifndef _LIBCPP_DEBUG
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -1257,9 +1240,7 @@ public:
|
||||
_LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const basic_string& __str) {return append(__str);}
|
||||
_LIBCPP_INLINE_VISIBILITY basic_string& operator+=(const_pointer __s) {return append(__s);}
|
||||
_LIBCPP_INLINE_VISIBILITY basic_string& operator+=(value_type __c) {push_back(__c); return *this;}
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY basic_string& operator+=(initializer_list<value_type> __il) {return append(__il);}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_string& append(const basic_string& __str);
|
||||
@@ -1282,10 +1263,8 @@ public:
|
||||
basic_string&
|
||||
>::type
|
||||
append(_ForwardIterator __first, _ForwardIterator __last);
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
void push_back(value_type __c);
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -1321,10 +1300,8 @@ public:
|
||||
basic_string&
|
||||
>::type
|
||||
assign(_ForwardIterator __first, _ForwardIterator __last);
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_string& insert(size_type __pos1, const basic_string& __str);
|
||||
@@ -1350,11 +1327,9 @@ public:
|
||||
iterator
|
||||
>::type
|
||||
insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last);
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(const_iterator __pos, initializer_list<value_type> __il)
|
||||
{return insert(__pos, __il.begin(), __il.end());}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
basic_string& erase(size_type __pos = 0, size_type __n = npos);
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -1383,11 +1358,9 @@ public:
|
||||
basic_string&
|
||||
>::type
|
||||
replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il)
|
||||
{return replace(__i1, __i2, __il.begin(), __il.end());}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
size_type copy(pointer __s, size_type __n, size_type __pos = 0) const;
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
@@ -1503,7 +1476,7 @@ private:
|
||||
{__r_.first().__l.__cap_ = __long_mask | __s;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
size_type __get_long_cap() const _NOEXCEPT
|
||||
{return __r_.first().__l.__cap_ & size_type(~__long_mask);}
|
||||
{return __r_.first().__l.__cap_ & ~__long_mask;}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __set_long_pointer(pointer __p) _NOEXCEPT
|
||||
@@ -1593,7 +1566,7 @@ private:
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPT
|
||||
void __copy_assign_alloc(const basic_string& __str, false_type) _NOEXCEPT
|
||||
{}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
@@ -1604,27 +1577,6 @@ private:
|
||||
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
|
||||
#endif
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void
|
||||
__move_assign_alloc(basic_string& __str)
|
||||
_NOEXCEPT_(
|
||||
!__alloc_traits::propagate_on_container_move_assignment::value ||
|
||||
is_nothrow_move_assignable<allocator_type>::value)
|
||||
{__move_assign_alloc(__str, integral_constant<bool,
|
||||
__alloc_traits::propagate_on_container_move_assignment::value>());}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __move_assign_alloc(basic_string& __c, true_type)
|
||||
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
|
||||
{
|
||||
__alloc() = _VSTD::move(__c.__alloc());
|
||||
}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void __move_assign_alloc(basic_string&, false_type)
|
||||
_NOEXCEPT
|
||||
{}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static void __swap_alloc(allocator_type& __x, allocator_type& __y)
|
||||
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
|
||||
@@ -1640,7 +1592,7 @@ private:
|
||||
swap(__x, __y);
|
||||
}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
static void __swap_alloc(allocator_type&, allocator_type&, false_type) _NOEXCEPT
|
||||
static void __swap_alloc(allocator_type& __x, allocator_type& __y, false_type) _NOEXCEPT
|
||||
{}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
|
||||
@@ -1671,11 +1623,7 @@ template <class _CharT, class _Traits, class _Allocator>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
#endif
|
||||
void
|
||||
basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type
|
||||
#ifdef _LIBCPP_DEBUG
|
||||
__pos
|
||||
#endif
|
||||
)
|
||||
basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type __pos)
|
||||
{
|
||||
#ifdef _LIBCPP_DEBUG
|
||||
const_iterator __beg = begin();
|
||||
@@ -1994,8 +1942,6 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(_InputIterator __first,
|
||||
__init(__first, __last);
|
||||
}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _CharT, class _Traits, class _Allocator>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
basic_string<_CharT, _Traits, _Allocator>::basic_string(initializer_list<value_type> __il)
|
||||
@@ -2011,8 +1957,6 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(initializer_list<value_t
|
||||
__init(__il.begin(), __il.end());
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _CharT, class _Traits, class _Allocator>
|
||||
basic_string<_CharT, _Traits, _Allocator>::~basic_string()
|
||||
{
|
||||
@@ -2176,8 +2120,7 @@ basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, tr
|
||||
{
|
||||
clear();
|
||||
shrink_to_fit();
|
||||
__r_.first() = __str.__r_.first();
|
||||
__move_assign_alloc(__str);
|
||||
__r_ = _VSTD::move(__str.__r_);
|
||||
__str.__zero();
|
||||
}
|
||||
|
||||
@@ -2208,7 +2151,6 @@ basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _Input
|
||||
clear();
|
||||
for (; __first != __last; ++__first)
|
||||
push_back(*__first);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits, class _Allocator>
|
||||
@@ -2792,7 +2734,7 @@ basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos)
|
||||
iterator __b = begin();
|
||||
size_type __r = static_cast<size_type>(__pos - __b);
|
||||
erase(__r, 1);
|
||||
return __b + static_cast<difference_type>(__r);
|
||||
return __b + __r;
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits, class _Allocator>
|
||||
@@ -2803,7 +2745,7 @@ basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_i
|
||||
iterator __b = begin();
|
||||
size_type __r = static_cast<size_type>(__first - __b);
|
||||
erase(__r, static_cast<size_type>(__last - __first));
|
||||
return __b + static_cast<difference_type>(__r);
|
||||
return __b + __r;
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits, class _Allocator>
|
||||
@@ -3450,17 +3392,7 @@ _LIBCPP_INLINE_VISIBILITY inline
|
||||
int
|
||||
basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPT
|
||||
{
|
||||
size_t __lhs_sz = size();
|
||||
size_t __rhs_sz = __str.size();
|
||||
int __result = traits_type::compare(data(), __str.data(),
|
||||
_VSTD::min(__lhs_sz, __rhs_sz));
|
||||
if (__result != 0)
|
||||
return __result;
|
||||
if (__lhs_sz < __rhs_sz)
|
||||
return -1;
|
||||
if (__lhs_sz > __rhs_sz)
|
||||
return 1;
|
||||
return 0;
|
||||
return compare(0, npos, __str.data(), __str.size());
|
||||
}
|
||||
|
||||
template <class _CharT, class _Traits, class _Allocator>
|
||||
@@ -3490,7 +3422,7 @@ basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
|
||||
|
||||
template <class _CharT, class _Traits, class _Allocator>
|
||||
int
|
||||
basic_string<_CharT, _Traits, _Allocator>::compare(const_pointer __s) const _NOEXCEPT
|
||||
basic_string<_CharT, _Traits, _Allocator>::compare(const_pointer __s) const
|
||||
{
|
||||
#ifdef _LIBCPP_DEBUG
|
||||
assert(__s != 0);
|
||||
@@ -3575,6 +3507,24 @@ operator==(const _CharT* __lhs,
|
||||
return __rhs.compare(__lhs) == 0;
|
||||
}
|
||||
|
||||
template<class _Allocator>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
bool
|
||||
operator==(const char* __lhs,
|
||||
const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT
|
||||
{
|
||||
return strcmp(__lhs, __rhs.data()) == 0;
|
||||
}
|
||||
|
||||
template<class _Allocator>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
bool
|
||||
operator==(const wchar_t* __lhs,
|
||||
const basic_string<wchar_t, char_traits<wchar_t>, _Allocator>& __rhs) _NOEXCEPT
|
||||
{
|
||||
return wcscmp(__lhs, __rhs.data()) == 0;
|
||||
}
|
||||
|
||||
template<class _CharT, class _Traits, class _Allocator>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
bool
|
||||
@@ -3584,6 +3534,24 @@ operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
|
||||
return __lhs.compare(__rhs) == 0;
|
||||
}
|
||||
|
||||
template<class _Allocator>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
bool
|
||||
operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs,
|
||||
const char* __rhs) _NOEXCEPT
|
||||
{
|
||||
return strcmp(__lhs.data(), __rhs) == 0;
|
||||
}
|
||||
|
||||
template<class _Allocator>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
bool
|
||||
operator==(const basic_string<wchar_t, char_traits<wchar_t>, _Allocator>& __lhs,
|
||||
const wchar_t* __rhs) _NOEXCEPT
|
||||
{
|
||||
return wcscmp(__lhs.data(), __rhs) == 0;
|
||||
}
|
||||
|
||||
// operator!=
|
||||
|
||||
template<class _CharT, class _Traits, class _Allocator>
|
||||
@@ -3621,7 +3589,25 @@ bool
|
||||
operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
|
||||
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
|
||||
{
|
||||
return __lhs.compare(__rhs) < 0;
|
||||
return __lhs.cmpare(__rhs) < 0;
|
||||
}
|
||||
|
||||
template<class _Allocator>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
bool
|
||||
operator< (const basic_string<char, char_traits<char>, _Allocator>& __lhs,
|
||||
const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT
|
||||
{
|
||||
return strcmp(__lhs.data(), __rhs.data()) < 0;
|
||||
}
|
||||
|
||||
template<class _Allocator>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
bool
|
||||
operator< (const basic_string<wchar_t, char_traits<wchar_t>, _Allocator>& __lhs,
|
||||
const basic_string<wchar_t, char_traits<wchar_t>, _Allocator>& __rhs) _NOEXCEPT
|
||||
{
|
||||
return wcscmp(__lhs.data(), __rhs.data()) < 0;
|
||||
}
|
||||
|
||||
template<class _CharT, class _Traits, class _Allocator>
|
||||
@@ -3630,7 +3616,25 @@ bool
|
||||
operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
|
||||
const _CharT* __rhs) _NOEXCEPT
|
||||
{
|
||||
return __lhs.compare(__rhs) < 0;
|
||||
return __lhs.compare(__rhs);
|
||||
}
|
||||
|
||||
template<class _Allocator>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
bool
|
||||
operator< (const basic_string<char, char_traits<char>, _Allocator>& __lhs,
|
||||
const char* __rhs) _NOEXCEPT
|
||||
{
|
||||
return strcmp(__lhs.data(), __rhs) < 0;
|
||||
}
|
||||
|
||||
template<class _Allocator>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
bool
|
||||
operator< (const basic_string<wchar_t, char_traits<wchar_t>, _Allocator>& __lhs,
|
||||
const wchar_t* __rhs) _NOEXCEPT
|
||||
{
|
||||
return wcscmp(__lhs.data(), __rhs) < 0;
|
||||
}
|
||||
|
||||
template<class _CharT, class _Traits, class _Allocator>
|
||||
@@ -3642,6 +3646,24 @@ operator< (const _CharT* __lhs,
|
||||
return __rhs.compare(__lhs) > 0;
|
||||
}
|
||||
|
||||
template<class _Allocator>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
bool
|
||||
operator< (const char* __lhs,
|
||||
const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT
|
||||
{
|
||||
return strcmp(__lhs, __rhs.data()) < 0;
|
||||
}
|
||||
|
||||
template<class _Allocator>
|
||||
_LIBCPP_INLINE_VISIBILITY inline
|
||||
bool
|
||||
operator< (const wchar_t* __lhs,
|
||||
const basic_string<wchar_t, char_traits<wchar_t>, _Allocator>& __rhs) _NOEXCEPT
|
||||
{
|
||||
return wcscmp(__lhs, __rhs.data()) < 0;
|
||||
}
|
||||
|
||||
// operator>
|
||||
|
||||
template<class _CharT, class _Traits, class _Allocator>
|
||||
@@ -3915,13 +3937,6 @@ template<class _CharT, class _Traits, class _Allocator>
|
||||
const typename basic_string<_CharT, _Traits, _Allocator>::size_type
|
||||
basic_string<_CharT, _Traits, _Allocator>::npos;
|
||||
|
||||
template<class _Ptr>
|
||||
size_t _LIBCPP_INLINE_VISIBILITY __do_string_hash(_Ptr __p, _Ptr __e)
|
||||
{
|
||||
typedef typename iterator_traits<_Ptr>::value_type value_type;
|
||||
return __murmur2_or_cityhash<size_t>()(__p, (__e-__p)*sizeof(value_type));
|
||||
}
|
||||
|
||||
template<class _CharT, class _Traits, class _Allocator>
|
||||
struct _LIBCPP_VISIBLE hash<basic_string<_CharT, _Traits, _Allocator> >
|
||||
: public unary_function<basic_string<_CharT, _Traits, _Allocator>, size_t>
|
||||
@@ -3935,48 +3950,24 @@ size_t
|
||||
hash<basic_string<_CharT, _Traits, _Allocator> >::operator()(
|
||||
const basic_string<_CharT, _Traits, _Allocator>& __val) const _NOEXCEPT
|
||||
{
|
||||
return __do_string_hash(__val.data(), __val.data() + __val.size());
|
||||
typedef basic_string<_CharT, _Traits, _Allocator> S;
|
||||
typedef typename S::const_pointer const_pointer;
|
||||
size_t __r = 0;
|
||||
const size_t __sr = __CHAR_BIT__ * sizeof(size_t) - 8;
|
||||
const size_t __m = size_t(0xF) << (__sr + 4);
|
||||
const_pointer __p = __val.data();
|
||||
const_pointer __e = __p + __val.size();
|
||||
for (; __p != __e; ++__p)
|
||||
{
|
||||
__r = (__r << 4) + *__p;
|
||||
size_t __g = __r & __m;
|
||||
__r ^= __g | (__g >> __sr);
|
||||
}
|
||||
return __r;
|
||||
}
|
||||
|
||||
template<class _CharT, class _Traits, class _Allocator>
|
||||
basic_ostream<_CharT, _Traits>&
|
||||
operator<<(basic_ostream<_CharT, _Traits>& __os,
|
||||
const basic_string<_CharT, _Traits, _Allocator>& __str);
|
||||
|
||||
template<class _CharT, class _Traits, class _Allocator>
|
||||
basic_istream<_CharT, _Traits>&
|
||||
operator>>(basic_istream<_CharT, _Traits>& __is,
|
||||
basic_string<_CharT, _Traits, _Allocator>& __str);
|
||||
|
||||
template<class _CharT, class _Traits, class _Allocator>
|
||||
basic_istream<_CharT, _Traits>&
|
||||
getline(basic_istream<_CharT, _Traits>& __is,
|
||||
basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
|
||||
|
||||
template<class _CharT, class _Traits, class _Allocator>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
basic_istream<_CharT, _Traits>&
|
||||
getline(basic_istream<_CharT, _Traits>& __is,
|
||||
basic_string<_CharT, _Traits, _Allocator>& __str);
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
template<class _CharT, class _Traits, class _Allocator>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
basic_istream<_CharT, _Traits>&
|
||||
getline(basic_istream<_CharT, _Traits>&& __is,
|
||||
basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
|
||||
|
||||
template<class _CharT, class _Traits, class _Allocator>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
basic_istream<_CharT, _Traits>&
|
||||
getline(basic_istream<_CharT, _Traits>&& __is,
|
||||
basic_string<_CharT, _Traits, _Allocator>& __str);
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
_LIBCPP_EXTERN_TEMPLATE(class basic_string<char>)
|
||||
_LIBCPP_EXTERN_TEMPLATE(class basic_string<wchar_t>)
|
||||
extern template class basic_string<char>;
|
||||
extern template class basic_string<wchar_t>;
|
||||
|
||||
extern template
|
||||
string
|
||||
|
||||
@@ -131,9 +131,7 @@ private:
|
||||
#include <ostream>
|
||||
#include <istream>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
#define atof sun_atof
|
||||
#define strtod sun_strtod
|
||||
#include_next "floatingpoint.h"
|
||||
#undef atof
|
||||
#undef strtod
|
||||
@@ -1,38 +0,0 @@
|
||||
#define iswalpha sun_iswalpha
|
||||
#define iswupper sun_iswupper
|
||||
#define iswlower sun_iswlower
|
||||
#define iswdigit sun_iswdigit
|
||||
#define iswxdigit sun_iswxdigit
|
||||
#define iswalnum sun_iswalnum
|
||||
#define iswspace sun_iswspace
|
||||
#define iswpunct sun_iswpunct
|
||||
#define iswprint sun_iswprint
|
||||
#define iswgraph sun_iswgraph
|
||||
#define iswcntrl sun_iswcntrl
|
||||
#define iswctype sun_iswctype
|
||||
#define towlower sun_towlower
|
||||
#define towupper sun_towupper
|
||||
#define wcswcs sun_wcswcs
|
||||
#define wcswidth sun_wcswidth
|
||||
#define wcwidth sun_wcwidth
|
||||
#define wctype sun_wctype
|
||||
#define _WCHAR_T 1
|
||||
#include_next "wchar.h"
|
||||
#undef iswalpha
|
||||
#undef iswupper
|
||||
#undef iswlower
|
||||
#undef iswdigit
|
||||
#undef iswxdigit
|
||||
#undef iswalnum
|
||||
#undef iswspace
|
||||
#undef iswpunct
|
||||
#undef iswprint
|
||||
#undef iswgraph
|
||||
#undef iswcntrl
|
||||
#undef iswctype
|
||||
#undef towlower
|
||||
#undef towupper
|
||||
#undef wcswcs
|
||||
#undef wcswidth
|
||||
#undef wcwidth
|
||||
#undef wctype
|
||||
@@ -1,146 +0,0 @@
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Minimal xlocale implementation for Solaris. This implements the subset of
|
||||
// the xlocale APIs that libc++ depends on.
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
#ifndef __XLOCALE_H_INCLUDED
|
||||
#define __XLOCALE_H_INCLUDED
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
typedef struct _LC_locale_t* locale_t;
|
||||
|
||||
#define LC_COLLATE_MASK (1<<0)
|
||||
#define LC_CTYPE_MASK (1<<1)
|
||||
#define LC_MESSAGES_MASK (1<<2)
|
||||
#define LC_MONETARY_MASK (1<<3)
|
||||
#define LC_NUMERIC_MASK (1<<4)
|
||||
#define LC_TIME_MASK (1<<5)
|
||||
#define LC_ALL_MASK (LC_COLLATE_MASK | LC_CTYPE_MASK | LC_MESSAGES_MASK | \
|
||||
LC_MONETARY_MASK | LC_NUMERIC_MASK | LC_TIME_MASK)
|
||||
|
||||
#define LC_GLOBAL_LOCALE ((locale_t)-1)
|
||||
|
||||
size_t __mb_cur_max(locale_t l);
|
||||
#define MB_CUR_MAX_L(l) __mb_cur_max(l)
|
||||
|
||||
locale_t newlocale(int mask, const char * locale, locale_t base);
|
||||
void freelocale(locale_t loc);
|
||||
|
||||
wint_t btowc_l(int __c, locale_t __l);
|
||||
|
||||
int wctob_l(wint_t __c, locale_t __l);
|
||||
|
||||
size_t wcrtomb_l(char *__s, wchar_t __wc, mbstate_t *__ps, locale_t __l);
|
||||
|
||||
size_t mbrtowc_l(wchar_t *__pwc, const char *__s, size_t __n,
|
||||
mbstate_t *__ps, locale_t __l);
|
||||
|
||||
int mbtowc_l(wchar_t *__pwc, const char *__pmb, size_t __max, locale_t __l);
|
||||
|
||||
size_t mbrlen_l(const char *__s, size_t __n, mbstate_t *__ps, locale_t __l);
|
||||
|
||||
struct lconv *localeconv_l(locale_t __l);
|
||||
|
||||
size_t mbsrtowcs_l(wchar_t *__dest, const char **__src, size_t __len,
|
||||
mbstate_t *__ps, locale_t __l);
|
||||
|
||||
int sprintf_l(char *__s, locale_t __l, const char *__format, ...);
|
||||
|
||||
int snprintf_l(char *__s, size_t __n, locale_t __l, const char *__format, ...);
|
||||
|
||||
int asprintf_l(char **__s, locale_t __l, const char *__format, ...);
|
||||
|
||||
int sscanf_l(const char *__s, locale_t __l, const char *__format, ...);
|
||||
|
||||
int isalnum_l(int,locale_t);
|
||||
int isalpha_l(int,locale_t);
|
||||
int isblank_l(int,locale_t);
|
||||
int iscntrl_l(int,locale_t);
|
||||
int isdigit_l(int,locale_t);
|
||||
int isgraph_l(int,locale_t);
|
||||
int islower_l(int,locale_t);
|
||||
int isprint_l(int,locale_t);
|
||||
int ispunct_l(int,locale_t);
|
||||
int isspace_l(int,locale_t);
|
||||
int isupper_l(int,locale_t);
|
||||
int isxdigit_l(int,locale_t);
|
||||
|
||||
int iswalnum_l(wchar_t,locale_t);
|
||||
int iswalpha_l(wchar_t,locale_t);
|
||||
int iswblank_l(wchar_t,locale_t);
|
||||
int iswcntrl_l(wchar_t,locale_t);
|
||||
int iswdigit_l(wchar_t,locale_t);
|
||||
int iswgraph_l(wchar_t,locale_t);
|
||||
int iswlower_l(wchar_t,locale_t);
|
||||
int iswprint_l(wchar_t,locale_t);
|
||||
int iswpunct_l(wchar_t,locale_t);
|
||||
int iswspace_l(wchar_t,locale_t);
|
||||
int iswupper_l(wchar_t,locale_t);
|
||||
int iswxdigit_l(wchar_t,locale_t);
|
||||
|
||||
int iswctype_l(wint_t, wctype_t, locale_t);
|
||||
|
||||
int toupper_l(int __c, locale_t __l);
|
||||
int tolower_l(int __c, locale_t __l);
|
||||
wint_t towupper_l(wint_t __c, locale_t __l);
|
||||
wint_t towlower_l(wint_t __c, locale_t __l);
|
||||
|
||||
|
||||
int strcoll_l(const char *__s1, const char *__s2, locale_t __l);
|
||||
int wcscoll_l(const wchar_t *__s1, const wchar_t *__s2, locale_t __l);
|
||||
size_t strftime_l(char *__s, size_t __size, const char *__fmt, const struct tm
|
||||
*__tm, locale_t __l);
|
||||
|
||||
size_t strxfrm_l(char *__s1, const char *__s2, size_t __n, locale_t __l);
|
||||
|
||||
size_t wcsxfrm_l(wchar_t *__ws1, const wchar_t *__ws2, size_t __n,
|
||||
locale_t __l);
|
||||
|
||||
|
||||
|
||||
size_t
|
||||
mbsnrtowcs_l(wchar_t * __restrict dst, const char ** __restrict src,
|
||||
size_t nms, size_t len, mbstate_t * __restrict ps, locale_t loc);
|
||||
|
||||
|
||||
size_t
|
||||
wcsnrtombs_l(char * __restrict dst, const wchar_t ** __restrict src,
|
||||
size_t nwc, size_t len, mbstate_t * __restrict ps, locale_t loc);
|
||||
|
||||
locale_t __cloc(void);
|
||||
|
||||
// FIXME: These are quick-and-dirty hacks to make things pretend to work
|
||||
static inline
|
||||
long long strtoll_l(const char *__nptr, char **__endptr,
|
||||
int __base, locale_t __loc) {
|
||||
return strtoll(__nptr, __endptr, __base);
|
||||
}
|
||||
static inline
|
||||
long strtol_l(const char *__nptr, char **__endptr,
|
||||
int __base, locale_t __loc) {
|
||||
return strtol(__nptr, __endptr, __base);
|
||||
}
|
||||
static inline
|
||||
long double strtold_l(const char *__nptr, char **__endptr,
|
||||
locale_t __loc) {
|
||||
return strtold(__nptr, __endptr);
|
||||
}
|
||||
static inline
|
||||
unsigned long long strtoull_l(const char *__nptr, char **__endptr,
|
||||
int __base, locale_t __loc) {
|
||||
return strtoull(__nptr, __endptr, __base);
|
||||
}
|
||||
static inline
|
||||
unsigned long strtoul_l(const char *__nptr, char **__endptr,
|
||||
int __base, locale_t __loc) {
|
||||
return strtoul(__nptr, __endptr, __base);
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,79 +0,0 @@
|
||||
// -*- C++ -*-
|
||||
//===--------------------- support/win32/limits_win32.h -------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is dual licensed under the MIT and the University of Illinois Open
|
||||
// Source Licenses. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP_SUPPORT_WIN32_LIMITS_WIN32_H
|
||||
#define _LIBCPP_SUPPORT_WIN32_LIMITS_WIN32_H
|
||||
|
||||
#if !defined(_MSC_VER)
|
||||
#error "This header is MSVC specific, Clang and GCC should not include it"
|
||||
#else
|
||||
|
||||
#ifndef NOMINMAX
|
||||
#define NOMINMAX
|
||||
#endif
|
||||
#include <windows.h> // ymath.h works correctly
|
||||
|
||||
#include <float.h> // limit constants
|
||||
|
||||
#define __FLT_MANT_DIG__ FLT_MANT_DIG
|
||||
#define __FLT_DIG__ FLT_DIG
|
||||
#define __FLT_RADIX__ FLT_RADIX
|
||||
#define __FLT_MIN_EXP__ FLT_MIN_EXP
|
||||
#define __FLT_MIN_10_EXP__ FLT_MIN_10_EXP
|
||||
#define __FLT_MAX_EXP__ FLT_MAX_EXP
|
||||
#define __FLT_MAX_10_EXP__ FLT_MAX_10_EXP
|
||||
#define __FLT_MIN__ FLT_MIN
|
||||
#define __FLT_MAX__ FLT_MAX
|
||||
#define __FLT_EPSILON__ FLT_EPSILON
|
||||
// predefined by MinGW GCC
|
||||
#define __FLT_DENORM_MIN__ 1.40129846432481707092e-45F
|
||||
|
||||
#define __DBL_MANT_DIG__ DBL_MANT_DIG
|
||||
#define __DBL_DIG__ DBL_DIG
|
||||
#define __DBL_RADIX__ DBL_RADIX
|
||||
#define __DBL_MIN_EXP__ DBL_MIN_EXP
|
||||
#define __DBL_MIN_10_EXP__ DBL_MIN_10_EXP
|
||||
#define __DBL_MAX_EXP__ DBL_MAX_EXP
|
||||
#define __DBL_MAX_10_EXP__ DBL_MAX_10_EXP
|
||||
#define __DBL_MIN__ DBL_MIN
|
||||
#define __DBL_MAX__ DBL_MAX
|
||||
#define __DBL_EPSILON__ DBL_EPSILON
|
||||
// predefined by MinGW GCC
|
||||
#define __DBL_DENORM_MIN__ double(4.94065645841246544177e-324L)
|
||||
|
||||
#define __LDBL_MANT_DIG__ LDBL_MANT_DIG
|
||||
#define __LDBL_DIG__ LDBL_DIG
|
||||
#define __LDBL_RADIX__ LDBL_RADIX
|
||||
#define __LDBL_MIN_EXP__ LDBL_MIN_EXP
|
||||
#define __LDBL_MIN_10_EXP__ LDBL_MIN_10_EXP
|
||||
#define __LDBL_MAX_EXP__ LDBL_MAX_EXP
|
||||
#define __LDBL_MAX_10_EXP__ LDBL_MAX_10_EXP
|
||||
#define __LDBL_MIN__ LDBL_MIN
|
||||
#define __LDBL_MAX__ LDBL_MAX
|
||||
#define __LDBL_EPSILON__ LDBL_EPSILON
|
||||
// predefined by MinGW GCC
|
||||
#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L
|
||||
|
||||
// __builtin replacements/workarounds
|
||||
#include <math.h> // HUGE_VAL
|
||||
#include <ymath.h> // internal MSVC header providing the needed functionality
|
||||
#define __builtin_huge_val() HUGE_VAL
|
||||
#define __builtin_huge_valf() _FInf._Float
|
||||
#define __builtin_huge_vall() _LInf._Long_double
|
||||
#define __builtin_nan(__dummy) _Nan._Double
|
||||
#define __builtin_nanf(__dummy) _FNan._Float
|
||||
#define __builtin_nanl(__dummmy) _LNan._Long_double
|
||||
#define __builtin_nans(__dummy) _Snan._Double
|
||||
#define __builtin_nansf(__dummy) _FSnan._Float
|
||||
#define __builtin_nansl(__dummy) _LSnan._Long_double
|
||||
|
||||
#endif // _MSC_VER
|
||||
|
||||
#endif // _LIBCPP_SUPPORT_WIN32_LIMITS_WIN32_H
|
||||
@@ -1,116 +0,0 @@
|
||||
// -*- C++ -*-
|
||||
//===--------------------- support/win32/locale_win32.h -------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is dual licensed under the MIT and the University of Illinois Open
|
||||
// Source Licenses. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H
|
||||
#define _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H
|
||||
|
||||
// ctype mask table defined in msvcrt.dll
|
||||
extern "C" unsigned short __declspec(dllimport) _ctype[];
|
||||
|
||||
#include "support/win32/support.h"
|
||||
#include <memory>
|
||||
#include <xlocinfo.h> // _locale_t
|
||||
#define locale_t _locale_t
|
||||
#define LC_COLLATE_MASK _M_COLLATE
|
||||
#define LC_CTYPE_MASK _M_CTYPE
|
||||
#define LC_MONETARY_MASK _M_MONETARY
|
||||
#define LC_NUMERIC_MASK _M_NUMERIC
|
||||
#define LC_TIME_MASK _M_TIME
|
||||
#define LC_MESSAGES_MASK _M_MESSAGES
|
||||
#define LC_ALL_MASK ( LC_COLLATE_MASK \
|
||||
| LC_CTYPE_MASK \
|
||||
| LC_MESSAGES_MASK \
|
||||
| LC_MONETARY_MASK \
|
||||
| LC_NUMERIC_MASK \
|
||||
| LC_TIME_MASK )
|
||||
#define freelocale _free_locale
|
||||
// FIXME: base currently unused. Needs manual work to construct the new locale
|
||||
locale_t newlocale( int mask, const char * locale, locale_t base );
|
||||
locale_t uselocale( locale_t newloc );
|
||||
lconv *localeconv_l( locale_t loc );
|
||||
size_t mbrlen_l( const char *__restrict__ s, size_t n,
|
||||
mbstate_t *__restrict__ ps, locale_t loc);
|
||||
size_t mbsrtowcs_l( wchar_t *__restrict__ dst, const char **__restrict__ src,
|
||||
size_t len, mbstate_t *__restrict__ ps, locale_t loc );
|
||||
size_t wcrtomb_l( char *__restrict__ s, wchar_t wc, mbstate_t *__restrict__ ps,
|
||||
locale_t loc);
|
||||
size_t mbrtowc_l( wchar_t *__restrict__ pwc, const char *__restrict__ s,
|
||||
size_t n, mbstate_t *__restrict__ ps, locale_t loc);
|
||||
size_t mbsnrtowcs_l( wchar_t *__restrict__ dst, const char **__restrict__ src,
|
||||
size_t nms, size_t len, mbstate_t *__restrict__ ps, locale_t loc);
|
||||
size_t wcsnrtombs_l( char *__restrict__ dst, const wchar_t **__restrict__ src,
|
||||
size_t nwc, size_t len, mbstate_t *__restrict__ ps, locale_t loc);
|
||||
wint_t btowc_l( int c, locale_t loc );
|
||||
int wctob_l( wint_t c, locale_t loc );
|
||||
typedef _VSTD::remove_pointer<locale_t>::type __locale_struct;
|
||||
typedef _VSTD::unique_ptr<__locale_struct, decltype(&uselocale)> __locale_raii;
|
||||
_LIBCPP_ALWAYS_INLINE inline
|
||||
decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l )
|
||||
{
|
||||
__locale_raii __current( uselocale(__l), uselocale );
|
||||
return MB_CUR_MAX;
|
||||
}
|
||||
|
||||
// the *_l functions are prefixed on Windows, only available for msvcr80+, VS2005+
|
||||
#include <stdio.h>
|
||||
#define mbtowc_l _mbtowc_l
|
||||
#define strtoll_l _strtoi64_l
|
||||
#define strtoull_l _strtoui64_l
|
||||
// FIXME: current msvcrt does not know about long double
|
||||
#define strtold_l _strtod_l
|
||||
#define islower_l _islower_l
|
||||
#define isupper_l _isupper_l
|
||||
#define isdigit_l _isdigit_l
|
||||
#define isxdigit_l _isxdigit_l
|
||||
#define strcoll_l _strcoll_l
|
||||
#define strxfrm_l _strxfrm_l
|
||||
#define wcscoll_l _wcscoll_l
|
||||
#define wcsxfrm_l _wcsxfrm_l
|
||||
#define toupper_l _toupper_l
|
||||
#define tolower_l _tolower_l
|
||||
#define iswspace_l _iswspace_l
|
||||
#define iswprint_l _iswprint_l
|
||||
#define iswcntrl_l _iswcntrl_l
|
||||
#define iswupper_l _iswupper_l
|
||||
#define iswlower_l _iswlower_l
|
||||
#define iswalpha_l _iswalpha_l
|
||||
#define iswdigit_l _iswdigit_l
|
||||
#define iswpunct_l _iswpunct_l
|
||||
#define iswxdigit_l _iswxdigit_l
|
||||
#define towupper_l _towupper_l
|
||||
#define towlower_l _towlower_l
|
||||
#define strftime_l _strftime_l
|
||||
#define sscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ )
|
||||
#define vsscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ )
|
||||
#define sprintf_l( __s, __l, __f, ... ) _sprintf_l( __s, __f, __l, __VA_ARGS__ )
|
||||
#define snprintf_l( __s, __n, __l, __f, ... ) _snprintf_l( __s, __n, __f, __l, __VA_ARGS__ )
|
||||
#define vsprintf_l( __s, __l, __f, ... ) _vsprintf_l( __s, __f, __l, __VA_ARGS__ )
|
||||
#define vsnprintf_l( __s, __n, __l, __f, ... ) _vsnprintf_l( __s, __n, __f, __l, __VA_ARGS__ )
|
||||
int asprintf_l( char **ret, locale_t loc, const char *format, ... );
|
||||
int vasprintf_l( char **ret, locale_t loc, const char *format, va_list ap );
|
||||
|
||||
|
||||
// not-so-pressing FIXME: use locale to determine blank characters
|
||||
inline int isblank_l( int c, locale_t /*loc*/ )
|
||||
{
|
||||
return ( c == ' ' || c == '\t' );
|
||||
}
|
||||
inline int iswblank_l( wint_t c, locale_t /*loc*/ )
|
||||
{
|
||||
return ( c == L' ' || c == L'\t' );
|
||||
}
|
||||
|
||||
#ifdef _MSC_VER
|
||||
inline int isblank( int c, locale_t /*loc*/ )
|
||||
{ return ( c == ' ' || c == '\t' ); }
|
||||
inline int iswblank( wint_t c, locale_t /*loc*/ )
|
||||
{ return ( c == L' ' || c == L'\t' ); }
|
||||
#endif // _MSC_VER
|
||||
#endif // _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H
|
||||
@@ -1,113 +0,0 @@
|
||||
// -*- C++ -*-
|
||||
//===---------------------- support/win32/math_win32.h --------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is dual licensed under the MIT and the University of Illinois Open
|
||||
// Source Licenses. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP_SUPPORT_WIN32_MATH_WIN32_H
|
||||
#define _LIBCPP_SUPPORT_WIN32_MATH_WIN32_H
|
||||
|
||||
#if !defined(_MSC_VER)
|
||||
#error "This header is MSVC specific, Clang and GCC should not include it"
|
||||
#else
|
||||
|
||||
#include <math.h>
|
||||
|
||||
typedef float float_t;
|
||||
typedef double double_t;
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE bool isfinite( double num )
|
||||
{
|
||||
return _finite(num) != 0;
|
||||
}
|
||||
_LIBCPP_ALWAYS_INLINE bool isinf( double num )
|
||||
{
|
||||
return !isfinite(num) && !_isnan(num);
|
||||
}
|
||||
_LIBCPP_ALWAYS_INLINE bool isnan( double num )
|
||||
{
|
||||
return _isnan(num) != 0;
|
||||
}
|
||||
_LIBCPP_ALWAYS_INLINE bool isnormal( double num )
|
||||
{
|
||||
int class_ = _fpclass(num);
|
||||
return class_ == _FPCLASS_NN || class_ == _FPCLASS_PN;
|
||||
}
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE bool isgreater( double x, double y )
|
||||
{
|
||||
if(_fpclass(x) == _FPCLASS_SNAN || _fpclass(y) == _FPCLASS_SNAN) return false;
|
||||
else return x > y;
|
||||
}
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE bool isgreaterequal( double x, double y )
|
||||
{
|
||||
if(_fpclass(x) == _FPCLASS_SNAN || _fpclass(y) == _FPCLASS_SNAN) return false;
|
||||
else return x >= y;
|
||||
}
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE bool isless( double x, double y )
|
||||
{
|
||||
if(_fpclass(x) == _FPCLASS_SNAN || _fpclass(y) == _FPCLASS_SNAN) return false;
|
||||
else return x < y;
|
||||
}
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE bool islessequal( double x, double y )
|
||||
{
|
||||
if(::_fpclass(x) == _FPCLASS_SNAN || ::_fpclass(y) == _FPCLASS_SNAN) return false;
|
||||
else return x <= y;
|
||||
}
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE bool islessgreater( double x, double y )
|
||||
{
|
||||
if(::_fpclass(x) == _FPCLASS_SNAN || ::_fpclass(y) == _FPCLASS_SNAN) return false;
|
||||
else return x < y || x > y;
|
||||
}
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE bool isunordered( double x, double y )
|
||||
{
|
||||
return isnan(x) || isnan(y);
|
||||
}
|
||||
_LIBCPP_ALWAYS_INLINE bool signbit( double num )
|
||||
{
|
||||
switch(_fpclass(num))
|
||||
{
|
||||
case _FPCLASS_SNAN:
|
||||
case _FPCLASS_QNAN:
|
||||
case _FPCLASS_NINF:
|
||||
case _FPCLASS_NN:
|
||||
case _FPCLASS_ND:
|
||||
case _FPCLASS_NZ:
|
||||
return true;
|
||||
case _FPCLASS_PZ:
|
||||
case _FPCLASS_PD:
|
||||
case _FPCLASS_PN:
|
||||
case _FPCLASS_PINF:
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
_LIBCPP_ALWAYS_INLINE float copysignf( float x, float y )
|
||||
{
|
||||
return (signbit (x) != signbit (y) ? - x : x);
|
||||
}
|
||||
_LIBCPP_ALWAYS_INLINE double copysign( double x, double y )
|
||||
{
|
||||
return ::_copysign(x,y);
|
||||
}
|
||||
_LIBCPP_ALWAYS_INLINE double copysignl( long double x, long double y )
|
||||
{
|
||||
return ::_copysignl(x,y);
|
||||
}
|
||||
_LIBCPP_ALWAYS_INLINE int fpclassify( double num )
|
||||
{
|
||||
return _fpclass(num);
|
||||
}
|
||||
|
||||
#endif // _MSC_VER
|
||||
|
||||
#endif // _LIBCPP_SUPPORT_WIN32_MATH_WIN32_H
|
||||
@@ -1,115 +0,0 @@
|
||||
// -*- C++ -*-
|
||||
//===----------------------- support/win32/support.h ----------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is dual licensed under the MIT and the University of Illinois Open
|
||||
// Source Licenses. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef _LIBCPP_SUPPORT_WIN32_SUPPORT_H
|
||||
#define _LIBCPP_SUPPORT_WIN32_SUPPORT_H
|
||||
|
||||
/*
|
||||
Functions and constants used in libc++ that are missing from the Windows C library.
|
||||
*/
|
||||
|
||||
#include <__config>
|
||||
#include <wchar.h> // mbstate_t
|
||||
#include <stdio.h> // _snwprintf
|
||||
#define swprintf _snwprintf
|
||||
#define vswprintf _vsnwprintf
|
||||
#define vfscnaf fscanf
|
||||
|
||||
int vasprintf( char **sptr, const char *__restrict fmt , va_list ap );
|
||||
int asprintf( char **sptr, const char *__restrict fmt, ...);
|
||||
//int vfscanf( FILE *__restrict stream, const char *__restrict format,
|
||||
// va_list arg);
|
||||
|
||||
size_t mbsnrtowcs( wchar_t *__restrict dst, const char **__restrict src,
|
||||
size_t nmc, size_t len, mbstate_t *__restrict ps );
|
||||
size_t wcsnrtombs( char *__restrict dst, const wchar_t **__restrict src,
|
||||
size_t nwc, size_t len, mbstate_t *__restrict ps );
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#define snprintf _snprintf
|
||||
|
||||
#include <xlocinfo.h>
|
||||
#define atoll _atoi64
|
||||
#define strtoll _strtoi64
|
||||
#define strtoull _strtoui64
|
||||
#define wcstoll _wcstoi64
|
||||
#define wcstoull _wcstoui64
|
||||
_LIBCPP_ALWAYS_INLINE float strtof( const char *nptr, char **endptr )
|
||||
{ return _Stof(nptr, endptr, 0); }
|
||||
_LIBCPP_ALWAYS_INLINE double strtod( const char *nptr, char **endptr )
|
||||
{ return _Stod(nptr, endptr, 0); }
|
||||
_LIBCPP_ALWAYS_INLINE long double strtold( const char *nptr, char **endptr )
|
||||
{ return _Stold(nptr, endptr, 0); }
|
||||
|
||||
#define _Exit _exit
|
||||
|
||||
#ifndef __clang__ // MSVC-based Clang also defines _MSC_VER
|
||||
#include <intrin.h>
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE int __builtin_popcount(unsigned int x) {
|
||||
static const unsigned int m1 = 0x55555555; //binary: 0101...
|
||||
static const unsigned int m2 = 0x33333333; //binary: 00110011..
|
||||
static const unsigned int m4 = 0x0f0f0f0f; //binary: 4 zeros, 4 ones ...
|
||||
static const unsigned int h01= 0x01010101; //the sum of 256 to the power of 0,1,2,3...
|
||||
x -= (x >> 1) & m1; //put count of each 2 bits into those 2 bits
|
||||
x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits
|
||||
x = (x + (x >> 4)) & m4; //put count of each 8 bits into those 8 bits
|
||||
return (x * h01) >> 24; //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24)
|
||||
}
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE int __builtin_popcountl(unsigned long x) {
|
||||
return __builtin_popcount(static_cast<int>(x));
|
||||
}
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE int __builtin_popcountll(unsigned long long x) {
|
||||
static const unsigned long long m1 = 0x5555555555555555; //binary: 0101...
|
||||
static const unsigned long long m2 = 0x3333333333333333; //binary: 00110011..
|
||||
static const unsigned long long m4 = 0x0f0f0f0f0f0f0f0f; //binary: 4 zeros, 4 ones ...
|
||||
static const unsigned long long h01 = 0x0101010101010101; //the sum of 256 to the power of 0,1,2,3...
|
||||
x -= (x >> 1) & m1; //put count of each 2 bits into those 2 bits
|
||||
x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits
|
||||
x = (x + (x >> 4)) & m4; //put count of each 8 bits into those 8 bits
|
||||
return static_cast<int>((x * h01)>>56); //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ...
|
||||
}
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE int __builtin_ctz( unsigned int x )
|
||||
{
|
||||
DWORD r = 0;
|
||||
_BitScanReverse(&r, x);
|
||||
return static_cast<int>(r);
|
||||
}
|
||||
// sizeof(long) == sizeof(int) on Windows
|
||||
_LIBCPP_ALWAYS_INLINE int __builtin_ctzl( unsigned long x )
|
||||
{ return __builtin_ctz( static_cast<int>(x) ); }
|
||||
_LIBCPP_ALWAYS_INLINE int __builtin_ctzll( unsigned long long x )
|
||||
{
|
||||
DWORD r = 0;
|
||||
_BitScanReverse64(&r, x);
|
||||
return static_cast<int>(r);
|
||||
}
|
||||
_LIBCPP_ALWAYS_INLINE int __builtin_clz( unsigned int x )
|
||||
{
|
||||
DWORD r = 0;
|
||||
_BitScanForward(&r, x);
|
||||
return static_cast<int>(r);
|
||||
}
|
||||
// sizeof(long) == sizeof(int) on Windows
|
||||
_LIBCPP_ALWAYS_INLINE int __builtin_clzl( unsigned long x )
|
||||
{ return __builtin_clz( static_cast<int>(x) ); }
|
||||
_LIBCPP_ALWAYS_INLINE int __builtin_clzll( unsigned long long x )
|
||||
{
|
||||
DWORD r = 0;
|
||||
_BitScanForward64(&r, x);
|
||||
return static_cast<int>(r);
|
||||
}
|
||||
#endif // !__clang__
|
||||
#endif // _MSC_VER
|
||||
|
||||
#endif // _LIBCPP_SUPPORT_WIN32_SUPPORT_H
|
||||
@@ -223,9 +223,7 @@ template <> struct hash<std::error_code>;
|
||||
#include <stdexcept>
|
||||
#include <__functional_base>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
@@ -245,8 +243,9 @@ struct _LIBCPP_VISIBLE is_error_condition_enum
|
||||
// for them:
|
||||
|
||||
//enum class errc
|
||||
_LIBCPP_DECLARE_STRONG_ENUM(errc)
|
||||
struct errc
|
||||
{
|
||||
enum _ {
|
||||
address_family_not_supported = EAFNOSUPPORT,
|
||||
address_in_use = EADDRINUSE,
|
||||
address_not_available = EADDRNOTAVAIL,
|
||||
@@ -342,32 +341,38 @@ _LIBCPP_DECLARE_STRONG_ENUM(errc)
|
||||
value_too_large = EOVERFLOW,
|
||||
wrong_protocol_type = EPROTOTYPE
|
||||
};
|
||||
_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc)
|
||||
|
||||
_ __v_;
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
errc(_ __v) : __v_(__v) {}
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
operator int() const {return __v_;}
|
||||
|
||||
};
|
||||
|
||||
template <>
|
||||
struct _LIBCPP_VISIBLE is_error_condition_enum<errc>
|
||||
: true_type { };
|
||||
|
||||
#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
|
||||
template <>
|
||||
struct _LIBCPP_VISIBLE is_error_condition_enum<errc::__lx>
|
||||
struct _LIBCPP_VISIBLE is_error_condition_enum<errc::_>
|
||||
: true_type { };
|
||||
#endif
|
||||
|
||||
class _LIBCPP_VISIBLE error_condition;
|
||||
class _LIBCPP_VISIBLE error_code;
|
||||
class error_condition;
|
||||
class error_code;
|
||||
|
||||
// class error_category
|
||||
|
||||
class _LIBCPP_HIDDEN __do_message;
|
||||
class __do_message;
|
||||
|
||||
class _LIBCPP_VISIBLE error_category
|
||||
{
|
||||
public:
|
||||
virtual ~error_category() _NOEXCEPT;
|
||||
|
||||
error_category() _NOEXCEPT;
|
||||
private:
|
||||
error_category() _NOEXCEPT;
|
||||
error_category(const error_category&);// = delete;
|
||||
error_category& operator=(const error_category&);// = delete;
|
||||
|
||||
@@ -387,7 +392,7 @@ public:
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
|
||||
|
||||
friend class _LIBCPP_HIDDEN __do_message;
|
||||
friend class __do_message;
|
||||
};
|
||||
|
||||
class _LIBCPP_HIDDEN __do_message
|
||||
@@ -412,10 +417,10 @@ public:
|
||||
error_condition(int __val, const error_category& __cat) _NOEXCEPT
|
||||
: __val_(__val), __cat_(&__cat) {}
|
||||
|
||||
template <class _Ep>
|
||||
template <class _E>
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
error_condition(_Ep __e,
|
||||
typename enable_if<is_error_condition_enum<_Ep>::value>::type* = 0
|
||||
error_condition(_E __e,
|
||||
typename enable_if<is_error_condition_enum<_E>::value>::type* = 0
|
||||
) _NOEXCEPT
|
||||
{*this = make_error_condition(__e);}
|
||||
|
||||
@@ -426,14 +431,14 @@ public:
|
||||
__cat_ = &__cat;
|
||||
}
|
||||
|
||||
template <class _Ep>
|
||||
template <class _E>
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
typename enable_if
|
||||
<
|
||||
is_error_condition_enum<_Ep>::value,
|
||||
is_error_condition_enum<_E>::value,
|
||||
error_condition&
|
||||
>::type
|
||||
operator=(_Ep __e) _NOEXCEPT
|
||||
operator=(_E __e) _NOEXCEPT
|
||||
{*this = make_error_condition(__e); return *this;}
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
@@ -451,7 +456,7 @@ public:
|
||||
string message() const;
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
_LIBCPP_EXPLICIT
|
||||
//explicit
|
||||
operator bool() const _NOEXCEPT {return __val_ != 0;}
|
||||
};
|
||||
|
||||
@@ -467,7 +472,7 @@ bool
|
||||
operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
|
||||
{
|
||||
return __x.category() < __y.category()
|
||||
|| (__x.category() == __y.category() && __x.value() < __y.value());
|
||||
|| __x.category() == __y.category() && __x.value() < __y.value();
|
||||
}
|
||||
|
||||
// error_code
|
||||
@@ -484,10 +489,10 @@ public:
|
||||
error_code(int __val, const error_category& __cat) _NOEXCEPT
|
||||
: __val_(__val), __cat_(&__cat) {}
|
||||
|
||||
template <class _Ep>
|
||||
template <class _E>
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
error_code(_Ep __e,
|
||||
typename enable_if<is_error_code_enum<_Ep>::value>::type* = 0
|
||||
error_code(_E __e,
|
||||
typename enable_if<is_error_code_enum<_E>::value>::type* = 0
|
||||
) _NOEXCEPT
|
||||
{*this = make_error_code(__e);}
|
||||
|
||||
@@ -498,14 +503,14 @@ public:
|
||||
__cat_ = &__cat;
|
||||
}
|
||||
|
||||
template <class _Ep>
|
||||
template <class _E>
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
typename enable_if
|
||||
<
|
||||
is_error_code_enum<_Ep>::value,
|
||||
is_error_code_enum<_E>::value,
|
||||
error_code&
|
||||
>::type
|
||||
operator=(_Ep __e) _NOEXCEPT
|
||||
operator=(_E __e) _NOEXCEPT
|
||||
{*this = make_error_code(__e); return *this;}
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
@@ -528,7 +533,7 @@ public:
|
||||
string message() const;
|
||||
|
||||
_LIBCPP_ALWAYS_INLINE
|
||||
_LIBCPP_EXPLICIT
|
||||
//explicit
|
||||
operator bool() const _NOEXCEPT {return __val_ != 0;}
|
||||
};
|
||||
|
||||
@@ -544,7 +549,7 @@ bool
|
||||
operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
|
||||
{
|
||||
return __x.category() < __y.category()
|
||||
|| (__x.category() == __y.category() && __x.value() < __y.value());
|
||||
|| __x.category() == __y.category() && __x.value() < __y.value();
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
|
||||
@@ -22,8 +22,6 @@
|
||||
#include <complex.h>
|
||||
#include <math.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#endif // _LIBCPP_TGMATH_H
|
||||
|
||||
171
include/thread
171
include/thread
@@ -26,41 +26,41 @@ public:
|
||||
class id;
|
||||
typedef pthread_t native_handle_type;
|
||||
|
||||
thread() noexcept;
|
||||
thread();
|
||||
template <class F, class ...Args> explicit thread(F&& f, Args&&... args);
|
||||
~thread();
|
||||
|
||||
thread(const thread&) = delete;
|
||||
thread(thread&& t) noexcept;
|
||||
thread(thread&& t);
|
||||
|
||||
thread& operator=(const thread&) = delete;
|
||||
thread& operator=(thread&& t) noexcept;
|
||||
thread& operator=(thread&& t);
|
||||
|
||||
void swap(thread& t) noexcept;
|
||||
void swap(thread& t);
|
||||
|
||||
bool joinable() const noexcept;
|
||||
bool joinable() const;
|
||||
void join();
|
||||
void detach();
|
||||
id get_id() const noexcept;
|
||||
id get_id() const;
|
||||
native_handle_type native_handle();
|
||||
|
||||
static unsigned hardware_concurrency() noexcept;
|
||||
static unsigned hardware_concurrency();
|
||||
};
|
||||
|
||||
void swap(thread& x, thread& y) noexcept;
|
||||
void swap(thread& x, thread& y);
|
||||
|
||||
class thread::id
|
||||
{
|
||||
public:
|
||||
id() noexcept;
|
||||
id();
|
||||
};
|
||||
|
||||
bool operator==(thread::id x, thread::id y) noexcept;
|
||||
bool operator!=(thread::id x, thread::id y) noexcept;
|
||||
bool operator< (thread::id x, thread::id y) noexcept;
|
||||
bool operator<=(thread::id x, thread::id y) noexcept;
|
||||
bool operator> (thread::id x, thread::id y) noexcept;
|
||||
bool operator>=(thread::id x, thread::id y) noexcept;
|
||||
bool operator==(thread::id x, thread::id y);
|
||||
bool operator!=(thread::id x, thread::id y);
|
||||
bool operator< (thread::id x, thread::id y);
|
||||
bool operator<=(thread::id x, thread::id y);
|
||||
bool operator> (thread::id x, thread::id y);
|
||||
bool operator>=(thread::id x, thread::id y);
|
||||
|
||||
template<class charT, class traits>
|
||||
basic_ostream<charT, traits>&
|
||||
@@ -69,9 +69,9 @@ operator<<(basic_ostream<charT, traits>& out, thread::id id);
|
||||
namespace this_thread
|
||||
{
|
||||
|
||||
thread::id get_id() noexcept;
|
||||
thread::id get_id();
|
||||
|
||||
void yield() noexcept;
|
||||
void yield();
|
||||
|
||||
template <class Clock, class Duration>
|
||||
void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
|
||||
@@ -100,9 +100,7 @@ void sleep_for(const chrono::duration<Rep, Period>& rel_time);
|
||||
#endif
|
||||
#include <pthread.h>
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
||||
#pragma GCC system_header
|
||||
#endif
|
||||
|
||||
#define __STDCPP_THREADS__ __cplusplus
|
||||
|
||||
@@ -137,55 +135,52 @@ template <class _Tp>
|
||||
void
|
||||
__thread_specific_ptr<_Tp>::__at_thread_exit(void* __p)
|
||||
{
|
||||
delete static_cast<pointer>(__p);
|
||||
delete static_cast<pointer>(__p);
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
__thread_specific_ptr<_Tp>::__thread_specific_ptr()
|
||||
{
|
||||
int __ec = pthread_key_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
|
||||
if (__ec)
|
||||
throw system_error(error_code(__ec, system_category()),
|
||||
"__thread_specific_ptr construction failed");
|
||||
if (__ec)
|
||||
throw system_error(error_code(__ec, system_category()),
|
||||
"__thread_specific_ptr construction failed");
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
__thread_specific_ptr<_Tp>::~__thread_specific_ptr()
|
||||
{
|
||||
pthread_key_delete(__key_);
|
||||
pthread_key_delete(__key_);
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
typename __thread_specific_ptr<_Tp>::pointer
|
||||
__thread_specific_ptr<_Tp>::release()
|
||||
{
|
||||
pointer __p = get();
|
||||
pthread_setspecific(__key_, 0);
|
||||
return __p;
|
||||
pointer __p = get();
|
||||
pthread_setspecific(__key_, 0);
|
||||
return __p;
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
void
|
||||
__thread_specific_ptr<_Tp>::reset(pointer __p)
|
||||
{
|
||||
pointer __p_old = get();
|
||||
pthread_setspecific(__key_, __p);
|
||||
delete __p_old;
|
||||
pointer __p_old = get();
|
||||
pthread_setspecific(__key_, __p);
|
||||
delete __p_old;
|
||||
}
|
||||
|
||||
class _LIBCPP_VISIBLE thread;
|
||||
class _LIBCPP_VISIBLE __thread_id;
|
||||
class thread;
|
||||
class __thread_id;
|
||||
|
||||
namespace this_thread
|
||||
{
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
|
||||
__thread_id get_id();
|
||||
|
||||
} // this_thread
|
||||
|
||||
class _LIBCPP_VISIBLE __thread_id;
|
||||
template<> struct _LIBCPP_VISIBLE hash<__thread_id>;
|
||||
|
||||
class _LIBCPP_VISIBLE __thread_id
|
||||
{
|
||||
// FIXME: pthread_t is a pointer on Darwin but a long on Linux.
|
||||
@@ -195,25 +190,25 @@ class _LIBCPP_VISIBLE __thread_id
|
||||
|
||||
public:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__thread_id() _NOEXCEPT : __id_(0) {}
|
||||
__thread_id() : __id_(0) {}
|
||||
|
||||
friend _LIBCPP_INLINE_VISIBILITY
|
||||
bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT
|
||||
bool operator==(__thread_id __x, __thread_id __y)
|
||||
{return __x.__id_ == __y.__id_;}
|
||||
friend _LIBCPP_INLINE_VISIBILITY
|
||||
bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT
|
||||
bool operator!=(__thread_id __x, __thread_id __y)
|
||||
{return !(__x == __y);}
|
||||
friend _LIBCPP_INLINE_VISIBILITY
|
||||
bool operator< (__thread_id __x, __thread_id __y) _NOEXCEPT
|
||||
bool operator< (__thread_id __x, __thread_id __y)
|
||||
{return __x.__id_ < __y.__id_;}
|
||||
friend _LIBCPP_INLINE_VISIBILITY
|
||||
bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT
|
||||
bool operator<=(__thread_id __x, __thread_id __y)
|
||||
{return !(__y < __x);}
|
||||
friend _LIBCPP_INLINE_VISIBILITY
|
||||
bool operator> (__thread_id __x, __thread_id __y) _NOEXCEPT
|
||||
bool operator> (__thread_id __x, __thread_id __y)
|
||||
{return __y < __x ;}
|
||||
friend _LIBCPP_INLINE_VISIBILITY
|
||||
bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT
|
||||
bool operator>=(__thread_id __x, __thread_id __y)
|
||||
{return !(__x < __y);}
|
||||
|
||||
template<class _CharT, class _Traits>
|
||||
@@ -227,11 +222,12 @@ private:
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__thread_id(pthread_t __id) : __id_(__id) {}
|
||||
|
||||
friend __thread_id this_thread::get_id() _NOEXCEPT;
|
||||
friend __thread_id this_thread::get_id();
|
||||
friend class _LIBCPP_VISIBLE thread;
|
||||
friend struct _LIBCPP_VISIBLE hash<__thread_id>;
|
||||
};
|
||||
|
||||
template<class _Tp> struct hash;
|
||||
|
||||
template<>
|
||||
struct _LIBCPP_VISIBLE hash<__thread_id>
|
||||
: public unary_function<__thread_id, size_t>
|
||||
@@ -239,7 +235,8 @@ struct _LIBCPP_VISIBLE hash<__thread_id>
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
size_t operator()(__thread_id __v) const
|
||||
{
|
||||
return hash<pthread_t>()(__v.__id_);
|
||||
const size_t* const __p = reinterpret_cast<const size_t*>(&__v);
|
||||
return *__p;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -248,7 +245,7 @@ namespace this_thread
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
__thread_id
|
||||
get_id() _NOEXCEPT
|
||||
get_id()
|
||||
{
|
||||
return pthread_self();
|
||||
}
|
||||
@@ -266,39 +263,39 @@ public:
|
||||
typedef pthread_t native_handle_type;
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
thread() _NOEXCEPT : __t_(0) {}
|
||||
thread() : __t_(0) {}
|
||||
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
||||
template <class _Fp, class ..._Args,
|
||||
template <class _F, class ..._Args,
|
||||
class = typename enable_if
|
||||
<
|
||||
!is_same<typename decay<_Fp>::type, thread>::value
|
||||
!is_same<typename decay<_F>::type, thread>::value
|
||||
>::type
|
||||
>
|
||||
explicit thread(_Fp&& __f, _Args&&... __args);
|
||||
explicit thread(_F&& __f, _Args&&... __args);
|
||||
#else // _LIBCPP_HAS_NO_VARIADICS
|
||||
template <class _Fp> explicit thread(_Fp __f);
|
||||
template <class _F> explicit thread(_F __f);
|
||||
#endif
|
||||
~thread();
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {__t.__t_ = 0;}
|
||||
thread& operator=(thread&& __t) _NOEXCEPT;
|
||||
thread(thread&& __t) : __t_(__t.__t_) {__t.__t_ = 0;}
|
||||
thread& operator=(thread&& __t);
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);}
|
||||
void swap(thread& __t) {_VSTD::swap(__t_, __t.__t_);}
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
bool joinable() const _NOEXCEPT {return __t_ != 0;}
|
||||
bool joinable() const {return __t_ != 0;}
|
||||
void join();
|
||||
void detach();
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
id get_id() const _NOEXCEPT {return __t_;}
|
||||
id get_id() const {return __t_;}
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
native_handle_type native_handle() _NOEXCEPT {return __t_;}
|
||||
native_handle_type native_handle() {return __t_;}
|
||||
|
||||
static unsigned hardware_concurrency() _NOEXCEPT;
|
||||
static unsigned hardware_concurrency();
|
||||
};
|
||||
|
||||
class __assoc_sub_state;
|
||||
@@ -323,34 +320,34 @@ __thread_specific_ptr<__thread_struct>& __thread_local_data();
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class _Fp, class ..._Args, size_t ..._Indices>
|
||||
template <class _F, class ..._Args, size_t ..._Indices>
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
void
|
||||
__threaad_execute(tuple<_Fp, _Args...>& __t, __tuple_indices<_Indices...>)
|
||||
__threaad_execute(tuple<_F, _Args...>& __t, __tuple_indices<_Indices...>)
|
||||
{
|
||||
__invoke(_VSTD::move(_VSTD::get<0>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...);
|
||||
}
|
||||
|
||||
template <class _Fp>
|
||||
template <class _F>
|
||||
void*
|
||||
__thread_proxy(void* __vp)
|
||||
{
|
||||
__thread_local_data().reset(new __thread_struct);
|
||||
std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
|
||||
typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
|
||||
std::unique_ptr<_F> __p(static_cast<_F*>(__vp));
|
||||
typedef typename __make_tuple_indices<tuple_size<_F>::value, 1>::type _Index;
|
||||
__threaad_execute(*__p, _Index());
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
template <class _Fp, class ..._Args,
|
||||
template <class _F, class ..._Args,
|
||||
class
|
||||
>
|
||||
thread::thread(_Fp&& __f, _Args&&... __args)
|
||||
thread::thread(_F&& __f, _Args&&... __args)
|
||||
{
|
||||
typedef tuple<typename decay<_Fp>::type, typename decay<_Args>::type...> _Gp;
|
||||
_VSTD::unique_ptr<_Gp> __p(new _Gp(__decay_copy(_VSTD::forward<_Fp>(__f)),
|
||||
typedef tuple<typename decay<_F>::type, typename decay<_Args>::type...> _G;
|
||||
_VSTD::unique_ptr<_G> __p(new _G(__decay_copy(_VSTD::forward<_F>(__f)),
|
||||
__decay_copy(_VSTD::forward<_Args>(__args))...));
|
||||
int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Gp>, __p.get());
|
||||
int __ec = pthread_create(&__t_, 0, &__thread_proxy<_G>, __p.get());
|
||||
if (__ec == 0)
|
||||
__p.release();
|
||||
else
|
||||
@@ -359,21 +356,21 @@ thread::thread(_Fp&& __f, _Args&&... __args)
|
||||
|
||||
#else // _LIBCPP_HAS_NO_VARIADICS
|
||||
|
||||
template <class _Fp>
|
||||
template <class _F>
|
||||
void*
|
||||
__thread_proxy(void* __vp)
|
||||
{
|
||||
__thread_local_data().reset(new __thread_struct);
|
||||
std::unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
|
||||
std::unique_ptr<_F> __p(static_cast<_F*>(__vp));
|
||||
(*__p)();
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
template <class _Fp>
|
||||
thread::thread(_Fp __f)
|
||||
template <class _F>
|
||||
thread::thread(_F __f)
|
||||
{
|
||||
std::unique_ptr<_Fp> __p(new _Fp(__f));
|
||||
int __ec = pthread_create(&__t_, 0, &__thread_proxy<_Fp>, __p.get());
|
||||
std::unique_ptr<_F> __p(new _F(__f));
|
||||
int __ec = pthread_create(&__t_, 0, &__thread_proxy<_F>, __p.get());
|
||||
if (__ec == 0)
|
||||
__p.release();
|
||||
else
|
||||
@@ -386,7 +383,7 @@ thread::thread(_Fp __f)
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
thread&
|
||||
thread::operator=(thread&& __t) _NOEXCEPT
|
||||
thread::operator=(thread&& __t)
|
||||
{
|
||||
if (__t_ != 0)
|
||||
terminate();
|
||||
@@ -398,7 +395,7 @@ thread::operator=(thread&& __t) _NOEXCEPT
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
void swap(thread& __x, thread& __y) _NOEXCEPT {__x.swap(__y);}
|
||||
void swap(thread& __x, thread& __y) {__x.swap(__y);}
|
||||
|
||||
namespace this_thread
|
||||
{
|
||||
@@ -410,20 +407,10 @@ void
|
||||
sleep_for(const chrono::duration<_Rep, _Period>& __d)
|
||||
{
|
||||
using namespace chrono;
|
||||
if (__d > duration<_Rep, _Period>::zero())
|
||||
{
|
||||
_LIBCPP_CONSTEXPR duration<long double> _Max = nanoseconds::max();
|
||||
nanoseconds __ns;
|
||||
if (__d < _Max)
|
||||
{
|
||||
__ns = duration_cast<nanoseconds>(__d);
|
||||
if (__ns < __d)
|
||||
++__ns;
|
||||
}
|
||||
else
|
||||
__ns = nanoseconds::max();
|
||||
sleep_for(__ns);
|
||||
}
|
||||
nanoseconds __ns = duration_cast<nanoseconds>(__d);
|
||||
if (__ns < __d)
|
||||
++__ns;
|
||||
sleep_for(__ns);
|
||||
}
|
||||
|
||||
template <class _Clock, class _Duration>
|
||||
@@ -448,7 +435,7 @@ sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
|
||||
}
|
||||
|
||||
inline _LIBCPP_INLINE_VISIBILITY
|
||||
void yield() _NOEXCEPT {sched_yield();}
|
||||
void yield() {sched_yield();}
|
||||
|
||||
} // this_thread
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user