Compare commits

...

112 Commits

Author SHA1 Message Date
Bill Wendling
699f9ca983 Creating release_30 branch
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/branches/release_30@142042 91177308-0d34-0410-b5e6-96231b3b80d8
2011-10-15 01:58:33 +00:00
Howard Hinnant
2baccd81f1 Fix http://llvm.org/bugs/show_bug.cgi?id=11113
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@141714 91177308-0d34-0410-b5e6-96231b3b80d8
2011-10-11 21:28:38 +00:00
Howard Hinnant
11624459ef Starting on musl port by Arvid Picciani
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@141672 91177308-0d34-0410-b5e6-96231b3b80d8
2011-10-11 16:00:46 +00:00
Howard Hinnant
bc90e2a47d Remove -Wglobal-constructors from flags. This was an accidental addition.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@141551 91177308-0d34-0410-b5e6-96231b3b80d8
2011-10-10 17:36:59 +00:00
Howard Hinnant
907732644c Update instructions for building on Mac OS 10.6
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@141507 91177308-0d34-0410-b5e6-96231b3b80d8
2011-10-09 15:25:34 +00:00
Howard Hinnant
b97de44471 Fix <rdar://problem/10256836> getline of an empty string mistakenly causes failure
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@141506 91177308-0d34-0410-b5e6-96231b3b80d8
2011-10-09 15:20:46 +00:00
Howard Hinnant
c6fe8cafc3 Fix <rdar://problem/10255403> match_results::begin() is off by one
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@141494 91177308-0d34-0410-b5e6-96231b3b80d8
2011-10-08 14:36:16 +00:00
Howard Hinnant
fdcbd1db25 reverting change to compatibility_version
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@141445 91177308-0d34-0410-b5e6-96231b3b80d8
2011-10-07 23:55:11 +00:00
Howard Hinnant
e0a0e51248 Change compatibility_version
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@141391 91177308-0d34-0410-b5e6-96231b3b80d8
2011-10-07 19:52:29 +00:00
Howard Hinnant
9677458967 Fix <rdar://problem/10136825>
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@141132 91177308-0d34-0410-b5e6-96231b3b80d8
2011-10-04 23:11:56 +00:00
Howard Hinnant
15e48f9239 Fix <rdar://problem/10226704>
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@141054 91177308-0d34-0410-b5e6-96231b3b80d8
2011-10-04 01:25:20 +00:00
Howard Hinnant
c0d0cbad9e Windows porting work by Ruben Van Boxem
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@141003 91177308-0d34-0410-b5e6-96231b3b80d8
2011-10-03 15:23:59 +00:00
Howard Hinnant
8452d21f41 Updated testit to run on Windows and fresh Windows results by Ruben Van Boxem
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140950 91177308-0d34-0410-b5e6-96231b3b80d8
2011-10-01 15:34:27 +00:00
Howard Hinnant
f8800b12c5 Fix <rdar://problem/10217868>.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140907 91177308-0d34-0410-b5e6-96231b3b80d8
2011-10-01 00:26:36 +00:00
Howard Hinnant
2481cba8b7 Provide link to developer's policy
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140857 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-30 16:58:02 +00:00
Howard Hinnant
14fa9f9d8f Windows port work by Ruben Van Boxem
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140805 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-29 20:33:10 +00:00
Howard Hinnant
3c466fc631 Windows patch work by Ruben Van Boxem
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140781 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-29 13:33:15 +00:00
Howard Hinnant
866569b8c3 Attempted locale refactoring. _LIBCPP_LOCALE__L_EXTENSIONS now should be defined if one has all of the xxx_l() functions. I've defined this for apple, freebsd and win32. _LIBCPP_HAS_DEFAULTRUNELOCALE should be defined if there is a _DefaultRuneLocale. I've defined this for apple and freebsd. The block of code we're trying to migrate away from is now under #ifdef __linux__. I've tested only on OS X. I hope I haven't broken things too badly elsewhere. Please let me know.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140734 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-28 23:39:33 +00:00
Howard Hinnant
efbe4067f2 Work on Windows port by Ruben Van Boxem
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140728 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-28 21:39:20 +00:00
Howard Hinnant
2ea1ca9bdd Attempt to enable locale simplification. On which platforms can we now #define _LIBCPP_STABLE_APPLE_ABI?
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140724 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-28 21:05:01 +00:00
Howard Hinnant
0cbb3a16e2 Ruben's Windows test results.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140700 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-28 15:44:39 +00:00
Howard Hinnant
1c3ec6d480 Another installment on debug mode. This addresses list. However this should be considered a temporary state. The API of the debug database and how vector and list use it, is unsatisfactory at the moment. It is both inefficient and overly verbose. I wanted to get this functionality checked in though. In the next day or so I'll refactor what is there in an attempt to streamline things.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140660 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-27 23:55:03 +00:00
Howard Hinnant
6cd05eeb35 Work on Windows port by Ruben Van Boxem
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140384 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-23 16:11:27 +00:00
Howard Hinnant
92a07003b2 Partial Windows port by Ruben Van Boxem
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140328 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-22 19:10:18 +00:00
Howard Hinnant
59832523ac Fix test bugs found by David Chisnall
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140271 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-21 18:33:46 +00:00
David Chisnall
9e02b90405 Fix locales used in re tests.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140265 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-21 17:38:03 +00:00
David Chisnall
2fb1a9d1e8 Remove undefines in cstdio test. Fix these properly rather than bodging the tests.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140264 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-21 17:37:18 +00:00
David Chisnall
86698890db More +.UTF-8 fixes.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140262 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-21 17:35:42 +00:00
Howard Hinnant
709c3d27f5 Fix failure found by David Chisnall
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140255 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-21 16:42:32 +00:00
Howard Hinnant
336f41ae0c Correct change to exception.cpp from r140245
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140253 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-21 15:12:26 +00:00
David Chisnall
db2e99f852 More fixes to the tests. Add UTF-8 encoding to all locales that don't specify one. Undefine some stdio.h macros that break the tests.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140252 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-21 14:59:10 +00:00
David Chisnall
a824f53600 Fully-qualify some more locales in the tests...
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140251 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-21 14:48:49 +00:00
David Chisnall
eb2c855c44 Don't check STREAMS error numbers on systems that don't implement the obsolete (as described in POSIX2008) XSI STREAMS extension.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140248 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-21 12:23:11 +00:00
David Chisnall
6b8ac3acda More locale cleanups. Fully specify locales in iostream tests.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140247 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-21 12:09:17 +00:00
David Chisnall
c512df1950 Fixes for FreeBSD, including some fairly obvious copy-and-paste errors.
libc++ now mostly works on FreeBSD with libcxxrt and this patch applied to the base system:

http://lists.freebsd.org/pipermail/freebsd-hackers/attachments/20110920/e666632c/xlocale-0001.obj

Summary of tests on FreeBSD:


****************************************************
Results for /root/libcxx/test:
using FreeBSD clang version 3.0 (trunk 135360) 20110717
Target: x86_64-unknown-freebsd9.0
Thread model: posix
with -std=c++0x -stdlib=libc++ -I/root/libcxx/include -L/root/libcxx/build/lib
----------------------------------------------------
sections without tests   : 1
sections with failures   : 48
sections without failures: 1015
                       +   ----
total number of sections : 1064
----------------------------------------------------
number of tests failed   : 145
number of tests passed   : 4179
                       +   ----
total number of tests    : 4324
****************************************************

(Many due to this clang version not supporting C++ atomics)

More fixes to follow...



git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140245 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-21 08:39:44 +00:00
David Chisnall
e2f2a15066 Localisation test fixes to make the tests pass on FreeBSD, which does not provide shortened forms of the various locales (e.g. en_US, rather than en_US.UTF-8 / en_US.ISO{whatever}).
Reviewed by Howard Hinnant.



git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140242 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-21 08:19:20 +00:00
Howard Hinnant
e6125bdeae Chris Jefferson noted that vector iterator ownership can be transferred from source to target under move construction and move assignment. This commit makes that happen for debug mode.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140023 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-19 16:34:29 +00:00
Howard Hinnant
be969d7c7d Removed unneeded boost implementation of is_base_of
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140014 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-19 13:19:31 +00:00
David Chisnall
68ebc448f0 Enable __locale to work on FreeBSD.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@140005 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-18 19:23:04 +00:00
Howard Hinnant
7608b4aac2 Doug Gregor pointed out some problems with debug mode enabled in one TU and not another. This patch helps detect those situations and offers improved error messages to help get debug mode enabled in more TU's when it is absolutely necessary to do so. Thanks Doug.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@139933 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-16 19:52:23 +00:00
Howard Hinnant
0442b12591 The vector test suite now passes for no-debug, debug-lite and debug-regular
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@139930 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-16 18:41:29 +00:00
Howard Hinnant
abe2628b43 Create multilevel debug mode
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@139913 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-16 17:29:17 +00:00
Howard Hinnant
7a563db09a Initial checkin for debug mode (version 2)
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@139711 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-14 18:33:51 +00:00
Howard Hinnant
8b3fae3cc7 Address PR10909: http://llvm.org/bugs/show_bug.cgi?id=10909
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@139493 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-12 14:15:45 +00:00
Howard Hinnant
9cbee430da Fix const correctness bug in __move_assign. Found and fixed by Ion Gaztañaga.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@139032 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-02 20:42:31 +00:00
Howard Hinnant
6b171c557b Up version number by 1. This is a 'minor version' update.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@138978 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-01 23:13:01 +00:00
Howard Hinnant
92a836c03d Reimplemented much of <istream> such that single character extractions do not check to see if this is the last character in the stream and thus never set eofbit. This fixes http://llvm.org/bugs/show_bug.cgi?id=10817 . This fix requires a recompiled libc++.dylib to be fully implemented. The recompiled libc++.dylib is ABI compatible with that shipped on Lion.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@138961 91177308-0d34-0410-b5e6-96231b3b80d8
2011-09-01 21:02:45 +00:00
Howard Hinnant
5f255944ac __split_buffer should only require default constructible. Bug found and fixed by Jared Hoberock
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@138726 91177308-0d34-0410-b5e6-96231b3b80d8
2011-08-28 15:21:29 +00:00
Dave Zarzycki
2b56659c60 Merge the Apple branch into trunk
We will eventually rebranch for the next Apple release and when we do, we don't want to drop changes.


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@137940 91177308-0d34-0410-b5e6-96231b3b80d8
2011-08-18 15:53:00 +00:00
Howard Hinnant
3fdbbd2a6f Don't move assign string::allocator_type when propagate_on_container_move_assignment is false.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@137862 91177308-0d34-0410-b5e6-96231b3b80d8
2011-08-17 20:36:18 +00:00
Howard Hinnant
43edf2d1e1 Fix needle-in-haystack bug found by Walter Brown
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@137617 91177308-0d34-0410-b5e6-96231b3b80d8
2011-08-15 17:22:22 +00:00
Howard Hinnant
e3e3291f3a Fixed PR10574: http://llvm.org/bugs/show_bug.cgi?id=10574
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@137522 91177308-0d34-0410-b5e6-96231b3b80d8
2011-08-12 21:56:02 +00:00
Howard Hinnant
8caf423916 Correct misspelling:_LIBCPP_APPLE_STABLE_ABI -> _LIBCPP_STABLE_APPLE_ABI
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136597 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-31 17:16:32 +00:00
Howard Hinnant
8775816ba3 Change how _LIBCPP_HAS_NO_ADVANCED_SFINAE gets set.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136596 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-31 17:10:44 +00:00
Howard Hinnant
199d0aec1b Fixed PR10507 (http://llvm.org/bugs/show_bug.cgi?id=10507)
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136595 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-31 17:04:30 +00:00
Chandler Carruth
9d7530935d Revert r136547, r136545, and r136542 by removing slist.
This was checked in without review. It is not clear its reasonable to
include with libc++ at all, and needs discussion at a highlevel before
moving forward.

It's also completely lacking tests, and included several bugs in the
implementation.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136577 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-30 21:10:18 +00:00
Chandler Carruth
a73da5d2ca Revert r136546, which was submitted without review.
Original change:
Destruct elements of hash tables when removing individual entries from
the hash_table. I think this is the correct solution to PR10507, but I'm
not sure since this is a little bit cargo-culted. Howard, please review.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136576 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-30 21:10:16 +00:00
Sean Hunt
8f0396e443 Add the missing default argument for the allocator and use a cleaner
implementation of previous().

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136547 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-30 00:47:53 +00:00
Sean Hunt
b59b929cc9 Destruct elements of hash tables when removing individual entries from
the hash_table. I think this is the correct solution to PR10507, but I'm
not sure since this is a little bit cargo-culted. Howard, please review.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136546 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-30 00:18:12 +00:00
Sean Hunt
70bbcae9b5 Oops. That last commit was from an earlier revision of the file and was
more than just a bit broken. This one should compile and run without
infinite loops.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136545 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-30 00:06:52 +00:00
Sean Hunt
d50c1c7429 Include an "implementation" if SGI's slist. This was quickly hacked
together to get it working with code, and is neither optimal
(erase(Iterator, Iterator) calculates the previous iterator twice,
rather than calculating the previous iterator of the first one, then
advancing it until the second is found) nor complete (splice() was not
implemented). Most of the implementation is borrowed from forward_list
via using-declarations.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136542 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-29 23:42:36 +00:00
Sean Hunt
110b8bf57e Explicitly invoke the size_type specialization of max and min. This
avoids bugs where, when the allocator's size_type was smaller than int,
the multiplication or division would cause integral promotions and, with
two different integer types as arguments, deduction of the template
arguments would fail.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136540 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-29 23:31:58 +00:00
Sean Hunt
affd9e5d43 Add a new hash class in __gnu_ext for the extension containers. There
are two motivations for this.

First, this allows users who are specializing __gnu_ext::hash to
continue doing so without changing their code.

Second, SGI specifies hash overloads for char* and const char* that
perform a hash of the string, not of the pointer.

In order to support this, the hashing code for string is factored out.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136539 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-29 23:31:56 +00:00
Sean Hunt
e36a196049 Add two missing members from the extension hash containers. The first is
the type name 'data_type', which is specified by the SGI spec as being
the correct type name for the mapped type. The second is an overload of
insert found in standard containers, taking an iterator as a 'hint'
(which we ignore in the standard containers as well). libstdc++'s
implementation includes these overloads, and they are needed to make
insert_iterator work (which I suspect is the real motivation for
including them in the standard containers).

The motivation for including these overloads of insert and leaving the
mapped_type typedef is to make it easier for clients to migrate to the
standard containers.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136538 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-29 23:31:53 +00:00
Howard Hinnant
23369ee812 Configure to get along with 2.9 clang
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136526 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-29 21:35:53 +00:00
Howard Hinnant
db86663223 Optimizing valarray::operator=(some-valarray-expression)
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136291 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-27 23:19:59 +00:00
Howard Hinnant
9c59d38112 Fix PR10509: http://llvm.org/bugs/show_bug.cgi?id=10509
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136247 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-27 19:25:28 +00:00
Howard Hinnant
d36369d910 Fix PR10510: http://llvm.org/bugs/show_bug.cgi?id=10510
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@136232 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-27 18:34:06 +00:00
Howard Hinnant
4f598034d2 http://llvm.org/bugs/show_bug.cgi?id=10469
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135897 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-24 23:59:50 +00:00
Howard Hinnant
fa06d75e8d Optimization of string::operator< by M.E. O'Neill. Discussion in http://llvm.org/bugs/show_bug.cgi?id=10461
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135893 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-24 21:45:06 +00:00
Howard Hinnant
2644a7b3da http://llvm.org/bugs/show_bug.cgi?id=10461
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135873 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-24 15:07:21 +00:00
Howard Hinnant
099084d52f http://llvm.org/bugs/show_bug.cgi?id=10455
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135854 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-23 16:14:35 +00:00
Dave Zarzycki
b3296ae5bc Test commit
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135774 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-22 17:08:57 +00:00
Howard Hinnant
bf6666f7a0 Correct test.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135460 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-19 01:07:49 +00:00
Sean Hunt
541cb301a1 Adjust two tests to account for a nasty change in copying behavior
between C++03 and C++0x and its effect on exceptions, and another two to
not test move construction when rvalue references are not available.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135445 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-18 23:51:25 +00:00
Sean Hunt
13aaf422e4 Make all fstream tests use tmpnam if creating files, rather than
hard-coded names.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135444 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-18 23:51:21 +00:00
Sean Hunt
e6440c6fa2 Do a litmus test of using tmpnam to generate safe temporary file names
for the tests that open new data files.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135422 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-18 20:46:16 +00:00
Sean Hunt
737a351850 Given that __underlying_type is now available in clang, implement
std::underlying_type.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135410 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-18 18:37:21 +00:00
Sean Hunt
2d81f3d1f3 Give A an explicitly non-throwing destructor so that B's destructor is
itself non-throwing.  Since nested_exception's destructor is
non-throwing, if B's destructor is not, this causes an error in C++03
mode due to the overriding function having a more lax specification.
This did not occur in C++0x mode as A's destructor was implicitly
non-throwing.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135400 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-18 17:07:53 +00:00
Howard Hinnant
464aa5cad3 http://llvm.org/bugs/show_bug.cgi?id=10390
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135393 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-18 15:51:59 +00:00
Howard Hinnant
bcbbd4d14f Revert locale for apple back to original design, getting rid of now useless helper *_l functions
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135272 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-15 14:46:11 +00:00
Howard Hinnant
9a2078137f _LIBCXX_STABLE_APPLE_ABI -> _LIBCPP_STABLE_APPLE_ABI
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135271 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-15 14:25:40 +00:00
Sean Hunt
a78264f872 Fix wchar tests by not assuming that tm is complete and by using the
proper va_list time on non-darwin platforms.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135247 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-15 05:44:47 +00:00
Sean Hunt
f3907e6cc0 Reapply 135035 with proper conditional inclusion, hopefully solving
issues with it.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135246 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-15 05:40:33 +00:00
Howard Hinnant
912012e949 http://llvm.org/bugs/show_bug.cgi?id=10353
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135125 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-14 01:34:46 +00:00
Howard Hinnant
22ba71b8ef http://llvm.org/bugs/show_bug.cgi?id=10346
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135045 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-13 16:00:50 +00:00
Howard Hinnant
8d75632ad0 Reverted to 134947. Once I got into it, I discovered there were too many problems to fix in 135035.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135044 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-13 15:48:16 +00:00
Sean Hunt
c97da3a590 Implement the __nolocale functions properly so that they will work on
all platforms. Unfortunately a lot of this remains conditionally
compiled so as not to break Apple's ABI.

The new _LIBCPP_LOCALE__L_EXTENSIONS macro can be defined on other
platforms that support _l suffixes for all functions in order to use
them.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@135035 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-13 06:40:50 +00:00
Sean Hunt
0389c53f44 Make sure that __time_put constructors properly on non-Apple platforms.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134947 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-12 00:55:04 +00:00
Howard Hinnant
66f2641ac9 Toralf Niebuhr: This is just a tiny patch fixing some small (probably copy & paste) errors.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134843 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 19:47:01 +00:00
Howard Hinnant
2bf1c08510 Make vector<bool>::reference and const_reference public
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134815 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 15:50:42 +00:00
Sean Hunt
6f0342cf2e Don't assume that wctype produces a nice mask on all platforms. On
glibc, for instance, it's a const char *.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134787 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 03:40:04 +00:00
Sean Hunt
e59f724f79 Conditionally wrap the changes from r134781.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134783 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 01:09:31 +00:00
Sean Hunt
62a6ac33a2 Implement generalized table lookups for upper, lower, and character
traits.

To the best of my knowledge, this will not break the ABI for Apple.
However, it does introduce three publicly visible (although with
reserved name) functions that will fail to link against the just-shipped
Apple version of libc++. Since they are not used in any inline
functions, no actual breakage should occur.

If Howard doesn't want to put undefined functions (even internal ones)
into a header, they could be surrounded by additional conditional
compilation.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134781 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 00:56:23 +00:00
Howard Hinnant
043fe1d931 provide ~future_error() definition
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134663 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-08 00:04:40 +00:00
Sean Hunt
cb05a0801a Fix typo
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134650 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-07 22:45:07 +00:00
Howard Hinnant
ac6de546bd Fixing up some ABI issues
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134639 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-07 21:03:52 +00:00
Sean Hunt
12c3d374a5 <inttypes.h> does not necessarily include <stdint.h>. Accordingly, do
not test for this.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134531 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-06 20:52:28 +00:00
Howard Hinnant
9f66bffdbe Fix uninitialized loop counter. http://llvm.org/bugs/show_bug.cgi?id=10278
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134405 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-05 14:14:17 +00:00
Howard Hinnant
3c8894b078 Make the default Makefile less destructive: John McCall
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134375 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-04 14:12:27 +00:00
Howard Hinnant
f03c3b4612 http://llvm.org/bugs/show_bug.cgi?id=10248
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134327 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-02 20:33:23 +00:00
Howard Hinnant
90d7785eba http://llvm.org/bugs/show_bug.cgi?id=10250
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134325 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-02 18:22:36 +00:00
Howard Hinnant
74248888ab Changed constraints on pair and tuple constructors from is_convertible to is_constructible.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134252 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-01 20:12:51 +00:00
Howard Hinnant
61aa6013c3 Correct for new rules regarding implicitly deleted special members. http://llvm.org/bugs/show_bug.cgi?id=10191
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134248 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-01 19:24:36 +00:00
Howard Hinnant
0949eedbd6 _STD -> _VSTD to avoid macro clash on windows
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134190 91177308-0d34-0410-b5e6-96231b3b80d8
2011-06-30 21:18:19 +00:00
Howard Hinnant
d318d49e5c Patch by Petteri Räty, http://llvm.org/bugs/show_bug.cgi?id=8992
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@134155 91177308-0d34-0410-b5e6-96231b3b80d8
2011-06-30 14:21:55 +00:00
Howard Hinnant
a2a08b43ee test for pair piecewise construction
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@133667 91177308-0d34-0410-b5e6-96231b3b80d8
2011-06-22 23:51:19 +00:00
Douglas Gregor
35d2fcfc8e Teach libc++ about the addressof() overloads it needs to work with
Objective-C Automatic Reference Counting, where Objective-C object
pointers can have several different qualifiers (__strong, __weak,
__autoreleasing, __unsafe_unretained). These addressof() overloads are
only provided in ARC mode, and the __weak variant is conditionalized
on having weak-reference support in the ARC runtime.

For historical reasons, Clang provides these definitions itself, and
defines the macro _LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF to note when
it as done so. The code belongs here, and this redundancy will be
eliminated in the future.

Addresses <rdar://problem/9658274>.


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@133656 91177308-0d34-0410-b5e6-96231b3b80d8
2011-06-22 22:17:44 +00:00
Howard Hinnant
f5d76a7afc Add instructions for -U__STRICT_ANSI__ for Mac OS 10.6
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@133616 91177308-0d34-0410-b5e6-96231b3b80d8
2011-06-22 12:13:55 +00:00
Howard Hinnant
7604fea08c More fixes: One of my fixes to type_traits earlier today was incorrect, so that is reverted. Recently clang appears to have tightened up its definition of is_convertible and that has caused some failures in [unordered_][multi]map. I've switched to using is_constructible to restablish the desired functionality in [unordered_][multi]map. Specifically, inserting rvalues of move-only types for the keys.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@133402 91177308-0d34-0410-b5e6-96231b3b80d8
2011-06-19 21:45:00 +00:00
Howard Hinnant
d4b957820c Miscellaneous minor fixes in <type_traits>
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@133401 91177308-0d34-0410-b5e6-96231b3b80d8
2011-06-19 19:12:59 +00:00
Howard Hinnant
2b1b2d40d7 Provide names for template and function parameters in forward declarations. The purpose is to aid automated documentation tools.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@133008 91177308-0d34-0410-b5e6-96231b3b80d8
2011-06-14 19:58:17 +00:00
340 changed files with 8030 additions and 3960 deletions

View File

@@ -20,3 +20,15 @@ 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 port and libcxxrt support.
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.

View File

@@ -15,6 +15,9 @@ else
INSTALL_PREFIX="$(SDKROOT)"
endif
help::
echo Use make install DSTROOT=<destination>
installsrc:: $(SRCROOT)
ditto $(SRCDIRS)/include $(SRCROOT)/include
@@ -26,13 +29,34 @@ clean::
installhdrs::
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/*
mkdir -p $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/c++/v1/ext
mkdir -p $(DSTROOT)/$(INSTALL_PREFIX)/usr/clang-ide/lib/c++/v1/ext
mkdir -p $(DSTROOT)/$(INSTALL_PREFIX)/Developer/usr/lib/c++/v1/ext
mkdir -p $(DSTROOT)/$(INSTALL_PREFIX)/Developer/Platforms/iPhoneOS.platform/usr/lib/c++/v1/ext
rsync -r --exclude=".*" $(SRCDIRS)/include/* $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/c++/v1/
rsync -r --exclude=".*" $(SRCDIRS)/include/* $(DSTROOT)/$(INSTALL_PREFIX)/usr/clang-ide/lib/c++/v1/
rsync -r --exclude=".*" $(SRCDIRS)/include/* $(DSTROOT)/$(INSTALL_PREFIX)/Developer/usr/lib/c++/v1/
rsync -r --exclude=".*" $(SRCDIRS)/include/* $(DSTROOT)/$(INSTALL_PREFIX)/Developer/Platforms/iPhoneOS.platform/usr/lib/c++/v1/
chown -R root:wheel $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/c++
chown -R root:wheel $(DSTROOT)/$(INSTALL_PREFIX)/usr/clang-ide/lib/c++
chown -R root:wheel $(DSTROOT)/$(INSTALL_PREFIX)/Developer/usr/lib/c++
chown -R root:wheel $(DSTROOT)/$(INSTALL_PREFIX)/Developer/Platforms/iPhoneOS.platform/usr/lib/c++
chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/c++/v1
chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/usr/clang-ide/lib/c++/v1
chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/usr/lib/c++/v1
chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/Platforms/iPhoneOS.platform/usr/lib/c++/v1
chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/c++/v1/*
chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/usr/clang-ide/lib/c++/v1/*
chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/usr/lib/c++/v1/*
chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/Platforms/iPhoneOS.platform/usr/lib/c++/v1/*
chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/c++/v1/ext
chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/usr/clang-ide/lib/c++/v1/ext
chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/usr/lib/c++/v1/ext
chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/Platforms/iPhoneOS.platform/usr/lib/c++/v1/ext
chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/c++/v1/ext/*
chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/usr/clang-ide/lib/c++/v1/ext/*
chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/usr/lib/c++/v1/ext/*
chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/Platforms/iPhoneOS.platform/usr/lib/c++/v1/ext/*
install:: installhdrs $(DESTDIR)

View File

@@ -21,7 +21,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _C, bool _IsConst> class __bit_iterator;
template <class _C> class __bit_const_reference;
template <class _C>
template <class _Tp>
struct __has_storage_type
{
static const bool value = false;
};
template <class _C, bool = __has_storage_type<_C>::value>
class __bit_reference
{
typedef typename _C::__storage_type __storage_type;
@@ -66,6 +72,11 @@ private:
: __seg_(__s), __mask_(__m) {}
};
template <class _C>
class __bit_reference<_C, false>
{
};
template <class _C, class _D>
_LIBCPP_INLINE_VISIBILITY inline
void
@@ -142,25 +153,25 @@ __find_bool_true(__bit_iterator<_C, false> __first, typename _C::size_type __n)
if (__first.__ctz_ != 0)
{
__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
__storage_type __dn = _STD::min(__clz_f, __n);
__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;
if (__b)
return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(__b)));
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
__n -= __dn;
++__first.__seg_;
}
// do middle whole words
for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
if (*__first.__seg_)
return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(*__first.__seg_)));
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(*__first.__seg_)));
// do last partial word
if (__n > 0)
{
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
__storage_type __b = *__first.__seg_ & __m;
if (__b)
return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(__b)));
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
}
return _It(__first.__seg_, static_cast<unsigned>(__n));
}
@@ -176,11 +187,11 @@ __find_bool_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
if (__first.__ctz_ != 0)
{
__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
__storage_type __dn = _STD::min(__clz_f, __n);
__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);
if (__b)
return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(__b)));
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
__n -= __dn;
++__first.__seg_;
}
@@ -189,7 +200,7 @@ __find_bool_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
{
__storage_type __b = ~*__first.__seg_;
if (__b)
return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(__b)));
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
}
// do last partial word
if (__n > 0)
@@ -197,7 +208,7 @@ __find_bool_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
__storage_type __b = ~(*__first.__seg_ & __m);
if (__b)
return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(__b)));
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
}
return _It(__first.__seg_, static_cast<unsigned>(__n));
}
@@ -227,20 +238,20 @@ __count_bool_true(__bit_iterator<_C, false> __first, typename _C::size_type __n)
if (__first.__ctz_ != 0)
{
__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
__storage_type __dn = _STD::min(__clz_f, __n);
__storage_type __dn = _VSTD::min(__clz_f, __n);
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
__r = _STD::__pop_count(*__first.__seg_ & __m);
__r = _VSTD::__pop_count(*__first.__seg_ & __m);
__n -= __dn;
++__first.__seg_;
}
// do middle whole words
for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
__r += _STD::__pop_count(*__first.__seg_);
__r += _VSTD::__pop_count(*__first.__seg_);
// do last partial word
if (__n > 0)
{
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
__r += _STD::__pop_count(*__first.__seg_ & __m);
__r += _VSTD::__pop_count(*__first.__seg_ & __m);
}
return __r;
}
@@ -258,20 +269,20 @@ __count_bool_false(__bit_iterator<_C, false> __first, typename _C::size_type __n
if (__first.__ctz_ != 0)
{
__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
__storage_type __dn = _STD::min(__clz_f, __n);
__storage_type __dn = _VSTD::min(__clz_f, __n);
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
__r = _STD::__pop_count(~(*__first.__seg_ & __m));
__r = _VSTD::__pop_count(~(*__first.__seg_ & __m));
__n -= __dn;
++__first.__seg_;
}
// do middle whole words
for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
__r += _STD::__pop_count(~*__first.__seg_);
__r += _VSTD::__pop_count(~*__first.__seg_);
// do last partial word
if (__n > 0)
{
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
__r += _STD::__pop_count(~(*__first.__seg_ & __m));
__r += _VSTD::__pop_count(~(*__first.__seg_ & __m));
}
return __r;
}
@@ -299,7 +310,7 @@ __fill_n_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
if (__first.__ctz_ != 0)
{
__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
__storage_type __dn = _STD::min(__clz_f, __n);
__storage_type __dn = _VSTD::min(__clz_f, __n);
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
*__first.__seg_ &= ~__m;
__n -= __dn;
@@ -307,7 +318,7 @@ __fill_n_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
}
// do middle whole words
__storage_type __nw = __n / __bits_per_word;
_STD::memset(__first.__seg_, 0, __nw * sizeof(__storage_type));
_VSTD::memset(__first.__seg_, 0, __nw * sizeof(__storage_type));
__n -= __nw * __bits_per_word;
// do last partial word
if (__n > 0)
@@ -329,7 +340,7 @@ __fill_n_true(__bit_iterator<_C, false> __first, typename _C::size_type __n)
if (__first.__ctz_ != 0)
{
__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
__storage_type __dn = _STD::min(__clz_f, __n);
__storage_type __dn = _VSTD::min(__clz_f, __n);
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
*__first.__seg_ |= __m;
__n -= __dn;
@@ -337,7 +348,7 @@ __fill_n_true(__bit_iterator<_C, false> __first, typename _C::size_type __n)
}
// do middle whole words
__storage_type __nw = __n / __bits_per_word;
_STD::memset(__first.__seg_, -1, __nw * sizeof(__storage_type));
_VSTD::memset(__first.__seg_, -1, __nw * sizeof(__storage_type));
__n -= __nw * __bits_per_word;
// do last partial word
if (__n > 0)
@@ -369,7 +380,7 @@ inline _LIBCPP_INLINE_VISIBILITY
void
fill(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __last, bool __value)
{
_STD::fill_n(__first, static_cast<typename _C::size_type>(__last - __first), __value);
_VSTD::fill_n(__first, static_cast<typename _C::size_type>(__last - __first), __value);
}
// copy
@@ -390,7 +401,7 @@ __copy_aligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst
if (__first.__ctz_ != 0)
{
unsigned __clz = __bits_per_word - __first.__ctz_;
difference_type __dn = _STD::min(static_cast<difference_type>(__clz), __n);
difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n);
__n -= __dn;
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
__storage_type __b = *__first.__seg_ & __m;
@@ -404,7 +415,7 @@ __copy_aligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst
// __first.__ctz_ == 0;
// do middle words
__storage_type __nw = __n / __bits_per_word;
_STD::memmove(__result.__seg_, __first.__seg_, __nw * sizeof(__storage_type));
_VSTD::memmove(__result.__seg_, __first.__seg_, __nw * sizeof(__storage_type));
__n -= __nw * __bits_per_word;
__result.__seg_ += __nw;
// do last word
@@ -437,12 +448,12 @@ __copy_unaligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsCon
if (__first.__ctz_ != 0)
{
unsigned __clz_f = __bits_per_word - __first.__ctz_;
difference_type __dn = _STD::min(static_cast<difference_type>(__clz_f), __n);
difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
__n -= __dn;
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
__storage_type __b = *__first.__seg_ & __m;
unsigned __clz_r = __bits_per_word - __result.__ctz_;
__storage_type __ddn = _STD::min<__storage_type>(__dn, __clz_r);
__storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r);
__m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
*__result.__seg_ &= ~__m;
if (__result.__ctz_ > __first.__ctz_)
@@ -480,7 +491,7 @@ __copy_unaligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsCon
{
__m = ~__storage_type(0) >> (__bits_per_word - __n);
__storage_type __b = *__first.__seg_ & __m;
__storage_type __dn = _STD::min(__n, static_cast<difference_type>(__clz_r));
__storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__clz_r));
__m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
*__result.__seg_ &= ~__m;
*__result.__seg_ |= __b << __result.__ctz_;
@@ -526,7 +537,7 @@ __copy_backward_aligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C,
// do first word
if (__last.__ctz_ != 0)
{
difference_type __dn = _STD::min(static_cast<difference_type>(__last.__ctz_), __n);
difference_type __dn = _VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);
__n -= __dn;
unsigned __clz = __bits_per_word - __last.__ctz_;
__storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz);
@@ -543,7 +554,7 @@ __copy_backward_aligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C,
__storage_type __nw = __n / __bits_per_word;
__result.__seg_ -= __nw;
__last.__seg_ -= __nw;
_STD::memmove(__result.__seg_, __last.__seg_, __nw * sizeof(__storage_type));
_VSTD::memmove(__result.__seg_, __last.__seg_, __nw * sizeof(__storage_type));
__n -= __nw * __bits_per_word;
// do last word
if (__n > 0)
@@ -573,13 +584,13 @@ __copy_backward_unaligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_
// do first word
if (__last.__ctz_ != 0)
{
difference_type __dn = _STD::min(static_cast<difference_type>(__last.__ctz_), __n);
difference_type __dn = _VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);
__n -= __dn;
unsigned __clz_l = __bits_per_word - __last.__ctz_;
__storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_l);
__storage_type __b = *__last.__seg_ & __m;
unsigned __clz_r = __bits_per_word - __result.__ctz_;
__storage_type __ddn = _STD::min(__dn, static_cast<difference_type>(__result.__ctz_));
__storage_type __ddn = _VSTD::min(__dn, static_cast<difference_type>(__result.__ctz_));
if (__ddn > 0)
{
__m = (~__storage_type(0) << (__result.__ctz_ - __ddn)) & (~__storage_type(0) >> __clz_r);
@@ -623,7 +634,7 @@ __copy_backward_unaligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_
__m = ~__storage_type(0) << (__bits_per_word - __n);
__storage_type __b = *--__last.__seg_ & __m;
unsigned __clz_r = __bits_per_word - __result.__ctz_;
__storage_type __dn = _STD::min(__n, static_cast<difference_type>(__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;
*__result.__seg_ |= __b >> (__bits_per_word - __result.__ctz_);
@@ -661,7 +672,7 @@ inline _LIBCPP_INLINE_VISIBILITY
__bit_iterator<_C, false>
move(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last, __bit_iterator<_C, false> __result)
{
return _STD::copy(__first, __last, __result);
return _VSTD::copy(__first, __last, __result);
}
// move_backward
@@ -671,17 +682,17 @@ inline _LIBCPP_INLINE_VISIBILITY
__bit_iterator<_C, false>
move_backward(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last, __bit_iterator<_C, false> __result)
{
return _STD::copy(__first, __last, __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;
@@ -692,7 +703,7 @@ __swap_ranges_aligned(__bit_iterator<_C1, false> __first, __bit_iterator<_C1, fa
if (__first.__ctz_ != 0)
{
unsigned __clz = __bits_per_word - __first.__ctz_;
difference_type __dn = _STD::min(static_cast<difference_type>(__clz), __n);
difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n);
__n -= __dn;
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
__storage_type __b1 = *__first.__seg_ & __m;
@@ -726,12 +737,12 @@ __swap_ranges_aligned(__bit_iterator<_C1, false> __first, __bit_iterator<_C1, fa
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;
@@ -742,13 +753,13 @@ __swap_ranges_unaligned(__bit_iterator<_C1, false> __first, __bit_iterator<_C1,
if (__first.__ctz_ != 0)
{
unsigned __clz_f = __bits_per_word - __first.__ctz_;
difference_type __dn = _STD::min(static_cast<difference_type>(__clz_f), __n);
difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
__n -= __dn;
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
__storage_type __b1 = *__first.__seg_ & __m;
*__first.__seg_ &= ~__m;
unsigned __clz_r = __bits_per_word - __result.__ctz_;
__storage_type __ddn = _STD::min<__storage_type>(__dn, __clz_r);
__storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r);
__m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
__storage_type __b2 = *__result.__seg_ & __m;
*__result.__seg_ &= ~__m;
@@ -803,7 +814,7 @@ __swap_ranges_unaligned(__bit_iterator<_C1, false> __first, __bit_iterator<_C1,
__m = ~__storage_type(0) >> (__bits_per_word - __n);
__storage_type __b1 = *__first.__seg_ & __m;
*__first.__seg_ &= ~__m;
__storage_type __dn = _STD::min<__storage_type>(__n, __clz_r);
__storage_type __dn = _VSTD::min<__storage_type>(__n, __clz_r);
__m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
__storage_type __b2 = *__result.__seg_ & __m;
*__result.__seg_ &= ~__m;
@@ -826,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);
@@ -877,13 +888,13 @@ rotate(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __middle, __
if (__d1 <= __bit_array<_C>::capacity())
{
__bit_array<_C> __b(__d1);
_STD::copy(__first, __middle, __b.begin());
_STD::copy(__b.begin(), __b.end(), _STD::copy(__middle, __last, __first));
_VSTD::copy(__first, __middle, __b.begin());
_VSTD::copy(__b.begin(), __b.end(), _VSTD::copy(__middle, __last, __first));
break;
}
else
{
__bit_iterator<_C, false> __mp = _STD::swap_ranges(__first, __middle, __middle);
__bit_iterator<_C, false> __mp = _VSTD::swap_ranges(__first, __middle, __middle);
__first = __middle;
__middle = __mp;
__d2 -= __d1;
@@ -894,14 +905,14 @@ rotate(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __middle, __
if (__d2 <= __bit_array<_C>::capacity())
{
__bit_array<_C> __b(__d2);
_STD::copy(__middle, __last, __b.begin());
_STD::copy_backward(__b.begin(), __b.end(), _STD::copy_backward(__first, __middle, __last));
_VSTD::copy(__middle, __last, __b.begin());
_VSTD::copy_backward(__b.begin(), __b.end(), _VSTD::copy_backward(__first, __middle, __last));
break;
}
else
{
__bit_iterator<_C, false> __mp = __first + __d2;
_STD::swap_ranges(__first, __mp, __middle);
_VSTD::swap_ranges(__first, __mp, __middle);
__first = __mp;
__d1 -= __d2;
}
@@ -928,12 +939,12 @@ __equal_unaligned(__bit_iterator<_C, true> __first1, __bit_iterator<_C, true> __
if (__first1.__ctz_ != 0)
{
unsigned __clz_f = __bits_per_word - __first1.__ctz_;
difference_type __dn = _STD::min(static_cast<difference_type>(__clz_f), __n);
difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
__n -= __dn;
__storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
__storage_type __b = *__first1.__seg_ & __m;
unsigned __clz_r = __bits_per_word - __first2.__ctz_;
__storage_type __ddn = _STD::min<__storage_type>(__dn, __clz_r);
__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_)))
@@ -972,7 +983,7 @@ __equal_unaligned(__bit_iterator<_C, true> __first1, __bit_iterator<_C, true> __
{
__m = ~__storage_type(0) >> (__bits_per_word - __n);
__storage_type __b = *__first1.__seg_ & __m;
__storage_type __dn = _STD::min(__n, static_cast<difference_type>(__clz_r));
__storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__clz_r));
__m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_))
return false;
@@ -1006,7 +1017,7 @@ __equal_aligned(__bit_iterator<_C, true> __first1, __bit_iterator<_C, true> __la
if (__first1.__ctz_ != 0)
{
unsigned __clz = __bits_per_word - __first1.__ctz_;
difference_type __dn = _STD::min(static_cast<difference_type>(__clz), __n);
difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n);
__n -= __dn;
__storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))
@@ -1202,15 +1213,15 @@ private:
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 __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>);

View File

@@ -13,7 +13,7 @@
#pragma GCC system_header
#define _LIBCPP_VERSION 1000
#define _LIBCPP_VERSION 1001
#define _LIBCPP_ABI_VERSION 1
@@ -50,6 +50,10 @@
#ifdef _WIN32
# define _LIBCPP_LITTLE_ENDIAN 1
# define _LIBCPP_BIG_ENDIAN 0
// Compiler intrinsics (GCC or MSVC)
# if (defined(_MSC_VER) && _MSC_VER >= 1400) || (__GNUC__ >= 4 && __GNUC_MINOR__ > 3)
# define _LIBCP_HAS_IS_BASE_OF
# endif
#endif // _WIN32
#if !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
@@ -146,6 +150,9 @@ 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
@@ -157,10 +164,27 @@ 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
#endif
#if __has_feature(objc_arc_weak)
#define _LIBCPP_HAS_OBJC_ARC_WEAK
#endif
// Inline namespaces are available in Clang regardless of C++ dialect.
#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {inline namespace _LIBCPP_NAMESPACE {
#define _LIBCPP_END_NAMESPACE_STD } }
#define _STD std::_LIBCPP_NAMESPACE
#define _VSTD std::_LIBCPP_NAMESPACE
namespace std {
inline namespace _LIBCPP_NAMESPACE {
@@ -179,6 +203,10 @@ namespace std {
# define _NOEXCEPT_(x)
#endif
#if __has_feature(underlying_type)
# define _LIBCXX_UNDERLYING_TYPE(T) __underlying_type(T)
#endif
// end defined(__clang__)
#elif defined(__GNUC__)
@@ -228,6 +256,7 @@ namespace std {
#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__ >= 4 && __GNUC_MINOR__ >= 4)
#if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 6)
@@ -238,7 +267,7 @@ namespace std {
#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std { namespace _LIBCPP_NAMESPACE {
#define _LIBCPP_END_NAMESPACE_STD } }
#define _STD std::_LIBCPP_NAMESPACE
#define _VSTD std::_LIBCPP_NAMESPACE
namespace std {
namespace _LIBCPP_NAMESPACE {
@@ -276,4 +305,32 @@ template <unsigned> struct __static_assert_check {};
#define __has_feature(__x) 0
#endif
#if __APPLE__ || __FreeBSD__ || _WIN32
#define _LIBCPP_LOCALE__L_EXTENSIONS 1
#endif
#if __APPLE__ || __FreeBSD__
#define _LIBCPP_HAS_DEFAULTRUNELOCALE
#endif
#if __APPLE__ || __FreeBSD__
#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 Normal file
View File

@@ -0,0 +1,191 @@
// -*- 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* _C = static_cast<_Cont*>(__c_);
return _C->__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* _C = static_cast<_Cont*>(__c_);
return _C->__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* _C = static_cast<_Cont*>(__c_);
return _C->__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* _C = static_cast<_Cont*>(__c_);
return _C->__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

View File

@@ -314,8 +314,8 @@ class __func<_F, _Alloc, _R()>
{
__compressed_pair<_F, _Alloc> __f_;
public:
explicit __func(_F __f) : __f_(_STD::move(__f)) {}
explicit __func(_F __f, _Alloc __a) : __f_(_STD::move(__f), _STD::move(__a)) {}
explicit __func(_F __f) : __f_(_VSTD::move(__f)) {}
explicit __func(_F __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
virtual __base<_R()>* __clone() const;
virtual void __clone(__base<_R()>*) const;
virtual void destroy();
@@ -396,9 +396,9 @@ class __func<_F, _Alloc, _R(_A0)>
{
__compressed_pair<_F, _Alloc> __f_;
public:
_LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_STD::move(__f)) {}
_LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_VSTD::move(__f)) {}
_LIBCPP_INLINE_VISIBILITY explicit __func(_F __f, _Alloc __a)
: __f_(_STD::move(__f), _STD::move(__a)) {}
: __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
virtual __base<_R(_A0)>* __clone() const;
virtual void __clone(__base<_R(_A0)>*) const;
virtual void destroy();
@@ -479,9 +479,9 @@ class __func<_F, _Alloc, _R(_A0, _A1)>
{
__compressed_pair<_F, _Alloc> __f_;
public:
_LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_STD::move(__f)) {}
_LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_VSTD::move(__f)) {}
_LIBCPP_INLINE_VISIBILITY explicit __func(_F __f, _Alloc __a)
: __f_(_STD::move(__f), _STD::move(__a)) {}
: __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
virtual __base<_R(_A0, _A1)>* __clone() const;
virtual void __clone(__base<_R(_A0, _A1)>*) const;
virtual void destroy();
@@ -562,9 +562,9 @@ class __func<_F, _Alloc, _R(_A0, _A1, _A2)>
{
__compressed_pair<_F, _Alloc> __f_;
public:
_LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_STD::move(__f)) {}
_LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_VSTD::move(__f)) {}
_LIBCPP_INLINE_VISIBILITY explicit __func(_F __f, _Alloc __a)
: __f_(_STD::move(__f), _STD::move(__a)) {}
: __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
virtual __base<_R(_A0, _A1, _A2)>* __clone() const;
virtual void __clone(__base<_R(_A0, _A1, _A2)>*) const;
virtual void destroy();
@@ -831,7 +831,7 @@ typename enable_if
>::type
function<_R()>::operator=(_F __f)
{
function(_STD::move(__f)).swap(*this);
function(_VSTD::move(__f)).swap(*this);
return *this;
}
@@ -878,7 +878,7 @@ function<_R()>::swap(function& __f)
__f_ = (__base*)&__buf_;
}
else
_STD::swap(__f_, __f.__f_);
_VSTD::swap(__f_, __f.__f_);
}
template<class _R>
@@ -1133,7 +1133,7 @@ typename enable_if
>::type
function<_R(_A0)>::operator=(_F __f)
{
function(_STD::move(__f)).swap(*this);
function(_VSTD::move(__f)).swap(*this);
return *this;
}
@@ -1180,7 +1180,7 @@ function<_R(_A0)>::swap(function& __f)
__f_ = (__base*)&__buf_;
}
else
_STD::swap(__f_, __f.__f_);
_VSTD::swap(__f_, __f.__f_);
}
template<class _R, class _A0>
@@ -1435,7 +1435,7 @@ typename enable_if
>::type
function<_R(_A0, _A1)>::operator=(_F __f)
{
function(_STD::move(__f)).swap(*this);
function(_VSTD::move(__f)).swap(*this);
return *this;
}
@@ -1482,7 +1482,7 @@ function<_R(_A0, _A1)>::swap(function& __f)
__f_ = (__base*)&__buf_;
}
else
_STD::swap(__f_, __f.__f_);
_VSTD::swap(__f_, __f.__f_);
}
template<class _R, class _A0, class _A1>
@@ -1737,7 +1737,7 @@ typename enable_if
>::type
function<_R(_A0, _A1, _A2)>::operator=(_F __f)
{
function(_STD::move(__f)).swap(*this);
function(_VSTD::move(__f)).swap(*this);
return *this;
}
@@ -1784,7 +1784,7 @@ function<_R(_A0, _A1, _A2)>::swap(function& __f)
__f_ = (__base*)&__buf_;
}
else
_STD::swap(__f_, __f.__f_);
_VSTD::swap(__f_, __f.__f_);
}
template<class _R, class _A0, class _A1, class _A2>
@@ -1909,7 +1909,7 @@ inline _LIBCPP_INLINE_VISIBILITY
typename __mu_return1<true, _Ti, _Uj...>::type
__mu_expand(_Ti& __ti, tuple<_Uj...>&& __uj, __tuple_indices<_Indx...>)
{
__ti(_STD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj))...);
__ti(_VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj))...);
}
template <class _Ti, class ..._Uj>
@@ -1947,7 +1947,7 @@ __mu(_Ti&, _Uj& __uj)
// compiler bug workaround
typename tuple_element<_Indx, _Uj>::type __t = get<_Indx>(__uj);
return __t;
// return _STD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
// return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
}
template <class _Ti, class _Uj>
@@ -2051,8 +2051,8 @@ class __bind
public:
template <class _G, class ..._BA>
explicit __bind(_G&& __f, _BA&& ...__bound_args)
: __f_(_STD::forward<_G>(__f)),
__bound_args_(_STD::forward<_BA>(__bound_args)...) {}
: __f_(_VSTD::forward<_G>(__f)),
__bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
template <class ..._Args>
typename __bind_return<_F, tuple<_BoundArgs...>, tuple<_Args&&...> >::type
@@ -2085,21 +2085,21 @@ public:
template <class _G, class ..._BA>
explicit __bind_r(_G&& __f, _BA&& ...__bound_args)
: base(_STD::forward<_G>(__f),
_STD::forward<_BA>(__bound_args)...) {}
: base(_VSTD::forward<_G>(__f),
_VSTD::forward<_BA>(__bound_args)...) {}
template <class ..._Args>
result_type
operator()(_Args&& ...__args)
{
return base::operator()(_STD::forward<_Args>(__args)...);
return base::operator()(_VSTD::forward<_Args>(__args)...);
}
template <class ..._Args>
result_type
operator()(_Args&& ...__args) const
{
return base::operator()(_STD::forward<_Args>(__args)...);
return base::operator()(_VSTD::forward<_Args>(__args)...);
}
};
@@ -2112,7 +2112,7 @@ __bind<typename decay<_F>::type, typename decay<_BoundArgs>::type...>
bind(_F&& __f, _BoundArgs&&... __bound_args)
{
typedef __bind<typename decay<_F>::type, typename decay<_BoundArgs>::type...> type;
return type(_STD::forward<_F>(__f), _STD::forward<_BoundArgs>(__bound_args)...);
return type(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
}
template<class _R, class _F, class ..._BoundArgs>
@@ -2121,7 +2121,7 @@ __bind_r<_R, typename decay<_F>::type, typename decay<_BoundArgs>::type...>
bind(_F&& __f, _BoundArgs&&... __bound_args)
{
typedef __bind_r<_R, typename decay<_F>::type, typename decay<_BoundArgs>::type...> type;
return type(_STD::forward<_F>(__f), _STD::forward<_BoundArgs>(__bound_args)...);
return type(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
}
*/

View File

@@ -287,18 +287,18 @@ template <class _F, class _A0, class ..._Args>
inline _LIBCPP_INLINE_VISIBILITY
auto
__invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
-> decltype((_STD::forward<_A0>(__a0).*__f)(_STD::forward<_Args>(__args)...))
-> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...))
{
return (_STD::forward<_A0>(__a0).*__f)(_STD::forward<_Args>(__args)...);
return (_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...);
}
template <class _F, class _A0, class ..._Args>
inline _LIBCPP_INLINE_VISIBILITY
auto
__invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
-> decltype(((*_STD::forward<_A0>(__a0)).*__f)(_STD::forward<_Args>(__args)...))
-> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...))
{
return ((*_STD::forward<_A0>(__a0)).*__f)(_STD::forward<_Args>(__args)...);
return ((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...);
}
// bullets 3 and 4
@@ -307,18 +307,18 @@ template <class _F, class _A0>
inline _LIBCPP_INLINE_VISIBILITY
auto
__invoke(_F&& __f, _A0&& __a0)
-> decltype(_STD::forward<_A0>(__a0).*__f)
-> decltype(_VSTD::forward<_A0>(__a0).*__f)
{
return _STD::forward<_A0>(__a0).*__f;
return _VSTD::forward<_A0>(__a0).*__f;
}
template <class _F, class _A0>
inline _LIBCPP_INLINE_VISIBILITY
auto
__invoke(_F&& __f, _A0&& __a0)
-> decltype((*_STD::forward<_A0>(__a0)).*__f)
-> decltype((*_VSTD::forward<_A0>(__a0)).*__f)
{
return (*_STD::forward<_A0>(__a0)).*__f;
return (*_VSTD::forward<_A0>(__a0)).*__f;
}
// bullet 5
@@ -327,15 +327,15 @@ template <class _F, class ..._Args>
inline _LIBCPP_INLINE_VISIBILITY
auto
__invoke(_F&& __f, _Args&& ...__args)
-> decltype(_STD::forward<_F>(__f)(_STD::forward<_Args>(__args)...))
-> decltype(_VSTD::forward<_F>(__f)(_VSTD::forward<_Args>(__args)...))
{
return _STD::forward<_F>(__f)(_STD::forward<_Args>(__args)...);
return _VSTD::forward<_F>(__f)(_VSTD::forward<_Args>(__args)...);
}
template <class _Tp, class ..._Args>
struct __invoke_return
{
typedef decltype(__invoke(_STD::declval<_Tp>(), _STD::declval<_Args>()...)) type;
typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_Args>()...)) type;
};
template <class _Tp>
@@ -365,7 +365,7 @@ public:
typename __invoke_of<type&, _ArgTypes...>::type
operator() (_ArgTypes&&... __args) const
{
return __invoke(get(), _STD::forward<_ArgTypes>(__args)...);
return __invoke(get(), _VSTD::forward<_ArgTypes>(__args)...);
}
};

View File

@@ -842,7 +842,7 @@ struct __4th_helper
template <class _T1, class _R>
struct __4th_helper<_T1, _R, true>
{
typedef typename __apply_cv<decltype(*_STD::declval<_T1>()), _R>::type type;
typedef typename __apply_cv<decltype(*_VSTD::declval<_T1>()), _R>::type type;
};
template <class _R, class _T, class _T1>
@@ -959,13 +959,13 @@ struct __invoke_return
template <class _F>
struct __invoke_return<_F, false>
{
typedef decltype(__invoke(_STD::declval<_F>())) type;
typedef decltype(__invoke(_VSTD::declval<_F>())) type;
};
template <class _Tp, class _A0>
struct __invoke_return0
{
typedef decltype(__invoke(_STD::declval<_Tp>(), _STD::declval<_A0>())) type;
typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>())) type;
};
template <class _R, class _T, class _A0>
@@ -983,16 +983,16 @@ struct __invoke_return0<_R _T::*, _A0*>
template <class _Tp, class _A0, class _A1>
struct __invoke_return1
{
typedef decltype(__invoke(_STD::declval<_Tp>(), _STD::declval<_A0>(),
_STD::declval<_A1>())) type;
typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>(),
_VSTD::declval<_A1>())) type;
};
template <class _Tp, class _A0, class _A1, class _A2>
struct __invoke_return2
{
typedef decltype(__invoke(_STD::declval<_Tp>(), _STD::declval<_A0>(),
_STD::declval<_A1>(),
_STD::declval<_A2>())) type;
typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>(),
_VSTD::declval<_A1>(),
_VSTD::declval<_A2>())) type;
};
template <class _Tp>

View File

@@ -23,7 +23,7 @@
_LIBCPP_BEGIN_NAMESPACE_STD
_LIBCPP_VISIBLE
size_t __next_prime(size_t);
size_t __next_prime(size_t __n);
template <class _NodePtr>
struct __hash_node_base
@@ -54,11 +54,12 @@ struct __hash_node
value_type __value_;
};
template <class, class, class, class> class __hash_table;
template <class> class __hash_const_iterator;
template <class> class __hash_map_iterator;
template <class> class __hash_map_const_iterator;
template <class, class, class, class, class> class _LIBCPP_VISIBLE unordered_map;
template <class _Tp, class _Hash, class _Equal, class _Alloc> class __hash_table;
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;
template <class _NodePtr>
class _LIBCPP_VISIBLE __hash_iterator
@@ -85,7 +86,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
reference operator*() const {return __node_->__value_;}
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const {return _STD::addressof(__node_->__value_);}
pointer operator->() const {return _VSTD::addressof(__node_->__value_);}
_LIBCPP_INLINE_VISIBILITY
__hash_iterator& operator++()
@@ -163,7 +164,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
reference operator*() const {return __node_->__value_;}
_LIBCPP_INLINE_VISIBILITY
pointer operator->() const {return _STD::addressof(__node_->__value_);}
pointer operator->() const {return _VSTD::addressof(__node_->__value_);}
_LIBCPP_INLINE_VISIBILITY
__hash_const_iterator& operator++()
@@ -199,7 +200,7 @@ private:
template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_multimap;
};
template <class> class _LIBCPP_VISIBLE __hash_const_local_iterator;
template <class _ConstNodePtr> class _LIBCPP_VISIBLE __hash_const_local_iterator;
template <class _NodePtr>
class _LIBCPP_VISIBLE __hash_local_iterator
@@ -387,7 +388,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
__bucket_list_deallocator(__bucket_list_deallocator&& __x)
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
: __data_(_STD::move(__x.__data_))
: __data_(_VSTD::move(__x.__data_))
{
__x.size() = 0;
}
@@ -411,7 +412,7 @@ public:
}
};
template <class> class __hash_map_node_destructor;
template <class _Alloc> class __hash_map_node_destructor;
template <class _Alloc>
class __hash_node_destructor
@@ -431,16 +432,17 @@ public:
bool __value_constructed;
_LIBCPP_INLINE_VISIBILITY
explicit __hash_node_destructor(allocator_type& __na) _NOEXCEPT
explicit __hash_node_destructor(allocator_type& __na,
bool __constructed = false) _NOEXCEPT
: __na_(__na),
__value_constructed(false)
__value_constructed(__constructed)
{}
_LIBCPP_INLINE_VISIBILITY
void operator()(pointer __p) _NOEXCEPT
{
if (__value_constructed)
__alloc_traits::destroy(__na_, _STD::addressof(__p->__value_));
__alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_));
if (__p)
__alloc_traits::deallocate(__na_, __p, 1);
}
@@ -687,7 +689,7 @@ public:
return __bc != 0 ? (float)size() / __bc : 0.f;
}
_LIBCPP_INLINE_VISIBILITY void max_load_factor(float __mlf) _NOEXCEPT
{max_load_factor() = _STD::max(__mlf, load_factor());}
{max_load_factor() = _VSTD::max(__mlf, load_factor());}
_LIBCPP_INLINE_VISIBILITY local_iterator begin(size_type __n)
{return local_iterator(__bucket_list_[__n], __n, bucket_count());}
@@ -740,8 +742,8 @@ private:
is_nothrow_move_assignable<__node_allocator>::value)
{
__bucket_list_.get_deleter().__alloc() =
_STD::move(__u.__bucket_list_.get_deleter().__alloc());
__node_alloc() = _STD::move(__u.__node_alloc());
_VSTD::move(__u.__bucket_list_.get_deleter().__alloc());
__node_alloc() = _VSTD::move(__u.__node_alloc());
}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {}
@@ -768,7 +770,7 @@ private:
__swap_alloc(_A& __x, _A& __y, true_type)
_NOEXCEPT_(__is_nothrow_swappable<_A>::value)
{
using _STD::swap;
using _VSTD::swap;
swap(__x, __y);
}
@@ -858,15 +860,15 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u)
is_nothrow_move_constructible<__first_node>::value &&
is_nothrow_move_constructible<hasher>::value &&
is_nothrow_move_constructible<key_equal>::value)
: __bucket_list_(_STD::move(__u.__bucket_list_)),
__p1_(_STD::move(__u.__p1_)),
__p2_(_STD::move(__u.__p2_)),
__p3_(_STD::move(__u.__p3_))
: __bucket_list_(_VSTD::move(__u.__bucket_list_)),
__p1_(_VSTD::move(__u.__p1_)),
__p2_(_VSTD::move(__u.__p2_)),
__p3_(_VSTD::move(__u.__p3_))
{
if (size() > 0)
{
__bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
__u.__p1_.first().__next_ = nullptr;
__u.size() = 0;
}
@@ -877,8 +879,8 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,
const allocator_type& __a)
: __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
__p1_(__node_allocator(__a)),
__p2_(0, _STD::move(__u.hash_function())),
__p3_(_STD::move(__u.__p3_))
__p2_(0, _VSTD::move(__u.hash_function())),
__p3_(_VSTD::move(__u.__p3_))
{
if (__a == allocator_type(__u.__node_alloc()))
{
@@ -890,7 +892,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_[__p1_.first().__next_->__hash_ % bucket_count()] =
static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
size() = __u.size();
__u.size() = 0;
}
@@ -944,7 +946,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate(__node_pointer __np)
while (__np != nullptr)
{
__node_pointer __next = __np->__next_;
__node_traits::destroy(__na, _STD::addressof(__np->__value_));
__node_traits::destroy(__na, _VSTD::addressof(__np->__value_));
__node_traits::deallocate(__na, __np, 1);
__np = __next;
}
@@ -980,14 +982,14 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
__u.__bucket_list_.get_deleter().size() = 0;
__move_assign_alloc(__u);
size() = __u.size();
hash_function() = _STD::move(__u.hash_function());
hash_function() = _VSTD::move(__u.hash_function());
max_load_factor() = __u.max_load_factor();
key_eq() = _STD::move(__u.key_eq());
key_eq() = _VSTD::move(__u.key_eq());
__p1_.first().__next_ = __u.__p1_.first().__next_;
if (size() > 0)
{
__bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
__u.__p1_.first().__next_ = nullptr;
__u.size() = 0;
}
@@ -1002,8 +1004,8 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
__move_assign(__u, true_type());
else
{
hash_function() = _STD::move(__u.hash_function());
key_eq() = _STD::move(__u.key_eq());
hash_function() = _VSTD::move(__u.hash_function());
key_eq() = _VSTD::move(__u.key_eq());
max_load_factor() = __u.max_load_factor();
if (bucket_count() != 0)
{
@@ -1015,7 +1017,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
const_iterator __i = __u.begin();
while (__cache != nullptr && __u.size() != 0)
{
__cache->__value_ = _STD::move(__u.remove(__i++)->__value_);
__cache->__value_ = _VSTD::move(__u.remove(__i++)->__value_);
__node_pointer __next = __cache->__next_;
__node_insert_multi(__cache);
__cache = __next;
@@ -1034,7 +1036,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
while (__u.size() != 0)
{
__node_holder __h =
__construct_node(_STD::move(__u.remove(__i++)->__value_));
__construct_node(_VSTD::move(__u.remove(__i++)->__value_));
__node_insert_multi(__h.get());
__h.release();
}
@@ -1167,7 +1169,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::clear() _NOEXCEPT
__deallocate(__p1_.first().__next_);
__p1_.first().__next_ = nullptr;
size_type __bc = bucket_count();
for (size_type __i; __i < __bc; ++__i)
for (size_type __i = 0; __i < __bc; ++__i)
__bucket_list_[__i] = nullptr;
size() = 0;
}
@@ -1200,7 +1202,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __
{
if (size()+1 > __bc * max_load_factor() || __bc == 0)
{
rehash(_STD::max<size_type>(2 * __bc + 1,
rehash(_VSTD::max<size_type>(2 * __bc + 1,
size_type(ceil(float(size() + 1) / max_load_factor()))));
__bc = bucket_count();
__chash = __nd->__hash_ % __bc;
@@ -1209,7 +1211,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __
__node_pointer __pn = __bucket_list_[__chash];
if (__pn == nullptr)
{
__pn = static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
__pn = static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
__nd->__next_ = __pn->__next_;
__pn->__next_ = __nd;
// fix up __bucket_list_
@@ -1239,7 +1241,7 @@ __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(_STD::max<size_type>(2 * __bc + 1,
rehash(_VSTD::max<size_type>(2 * __bc + 1,
size_type(ceil(float(size() + 1) / max_load_factor()))));
__bc = bucket_count();
}
@@ -1247,7 +1249,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(__node_pointer __c
__node_pointer __pn = __bucket_list_[__chash];
if (__pn == nullptr)
{
__pn = static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
__pn = static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
__cp->__next_ = __pn->__next_;
__pn->__next_ = __cp;
// fix up __bucket_list_
@@ -1300,7 +1302,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(
size_type __bc = bucket_count();
if (size()+1 > __bc * max_load_factor() || __bc == 0)
{
rehash(_STD::max<size_type>(2 * __bc + 1,
rehash(_VSTD::max<size_type>(2 * __bc + 1,
size_type(ceil(float(size() + 1) / max_load_factor()))));
__bc = bucket_count();
}
@@ -1344,7 +1346,7 @@ __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(_STD::max<size_type>(2 * __bc + 1,
rehash(_VSTD::max<size_type>(2 * __bc + 1,
size_type(ceil(float(size() + 1) / max_load_factor()))));
__bc = bucket_count();
__chash = __hash % __bc;
@@ -1353,7 +1355,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(const value_type& __x)
__node_pointer __pn = __bucket_list_[__chash];
if (__pn == nullptr)
{
__pn = static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
__pn = static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
__h->__next_ = __pn->__next_;
__pn->__next_ = __h.get();
// fix up __bucket_list_
@@ -1383,7 +1385,7 @@ template <class... _Args>
pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique(_Args&&... __args)
{
__node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
pair<iterator, bool> __r = __node_insert_unique(__h.get());
if (__r.second)
__h.release();
@@ -1395,7 +1397,7 @@ template <class... _Args>
typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_multi(_Args&&... __args)
{
__node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
iterator __r = __node_insert_multi(__h.get());
__h.release();
return __r;
@@ -1407,7 +1409,7 @@ typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_hint_multi(
const_iterator __p, _Args&&... __args)
{
__node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
iterator __r = __node_insert_multi(__p, __h.get());
__h.release();
return __r;
@@ -1420,7 +1422,7 @@ template <class _P>
pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(_P&& __x)
{
__node_holder __h = __construct_node(_STD::forward<_P>(__x));
__node_holder __h = __construct_node(_VSTD::forward<_P>(__x));
pair<iterator, bool> __r = __node_insert_unique(__h.get());
if (__r.second)
__h.release();
@@ -1436,7 +1438,7 @@ template <class _P>
typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(_P&& __x)
{
__node_holder __h = __construct_node(_STD::forward<_P>(__x));
__node_holder __h = __construct_node(_VSTD::forward<_P>(__x));
iterator __r = __node_insert_multi(__h.get());
__h.release();
return __r;
@@ -1448,7 +1450,7 @@ typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
__hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const_iterator __p,
_P&& __x)
{
__node_holder __h = __construct_node(_STD::forward<_P>(__x));
__node_holder __h = __construct_node(_VSTD::forward<_P>(__x));
iterator __r = __node_insert_multi(__p, __h.get());
__h.release();
return __r;
@@ -1483,13 +1485,13 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc>
void
__hash_table<_Tp, _Hash, _Equal, _Alloc>::rehash(size_type __n)
{
__n = __next_prime(_STD::max<size_type>(__n, size() > 0));
__n = __next_prime(_VSTD::max<size_type>(__n, size() > 0));
size_type __bc = bucket_count();
if (__n > __bc)
__rehash(__n);
else
{
__n = _STD::max<size_type>
__n = _VSTD::max<size_type>
(
__n,
__next_prime(size_t(ceil(float(size()) / max_load_factor())))
@@ -1511,7 +1513,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__rehash(size_type __nbc)
{
for (size_type __i = 0; __i < __nbc; ++__i)
__bucket_list_[__i] = nullptr;
__node_pointer __pp(static_cast<__node_pointer>(_STD::addressof(__p1_.first())));
__node_pointer __pp(static_cast<__node_pointer>(_VSTD::addressof(__p1_.first())));
__node_pointer __cp = __pp->__next_;
if (__cp != nullptr)
{
@@ -1611,7 +1613,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(_Args&& ...__args)
{
__node_allocator& __na = __node_alloc();
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_Args>(__args)...);
__node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::forward<_Args>(__args)...);
__h.get_deleter().__value_constructed = true;
__h->__hash_ = hash_function()(__h->__value_);
__h->__next_ = nullptr;
@@ -1627,11 +1629,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(value_type&& __v,
{
__node_allocator& __na = __node_alloc();
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::move(__v));
__node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
__h.get_deleter().__value_constructed = true;
__h->__hash_ = __hash;
__h->__next_ = nullptr;
return _STD::move(__h);
return _VSTD::move(__h);
}
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1642,11 +1644,11 @@ __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), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
__node_traits::construct(__na, _VSTD::addressof(__h->__value_), __v);
__h.get_deleter().__value_constructed = true;
__h->__hash_ = hash_function()(__h->__value_);
__h->__next_ = nullptr;
return _STD::move(__h);
return _VSTD::move(__h);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1658,11 +1660,11 @@ __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), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
__node_traits::construct(__na, _VSTD::addressof(__h->__value_), __v);
__h.get_deleter().__value_constructed = true;
__h->__hash_ = __hash;
__h->__next_ = nullptr;
return _STD::move(__h);
return _VSTD::move(__h);
}
template <class _Tp, class _Hash, class _Equal, class _Alloc>
@@ -1736,7 +1738,7 @@ __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 == _STD::addressof(__p1_.first()) || __pn->__hash_ % __bc != __chash)
if (__pn == _VSTD::addressof(__p1_.first()) || __pn->__hash_ % __bc != __chash)
{
if (__cn->__next_ == nullptr || __cn->__next_->__hash_ % __bc != __chash)
__bucket_list_[__chash] = nullptr;
@@ -1752,7 +1754,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p) _NOEXCEPT
__pn->__next_ = __cn->__next_;
__cn->__next_ = nullptr;
--size();
return __node_holder(__cn, _D(__node_alloc()));
return __node_holder(__cn, _D(__node_alloc(), true));
}
template <class _Tp, class _Hash, class _Equal, class _Alloc>
@@ -1867,19 +1869,19 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::swap(__hash_table& __u)
__bucket_list_.reset(__u.__bucket_list_.release());
__u.__bucket_list_.reset(__npp);
}
_STD::swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size());
_VSTD::swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size());
__swap_alloc(__bucket_list_.get_deleter().__alloc(),
__u.__bucket_list_.get_deleter().__alloc());
__swap_alloc(__node_alloc(), __u.__node_alloc());
_STD::swap(__p1_.first().__next_, __u.__p1_.first().__next_);
_VSTD::swap(__p1_.first().__next_, __u.__p1_.first().__next_);
__p2_.swap(__u.__p2_);
__p3_.swap(__u.__p3_);
if (size() > 0)
__bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
if (__u.size() > 0)
__u.__bucket_list_[__u.__p1_.first().__next_->__hash_ % __u.bucket_count()] =
static_cast<__node_pointer>(_STD::addressof(__u.__p1_.first()));
static_cast<__node_pointer>(_VSTD::addressof(__u.__p1_.first()));
}
template <class _Tp, class _Hash, class _Equal, class _Alloc>

View File

@@ -19,7 +19,11 @@
#include <cstdint>
#include <cctype>
#include <locale.h>
#include <xlocale.h>
#if _WIN32
# include <support/win32/locale_win32.h>
#elif (__GLIBC__ || __APPLE__ || __FreeBSD__)
# include <xlocale.h>
#endif // _WIN32 || __GLIBC__ || __APPLE__ || __FreeBSD_
#pragma GCC system_header
@@ -137,10 +141,10 @@ locale
locale::combine(const locale& __other) const
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (!_STD::has_facet<_Facet>(__other))
if (!_VSTD::has_facet<_Facet>(__other))
throw runtime_error("locale::combine: locale missing facet");
#endif // _LIBCPP_NO_EXCEPTIONS
return locale(*this, &const_cast<_Facet&>(_STD::use_facet<_Facet>(__other)));
return locale(*this, &const_cast<_Facet&>(_VSTD::use_facet<_Facet>(__other)));
}
template <class _Facet>
@@ -227,18 +231,18 @@ 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) + *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);
}
extern template class _LIBCPP_VISIBLE collate<char>;
@@ -292,7 +296,7 @@ bool
locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
const basic_string<_CharT, _Traits, _Allocator>& __y) const
{
return _STD::use_facet<_STD::collate<_CharT> >(*this).compare(
return _VSTD::use_facet<_VSTD::collate<_CharT> >(*this).compare(
__x.data(), __x.data() + __x.size(),
__y.data(), __y.data() + __y.size()) < 0;
}
@@ -302,20 +306,8 @@ locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
class _LIBCPP_VISIBLE ctype_base
{
public:
typedef __uint32_t mask;
#if __APPLE__
static const mask space = _CTYPE_S;
static const mask print = _CTYPE_R;
static const mask cntrl = _CTYPE_C;
static const mask upper = _CTYPE_U;
static const mask lower = _CTYPE_L;
static const mask alpha = _CTYPE_A;
static const mask digit = _CTYPE_D;
static const mask punct = _CTYPE_P;
static const mask xdigit = _CTYPE_X;
static const mask blank = _CTYPE_B;
#else // __APPLE__
#if __GLIBC__
typedef unsigned short mask;
static const mask space = _ISspace;
static const mask print = _ISprint;
static const mask cntrl = _IScntrl;
@@ -326,7 +318,47 @@ public:
static const mask punct = _ISpunct;
static const mask xdigit = _ISxdigit;
static const mask blank = _ISblank;
#endif // __APPLE__
#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
static const mask space = _CTYPE_S;
static const mask print = _CTYPE_R;
static const mask cntrl = _CTYPE_C;
static const mask upper = _CTYPE_U;
static const mask lower = _CTYPE_L;
static const mask alpha = _CTYPE_A;
static const mask digit = _CTYPE_D;
static const mask punct = _CTYPE_P;
static const mask xdigit = _CTYPE_X;
static const mask blank = _CTYPE_B;
#else // __GLIBC__ || _WIN32 || __APPLE__ || __FreeBSD__
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__
static const mask alnum = alpha | digit;
static const mask graph = alnum | punct;
@@ -537,6 +569,10 @@ 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();

View File

@@ -21,8 +21,8 @@
#ifdef _LIBCPP_SHARED_LOCK
namespace ting {
template <class> class shared_lock;
template <class> class upgrade_lock;
template <class _Mutex> class shared_lock;
template <class _Mutex> class upgrade_lock;
}
#endif // _LIBCPP_SHARED_LOCK
@@ -190,8 +190,8 @@ public:
_LIBCPP_INLINE_VISIBILITY
void swap(unique_lock& __u)
{
_STD::swap(__m_, __u.__m_);
_STD::swap(__owns_, __u.__owns_);
_VSTD::swap(__m_, __u.__m_);
_VSTD::swap(__owns_, __u.__owns_);
}
_LIBCPP_INLINE_VISIBILITY
mutex_type* release()
@@ -429,7 +429,7 @@ condition_variable::wait_for(unique_lock<mutex>& __lk,
_Predicate __pred)
{
return wait_until(__lk, chrono::steady_clock::now() + __d,
_STD::move(__pred));
_VSTD::move(__pred));
}
_LIBCPP_END_NAMESPACE_STD

View File

@@ -141,14 +141,14 @@ public:
private:
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(const __split_buffer& __c, true_type)
void __move_assign_alloc(__split_buffer& __c, true_type)
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
{
__alloc() = _STD::move(__c.__alloc());
__alloc() = _VSTD::move(__c.__alloc());
}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(const __split_buffer& __c, false_type) _NOEXCEPT
void __move_assign_alloc(__split_buffer& __c, false_type) _NOEXCEPT
{}
_LIBCPP_INLINE_VISIBILITY
@@ -162,7 +162,7 @@ private:
static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y, true_type)
_NOEXCEPT_(__is_nothrow_swappable<__alloc_rr>::value)
{
using _STD::swap;
using _VSTD::swap;
swap(__x, __y);
}
@@ -208,7 +208,7 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
__alloc_rr& __a = this->__alloc();
do
{
__alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_), value_type());
__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_));
++this->__end_;
--__n;
} while (__n > 0);
@@ -227,7 +227,7 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_referen
__alloc_rr& __a = this->__alloc();
do
{
__alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_), __x);
__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), __x);
++this->__end_;
--__n;
} while (__n > 0);
@@ -249,14 +249,14 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(_InputIter __first, _InputIt
if (__end_ == __end_cap())
{
size_type __old_cap = __end_cap() - __first_;
size_type __new_cap = _STD::max<size_type>(2 * __old_cap, 8);
size_type __new_cap = _VSTD::max<size_type>(2 * __old_cap, 8);
__split_buffer __buf(__new_cap, 0, __a);
for (pointer __p = __begin_; __p != __end_; ++__p, ++__buf.__end_)
__alloc_traits::construct(__buf.__alloc(),
_STD::__to_raw_pointer(__buf.__end_), _STD::move(*__p));
_VSTD::__to_raw_pointer(__buf.__end_), _VSTD::move(*__p));
swap(__buf);
}
__alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_), *__first);
__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first);
++this->__end_;
}
}
@@ -273,7 +273,7 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _F
__alloc_rr& __a = this->__alloc();
for (; __first != __last; ++__first)
{
__alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_), *__first);
__alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first);
++this->__end_;
}
}
@@ -356,10 +356,10 @@ __split_buffer<_Tp, _Allocator>::~__split_buffer()
template <class _Tp, class _Allocator>
__split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c)
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
: __first_(_STD::move(__c.__first_)),
__begin_(_STD::move(__c.__begin_)),
__end_(_STD::move(__c.__end_)),
__end_cap_(_STD::move(__c.__end_cap_))
: __first_(_VSTD::move(__c.__first_)),
__begin_(_VSTD::move(__c.__begin_)),
__end_(_VSTD::move(__c.__end_)),
__end_cap_(_VSTD::move(__c.__end_cap_))
{
__c.__first_ = nullptr;
__c.__begin_ = nullptr;
@@ -421,10 +421,10 @@ __split_buffer<_Tp, _Allocator>::swap(__split_buffer& __x)
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value||
__is_nothrow_swappable<__alloc_rr>::value)
{
_STD::swap(__first_, __x.__first_);
_STD::swap(__begin_, __x.__begin_);
_STD::swap(__end_, __x.__end_);
_STD::swap(__end_cap(), __x.__end_cap());
_VSTD::swap(__first_, __x.__first_);
_VSTD::swap(__begin_, __x.__begin_);
_VSTD::swap(__end_, __x.__end_);
_VSTD::swap(__end_cap(), __x.__end_cap());
__swap_alloc(__alloc(), __x.__alloc());
}
@@ -437,10 +437,10 @@ __split_buffer<_Tp, _Allocator>::reserve(size_type __n)
__split_buffer<value_type, __alloc_rr&> __t(__n, 0, __alloc());
__t.__construct_at_end(move_iterator<pointer>(__begin_),
move_iterator<pointer>(__end_));
_STD::swap(__first_, __t.__first_);
_STD::swap(__begin_, __t.__begin_);
_STD::swap(__end_, __t.__end_);
_STD::swap(__end_cap(), __t.__end_cap());
_VSTD::swap(__first_, __t.__first_);
_VSTD::swap(__begin_, __t.__begin_);
_VSTD::swap(__end_, __t.__end_);
_VSTD::swap(__end_cap(), __t.__end_cap());
}
}
@@ -458,10 +458,10 @@ __split_buffer<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
__t.__construct_at_end(move_iterator<pointer>(__begin_),
move_iterator<pointer>(__end_));
__t.__end_ = __t.__begin_ + (__end_ - __begin_);
_STD::swap(__first_, __t.__first_);
_STD::swap(__begin_, __t.__begin_);
_STD::swap(__end_, __t.__end_);
_STD::swap(__end_cap(), __t.__end_cap());
_VSTD::swap(__first_, __t.__first_);
_VSTD::swap(__begin_, __t.__begin_);
_VSTD::swap(__end_, __t.__end_);
_VSTD::swap(__end_cap(), __t.__end_cap());
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
@@ -481,7 +481,7 @@ __split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
{
difference_type __d = __end_cap() - __end_;
__d = (__d + 1) / 2;
__begin_ = _STD::move_backward(__begin_, __end_, __end_ + __d);
__begin_ = _VSTD::move_backward(__begin_, __end_, __end_ + __d);
__end_ += __d;
}
else
@@ -490,13 +490,13 @@ __split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
__split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
__t.__construct_at_end(move_iterator<pointer>(__begin_),
move_iterator<pointer>(__end_));
_STD::swap(__first_, __t.__first_);
_STD::swap(__begin_, __t.__begin_);
_STD::swap(__end_, __t.__end_);
_STD::swap(__end_cap(), __t.__end_cap());
_VSTD::swap(__first_, __t.__first_);
_VSTD::swap(__begin_, __t.__begin_);
_VSTD::swap(__end_, __t.__end_);
_VSTD::swap(__end_cap(), __t.__end_cap());
}
}
__alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__begin_-1), __x);
__alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__begin_-1), __x);
--__begin_;
}
@@ -512,7 +512,7 @@ __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
{
difference_type __d = __end_cap() - __end_;
__d = (__d + 1) / 2;
__begin_ = _STD::move_backward(__begin_, __end_, __end_ + __d);
__begin_ = _VSTD::move_backward(__begin_, __end_, __end_ + __d);
__end_ += __d;
}
else
@@ -521,14 +521,14 @@ __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
__split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
__t.__construct_at_end(move_iterator<pointer>(__begin_),
move_iterator<pointer>(__end_));
_STD::swap(__first_, __t.__first_);
_STD::swap(__begin_, __t.__begin_);
_STD::swap(__end_, __t.__end_);
_STD::swap(__end_cap(), __t.__end_cap());
_VSTD::swap(__first_, __t.__first_);
_VSTD::swap(__begin_, __t.__begin_);
_VSTD::swap(__end_, __t.__end_);
_VSTD::swap(__end_cap(), __t.__end_cap());
}
}
__alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__begin_-1),
_STD::move(__x));
__alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__begin_-1),
_VSTD::move(__x));
--__begin_;
}
@@ -545,7 +545,7 @@ __split_buffer<_Tp, _Allocator>::push_back(const_reference __x)
{
difference_type __d = __begin_ - __first_;
__d = (__d + 1) / 2;
__end_ = _STD::move(__begin_, __end_, __begin_ - __d);
__end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
__begin_ -= __d;
}
else
@@ -554,13 +554,13 @@ __split_buffer<_Tp, _Allocator>::push_back(const_reference __x)
__split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
__t.__construct_at_end(move_iterator<pointer>(__begin_),
move_iterator<pointer>(__end_));
_STD::swap(__first_, __t.__first_);
_STD::swap(__begin_, __t.__begin_);
_STD::swap(__end_, __t.__end_);
_STD::swap(__end_cap(), __t.__end_cap());
_VSTD::swap(__first_, __t.__first_);
_VSTD::swap(__begin_, __t.__begin_);
_VSTD::swap(__end_, __t.__end_);
_VSTD::swap(__end_cap(), __t.__end_cap());
}
}
__alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__end_), __x);
__alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_), __x);
++__end_;
}
@@ -576,7 +576,7 @@ __split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
{
difference_type __d = __begin_ - __first_;
__d = (__d + 1) / 2;
__end_ = _STD::move(__begin_, __end_, __begin_ - __d);
__end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
__begin_ -= __d;
}
else
@@ -585,14 +585,14 @@ __split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
__split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
__t.__construct_at_end(move_iterator<pointer>(__begin_),
move_iterator<pointer>(__end_));
_STD::swap(__first_, __t.__first_);
_STD::swap(__begin_, __t.__begin_);
_STD::swap(__end_, __t.__end_);
_STD::swap(__end_cap(), __t.__end_cap());
_VSTD::swap(__first_, __t.__first_);
_VSTD::swap(__begin_, __t.__begin_);
_VSTD::swap(__end_, __t.__end_);
_VSTD::swap(__end_cap(), __t.__end_cap());
}
}
__alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__end_),
_STD::move(__x));
__alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_),
_VSTD::move(__x));
++__end_;
}
@@ -609,7 +609,7 @@ __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)
{
difference_type __d = __begin_ - __first_;
__d = (__d + 1) / 2;
__end_ = _STD::move(__begin_, __end_, __begin_ - __d);
__end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
__begin_ -= __d;
}
else
@@ -618,14 +618,14 @@ __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)
__split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
__t.__construct_at_end(move_iterator<pointer>(__begin_),
move_iterator<pointer>(__end_));
_STD::swap(__first_, __t.__first_);
_STD::swap(__begin_, __t.__begin_);
_STD::swap(__end_, __t.__end_);
_STD::swap(__end_cap(), __t.__end_cap());
_VSTD::swap(__first_, __t.__first_);
_VSTD::swap(__begin_, __t.__begin_);
_VSTD::swap(__end_, __t.__end_);
_VSTD::swap(__end_cap(), __t.__end_cap());
}
}
__alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__end_),
_STD::forward<_Args>(__args)...);
__alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_),
_VSTD::forward<_Args>(__args)...);
++__end_;
}

View File

@@ -97,7 +97,7 @@ typename __stdinbuf<_CharT>::int_type
__stdinbuf<_CharT>::__getchar(bool __consume)
{
char __extbuf[__limit];
int __nread = _STD::max(1, __encoding_);
int __nread = _VSTD::max(1, __encoding_);
for (int __i = 0; __i < __nread; ++__i)
{
char __c = getc(__file_);
@@ -120,7 +120,7 @@ __stdinbuf<_CharT>::__getchar(bool __consume)
&__1buf, &__1buf + 1, __inxt);
switch (__r)
{
case _STD::codecvt_base::ok:
case _VSTD::codecvt_base::ok:
break;
case codecvt_base::partial:
__st_ = __sv_st;
@@ -136,11 +136,11 @@ __stdinbuf<_CharT>::__getchar(bool __consume)
break;
case codecvt_base::error:
return traits_type::eof();
case _STD::codecvt_base::noconv:
case _VSTD::codecvt_base::noconv:
__1buf = static_cast<char_type>(__extbuf[0]);
break;
}
} while (__r == _STD::codecvt_base::partial);
} while (__r == _VSTD::codecvt_base::partial);
}
if (!__consume)
{
@@ -166,9 +166,9 @@ __stdinbuf<_CharT>::pbackfail(int_type __c)
switch (__cv_->out(__st_, &__ci, &__ci + 1, __inxt,
__extbuf, __extbuf + sizeof(__extbuf), __enxt))
{
case _STD::codecvt_base::ok:
case _VSTD::codecvt_base::ok:
break;
case _STD::codecvt_base::noconv:
case _VSTD::codecvt_base::noconv:
__extbuf[0] = static_cast<char>(__c);
__enxt = __extbuf + 1;
break;

View File

@@ -21,13 +21,19 @@
_LIBCPP_BEGIN_NAMESPACE_STD
template <class, class, class> class __tree;
template <class, class, class> class _LIBCPP_VISIBLE __tree_iterator;
template <class, class, class> class _LIBCPP_VISIBLE __tree_const_iterator;
template <class, class, class, class> class _LIBCPP_VISIBLE map;
template <class, class, class, class> class _LIBCPP_VISIBLE multimap;
template <class, class, class> class _LIBCPP_VISIBLE set;
template <class, class, class> class _LIBCPP_VISIBLE multiset;
template <class _Tp, class _Compare, class _Allocator> class __tree;
template <class _Tp, class _NodePtr, class _DiffType>
class _LIBCPP_VISIBLE __tree_iterator;
template <class _Tp, class _ConstNodePtr, class _DiffType>
class _LIBCPP_VISIBLE __tree_const_iterator;
template <class _Key, class _Tp, class _Compare, class _Allocator>
class _LIBCPP_VISIBLE map;
template <class _Key, class _Tp, class _Compare, class _Allocator>
class _LIBCPP_VISIBLE multimap;
template <class _Key, class _Compare, class _Allocator>
class _LIBCPP_VISIBLE set;
template <class _Key, class _Compare, class _Allocator>
class _LIBCPP_VISIBLE multiset;
/*
@@ -494,7 +500,7 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
}
}
template <class> class __map_node_destructor;
template <class _Allocator> class __map_node_destructor;
template <class _Allocator>
class __tree_node_destructor
@@ -523,7 +529,7 @@ public:
void operator()(pointer __p) _NOEXCEPT
{
if (__value_constructed)
__alloc_traits::destroy(__na_, _STD::addressof(__p->__value_));
__alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_));
if (__p)
__alloc_traits::deallocate(__na_, __p, 1);
}
@@ -598,7 +604,7 @@ public:
template <class ..._Args>
_LIBCPP_INLINE_VISIBILITY
explicit __tree_node(_Args&& ...__args)
: __value_(_STD::forward<_Args>(__args)...) {}
: __value_(_VSTD::forward<_Args>(__args)...) {}
#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY
explicit __tree_node(const value_type& __v)
@@ -606,8 +612,8 @@ public:
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
};
template <class> class __map_iterator;
template <class> class __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
@@ -1069,7 +1075,7 @@ private:
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__tree& __t, true_type)
_NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
{__node_alloc() = _STD::move(__t.__node_alloc());}
{__node_alloc() = _VSTD::move(__t.__node_alloc());}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__tree& __t, false_type) _NOEXCEPT {}
@@ -1084,7 +1090,7 @@ private:
static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, true_type)
_NOEXCEPT_(__is_nothrow_swappable<__node_allocator>::value)
{
using _STD::swap;
using _VSTD::swap;
swap(__x, __y);
}
_LIBCPP_INLINE_VISIBILITY
@@ -1278,9 +1284,9 @@ __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t)
_NOEXCEPT_(
is_nothrow_move_constructible<__node_allocator>::value &&
is_nothrow_move_constructible<value_compare>::value)
: __begin_node_(_STD::move(__t.__begin_node_)),
__pair1_(_STD::move(__t.__pair1_)),
__pair3_(_STD::move(__t.__pair3_))
: __begin_node_(_VSTD::move(__t.__begin_node_)),
__pair1_(_VSTD::move(__t.__pair1_)),
__pair3_(_VSTD::move(__t.__pair3_))
{
if (size() == 0)
__begin_node() = __end_node();
@@ -1296,7 +1302,7 @@ __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t)
template <class _Tp, class _Compare, class _Allocator>
__tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __a)
: __pair1_(__node_allocator(__a)),
__pair3_(0, _STD::move(__t.value_comp()))
__pair3_(0, _VSTD::move(__t.value_comp()))
{
if (__a == __t.__alloc())
{
@@ -1329,7 +1335,7 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, true_type)
__begin_node_ = __t.__begin_node_;
__pair1_.first() = __t.__pair1_.first();
__move_assign_alloc(__t);
__pair3_ = _STD::move(__t.__pair3_);
__pair3_ = _VSTD::move(__t.__pair3_);
if (size() == 0)
__begin_node() = __end_node();
else
@@ -1349,7 +1355,7 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
__move_assign(__t, true_type());
else
{
value_comp() = _STD::move(__t.value_comp());
value_comp() = _VSTD::move(__t.value_comp());
const_iterator __e = end();
if (size() != 0)
{
@@ -1360,7 +1366,7 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
#endif // _LIBCPP_NO_EXCEPTIONS
while (__cache != nullptr && __t.size() != 0)
{
__cache->__value_ = _STD::move(__t.remove(__t.begin())->__value_);
__cache->__value_ = _VSTD::move(__t.remove(__t.begin())->__value_);
__node_pointer __next = __detach(__cache);
__node_insert_multi(__cache);
__cache = __next;
@@ -1383,7 +1389,7 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
}
}
while (__t.size() != 0)
__insert_multi(__e, _STD::move(__t.remove(__t.begin())->__value_));
__insert_multi(__e, _VSTD::move(__t.remove(__t.begin())->__value_));
}
}
@@ -1418,7 +1424,7 @@ __tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT
destroy(static_cast<__node_pointer>(__nd->__left_));
destroy(static_cast<__node_pointer>(__nd->__right_));
__node_allocator& __na = __node_alloc();
__node_traits::destroy(__na, _STD::addressof(__nd->__value_));
__node_traits::destroy(__na, _VSTD::addressof(__nd->__value_));
__node_traits::deallocate(__na, __nd, 1);
}
}
@@ -1431,7 +1437,7 @@ __tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)
(!__node_traits::propagate_on_container_swap::value ||
__is_nothrow_swappable<__node_allocator>::value))
{
using _STD::swap;
using _VSTD::swap;
swap(__begin_node_, __t.__begin_node_);
swap(__pair1_.first(), __t.__pair1_.first());
__swap_alloc(__node_alloc(), __t.__node_alloc());
@@ -1655,10 +1661,10 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
else if (value_comp()(*__hint, __v)) // check after
{
// *__hint < __v
const_iterator __next = _STD::next(__hint);
const_iterator __next = _VSTD::next(__hint);
if (__next == end() || value_comp()(__v, *__next))
{
// *__hint < __v < *_STD::next(__hint)
// *__hint < __v < *_VSTD::next(__hint)
if (__hint.__ptr_->__right_ == nullptr)
{
__parent = const_cast<__node_pointer&>(__hint.__ptr_);
@@ -1704,7 +1710,7 @@ __tree<_Tp, _Compare, _Allocator>::__construct_node(_Args&& ...__args)
{
__node_allocator& __na = __node_alloc();
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_Args>(__args)...);
__node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::forward<_Args>(__args)...);
__h.get_deleter().__value_constructed = true;
return __h;
}
@@ -1714,7 +1720,7 @@ template <class... _Args>
pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
__tree<_Tp, _Compare, _Allocator>::__emplace_unique(_Args&&... __args)
{
__node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
__node_base_pointer __parent;
__node_base_pointer& __child = __find_equal(__parent, __h->__value_);
__node_pointer __r = static_cast<__node_pointer>(__child);
@@ -1733,7 +1739,7 @@ template <class... _Args>
typename __tree<_Tp, _Compare, _Allocator>::iterator
__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique(const_iterator __p, _Args&&... __args)
{
__node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
__node_base_pointer __parent;
__node_base_pointer& __child = __find_equal(__p, __parent, __h->__value_);
__node_pointer __r = static_cast<__node_pointer>(__child);
@@ -1750,7 +1756,7 @@ template <class... _Args>
typename __tree<_Tp, _Compare, _Allocator>::iterator
__tree<_Tp, _Compare, _Allocator>::__emplace_multi(_Args&&... __args)
{
__node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
__node_base_pointer __parent;
__node_base_pointer& __child = __find_leaf_high(__parent, __h->__value_);
__insert_node_at(__parent, __child, __h.get());
@@ -1763,7 +1769,7 @@ typename __tree<_Tp, _Compare, _Allocator>::iterator
__tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p,
_Args&&... __args)
{
__node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
__node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
__node_base_pointer __parent;
__node_base_pointer& __child = __find_leaf(__p, __parent, __h->__value_);
__insert_node_at(__parent, __child, __h.get());
@@ -1777,7 +1783,7 @@ template <class _V>
pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
__tree<_Tp, _Compare, _Allocator>::__insert_unique(_V&& __v)
{
__node_holder __h = __construct_node(_STD::forward<_V>(__v));
__node_holder __h = __construct_node(_VSTD::forward<_V>(__v));
pair<iterator, bool> __r = __node_insert_unique(__h.get());
if (__r.second)
__h.release();
@@ -1789,7 +1795,7 @@ template <class _V>
typename __tree<_Tp, _Compare, _Allocator>::iterator
__tree<_Tp, _Compare, _Allocator>::__insert_unique(const_iterator __p, _V&& __v)
{
__node_holder __h = __construct_node(_STD::forward<_V>(__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();
@@ -1801,7 +1807,7 @@ template <class _V>
typename __tree<_Tp, _Compare, _Allocator>::iterator
__tree<_Tp, _Compare, _Allocator>::__insert_multi(_V&& __v)
{
__node_holder __h = __construct_node(_STD::forward<_V>(__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());
@@ -1813,7 +1819,7 @@ template <class _V>
typename __tree<_Tp, _Compare, _Allocator>::iterator
__tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, _V&& __v)
{
__node_holder __h = __construct_node(_STD::forward<_V>(__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());
@@ -1828,9 +1834,9 @@ __tree<_Tp, _Compare, _Allocator>::__construct_node(const value_type& __v)
{
__node_allocator& __na = __node_alloc();
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
__node_traits::construct(__na, _VSTD::addressof(__h->__value_), __v);
__h.get_deleter().__value_constructed = true;
return _STD::move(__h);
return _VSTD::move(__h);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1956,7 +1962,7 @@ __tree<_Tp, _Compare, _Allocator>::erase(const_iterator __p)
__begin_node() = __r.__ptr_;
--size();
__node_allocator& __na = __node_alloc();
__node_traits::destroy(__na, const_cast<value_type*>(_STD::addressof(*__p)));
__node_traits::destroy(__na, const_cast<value_type*>(_VSTD::addressof(*__p)));
__tree_remove(__end_node()->__left_,
static_cast<__node_base_pointer>(__np));
__node_traits::deallocate(__na, __np, 1);
@@ -2058,7 +2064,7 @@ __tree<_Tp, _Compare, _Allocator>::__count_multi(const _Key& __k) const
else if (value_comp()(__rt->__value_, __k))
__rt = static_cast<__node_const_pointer>(__rt->__right_);
else
return _STD::distance(
return _VSTD::distance(
__lower_bound(__k, static_cast<__node_const_pointer>(__rt->__left_), __rt),
__upper_bound(__k, static_cast<__node_const_pointer>(__rt->__right_), __result)
);

View File

@@ -214,11 +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,
#if 1 // waiting on cwg 1170
is_convertible<_Tp0, _Up0>::value &&
#else
is_constructible<_Up0, _Tp0>::value &&
#endif
__tuple_convertible_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
template <>

File diff suppressed because it is too large Load Diff

View File

@@ -136,10 +136,10 @@ struct _LIBCPP_VISIBLE array
// No explicit construct/copy/destroy for aggregate type
_LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u)
{_STD::fill_n(__elems_, _Size, __u);}
{_VSTD::fill_n(__elems_, _Size, __u);}
_LIBCPP_INLINE_VISIBILITY
void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
{_STD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}
{_VSTD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}
// iterators:
_LIBCPP_INLINE_VISIBILITY
@@ -225,7 +225,7 @@ _LIBCPP_INLINE_VISIBILITY inline
bool
operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
{
return _STD::equal(__x.__elems_, __x.__elems_ + _Size, __y.__elems_);
return _VSTD::equal(__x.__elems_, __x.__elems_ + _Size, __y.__elems_);
}
template <class _Tp, size_t _Size>
@@ -241,7 +241,7 @@ _LIBCPP_INLINE_VISIBILITY inline
bool
operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
{
return _STD::lexicographical_compare(__x.__elems_, __x.__elems_ + _Size, __y.__elems_, __y.__elems_ + _Size);
return _VSTD::lexicographical_compare(__x.__elems_, __x.__elems_ + _Size, __y.__elems_, __y.__elems_ + _Size);
}
template <class _Tp, size_t _Size>
@@ -326,7 +326,7 @@ _LIBCPP_INLINE_VISIBILITY inline
_Tp&&
get(array<_Tp, _Size>&& __a) _NOEXCEPT
{
return _STD::move(__a[_Ip]);
return _VSTD::move(__a[_Ip]);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

View File

@@ -129,6 +129,15 @@ template <size_t N> struct hash<std::bitset<N>>;
_LIBCPP_BEGIN_NAMESPACE_STD
template <size_t _N_words, size_t _Size>
class __bitset;
template <size_t _N_words, size_t _Size>
struct __has_storage_type<__bitset<_N_words, _Size> >
{
static const bool value = true;
};
template <size_t _N_words, size_t _Size>
class __bitset
{
@@ -195,7 +204,7 @@ template <size_t _N_words, size_t _Size>
inline _LIBCPP_INLINE_VISIBILITY
__bitset<_N_words, _Size>::__bitset() _NOEXCEPT
{
_STD::fill_n(__first_, _N_words, __storage_type(0));
_VSTD::fill_n(__first_, _N_words, __storage_type(0));
}
template <size_t _N_words, size_t _Size>
@@ -205,8 +214,8 @@ __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)
__t[__i] = static_cast<__storage_type>(__v);
_STD::copy(__t, __t + sizeof(__t)/sizeof(__t[0]), __first_);
_STD::fill(__first_ + sizeof(__t)/sizeof(__t[0]), __first_ + sizeof(__first_)/sizeof(__first_[0]),
_VSTD::copy(__t, __t + sizeof(__t)/sizeof(__t[0]), __first_);
_VSTD::fill(__first_ + sizeof(__t)/sizeof(__t[0]), __first_ + sizeof(__first_)/sizeof(__first_[0]),
__storage_type(0));
}
@@ -216,7 +225,7 @@ void
__bitset<_N_words, _Size>::__init(unsigned long long __v, true_type)
{
__first_[0] = __v;
_STD::fill(__first_ + 1, __first_ + sizeof(__first_)/sizeof(__first_[0]), __storage_type(0));
_VSTD::fill(__first_ + 1, __first_ + sizeof(__first_)/sizeof(__first_[0]), __storage_type(0));
}
template <size_t _N_words, size_t _Size>
@@ -277,7 +286,7 @@ unsigned long
__bitset<_N_words, _Size>::to_ulong(false_type) const
{
const_iterator __e = __make_iter(_Size);
const_iterator __i = _STD::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true);
const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true);
if (__i != __e)
#ifndef _LIBCPP_NO_EXCEPTIONS
throw overflow_error("bitset to_ulong overflow error");
@@ -300,7 +309,7 @@ unsigned long long
__bitset<_N_words, _Size>::to_ullong(false_type) const
{
const_iterator __e = __make_iter(_Size);
const_iterator __i = _STD::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true);
const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true);
if (__i != __e)
#ifndef _LIBCPP_NO_EXCEPTIONS
throw overflow_error("bitset to_ullong overflow error");
@@ -674,7 +683,7 @@ bitset<_Size>::bitset(const _CharT* __str,
typename basic_string<_CharT>::size_type __n,
_CharT __zero, _CharT __one)
{
size_t __rlen = _STD::min(__n, char_traits<_CharT>::length(__str));
size_t __rlen = _VSTD::min(__n, char_traits<_CharT>::length(__str));
for (size_t __i = 0; __i < __rlen; ++__i)
if (__str[__i] != __zero && __str[__i] != __one)
#ifndef _LIBCPP_NO_EXCEPTIONS
@@ -682,7 +691,7 @@ bitset<_Size>::bitset(const _CharT* __str,
#else
assert(!"bitset string ctor has invalid argument");
#endif
size_t _M = _STD::min(__rlen, _Size);
size_t _M = _VSTD::min(__rlen, _Size);
size_t __i = 0;
for (; __i < _M; ++__i)
{
@@ -692,7 +701,7 @@ bitset<_Size>::bitset(const _CharT* __str,
else
(*this)[__i] = true;
}
_STD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
_VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
}
template <size_t _Size>
@@ -708,7 +717,7 @@ bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
#else
assert(!"bitset string pos out of range");
#endif
size_t __rlen = _STD::min(__n, __str.size() - __pos);
size_t __rlen = _VSTD::min(__n, __str.size() - __pos);
for (size_t __i = __pos; __i < __pos + __rlen; ++__i)
if (!_Traits::eq(__str[__i], __zero) && !_Traits::eq(__str[__i], __one))
#ifndef _LIBCPP_NO_EXCEPTIONS
@@ -716,7 +725,7 @@ bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
#else
assert(!"bitset string ctor has invalid argument");
#endif
size_t _M = _STD::min(__rlen, _Size);
size_t _M = _VSTD::min(__rlen, _Size);
size_t __i = 0;
for (; __i < _M; ++__i)
{
@@ -726,7 +735,7 @@ bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
else
(*this)[__i] = true;
}
_STD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
_VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
}
template <size_t _Size>
@@ -760,9 +769,9 @@ template <size_t _Size>
bitset<_Size>&
bitset<_Size>::operator<<=(size_t __pos) _NOEXCEPT
{
__pos = _STD::min(__pos, _Size);
_STD::copy_backward(base::__make_iter(0), base::__make_iter(_Size - __pos), base::__make_iter(_Size));
_STD::fill_n(base::__make_iter(0), __pos, false);
__pos = _VSTD::min(__pos, _Size);
_VSTD::copy_backward(base::__make_iter(0), base::__make_iter(_Size - __pos), base::__make_iter(_Size));
_VSTD::fill_n(base::__make_iter(0), __pos, false);
return *this;
}
@@ -770,9 +779,9 @@ template <size_t _Size>
bitset<_Size>&
bitset<_Size>::operator>>=(size_t __pos) _NOEXCEPT
{
__pos = _STD::min(__pos, _Size);
_STD::copy(base::__make_iter(__pos), base::__make_iter(_Size), base::__make_iter(0));
_STD::fill_n(base::__make_iter(_Size - __pos), __pos, false);
__pos = _VSTD::min(__pos, _Size);
_VSTD::copy(base::__make_iter(__pos), base::__make_iter(_Size), base::__make_iter(0));
_VSTD::fill_n(base::__make_iter(_Size - __pos), __pos, false);
return *this;
}
@@ -781,7 +790,7 @@ inline _LIBCPP_INLINE_VISIBILITY
bitset<_Size>&
bitset<_Size>::set() _NOEXCEPT
{
_STD::fill_n(base::__make_iter(0), _Size, true);
_VSTD::fill_n(base::__make_iter(0), _Size, true);
return *this;
}
@@ -804,7 +813,7 @@ inline _LIBCPP_INLINE_VISIBILITY
bitset<_Size>&
bitset<_Size>::reset() _NOEXCEPT
{
_STD::fill_n(base::__make_iter(0), _Size, false);
_VSTD::fill_n(base::__make_iter(0), _Size, false);
return *this;
}
@@ -917,7 +926,7 @@ inline _LIBCPP_INLINE_VISIBILITY
size_t
bitset<_Size>::count() const _NOEXCEPT
{
return static_cast<size_t>(_STD::count(base::__make_iter(0), base::__make_iter(_Size), true));
return static_cast<size_t>(_VSTD::count(base::__make_iter(0), base::__make_iter(_Size), true));
}
template <size_t _Size>
@@ -925,7 +934,7 @@ inline _LIBCPP_INLINE_VISIBILITY
bool
bitset<_Size>::operator==(const bitset& __rhs) const _NOEXCEPT
{
return _STD::equal(base::__make_iter(0), base::__make_iter(_Size), __rhs.__make_iter(0));
return _VSTD::equal(base::__make_iter(0), base::__make_iter(_Size), __rhs.__make_iter(0));
}
template <size_t _Size>
@@ -1024,6 +1033,14 @@ 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

View File

@@ -72,4 +72,320 @@ 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

View File

@@ -407,7 +407,7 @@ public:
(ratio_divide<_Period2, period>::type::den == 1 &&
!treat_as_floating_point<_Rep2>::value)
>::type* = 0)
: __rep_(_STD::chrono::duration_cast<duration>(__d).count()) {}
: __rep_(_VSTD::chrono::duration_cast<duration>(__d).count()) {}
// observer
@@ -726,7 +726,7 @@ inline _LIBCPP_INLINE_VISIBILITY
time_point<_Clock, _ToDuration>
time_point_cast(const time_point<_Clock, _Duration>& __t)
{
return time_point<_Clock, _ToDuration>(_STD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
return time_point<_Clock, _ToDuration>(_VSTD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
}
// time_point ==

View File

@@ -1173,7 +1173,7 @@ complex<typename __promote<_Tp, _Up>::type>
pow(const complex<_Tp>& __x, const complex<_Up>& __y)
{
typedef complex<typename __promote<_Tp, _Up>::type> result_type;
return _STD::pow(result_type(__x), result_type(__y));
return _VSTD::pow(result_type(__x), result_type(__y));
}
template<class _Tp, class _Up>
@@ -1186,7 +1186,7 @@ typename enable_if
pow(const complex<_Tp>& __x, const _Up& __y)
{
typedef complex<typename __promote<_Tp, _Up>::type> result_type;
return _STD::pow(result_type(__x), result_type(__y));
return _VSTD::pow(result_type(__x), result_type(__y));
}
template<class _Tp, class _Up>
@@ -1199,7 +1199,7 @@ typename enable_if
pow(const _Tp& __x, const complex<_Up>& __y)
{
typedef complex<typename __promote<_Tp, _Up>::type> result_type;
return _STD::pow(result_type(__x), result_type(__y));
return _VSTD::pow(result_type(__x), result_type(__y));
}
// asinh

View File

@@ -243,7 +243,7 @@ condition_variable_any::wait_for(_Lock& __lock,
_Predicate __pred)
{
return wait_until(__lock, chrono::steady_clock::now() + __d,
_STD::move(__pred));
_VSTD::move(__pred));
}
_LIBCPP_VISIBLE

View File

@@ -82,7 +82,7 @@ struct _LIBCPP_VISIBLE nullptr_t
inline _LIBCPP_ALWAYS_INLINE nullptr_t __get_nullptr_t() {return nullptr_t(0);}
#define nullptr _STD::__get_nullptr_t()
#define nullptr _VSTD::__get_nullptr_t()
#endif // _LIBCPP_HAS_NO_NULLPTR

View File

@@ -106,6 +106,9 @@ 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
#pragma GCC system_header

View File

@@ -535,7 +535,7 @@ copy(_RAIter __f,
__n = __bs;
__m = __f + __n;
}
_STD::copy(__f, __m, __rb);
_VSTD::copy(__f, __m, __rb);
__f = __m;
__r += __n;
}
@@ -562,7 +562,7 @@ copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
__bs = __n;
__fe = __fb + __bs;
}
__r = _STD::copy(__fb, __fe, __r);
__r = _VSTD::copy(__fb, __fe, __r);
__n -= __bs;
__f += __bs;
}
@@ -589,7 +589,7 @@ copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
__bs = __n;
__fe = __fb + __bs;
}
__r = _STD::copy(__fb, __fe, __r);
__r = _VSTD::copy(__fb, __fe, __r);
__n -= __bs;
__f += __bs;
}
@@ -610,7 +610,7 @@ copy_backward(_RAIter __f,
typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
while (__f != __l)
{
__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _STD::prev(__r);
__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _VSTD::prev(__r);
pointer __rb = *__rp.__m_iter_;
pointer __re = __rp.__ptr_ + 1;
difference_type __bs = __re - __rb;
@@ -621,7 +621,7 @@ copy_backward(_RAIter __f,
__n = __bs;
__m = __l - __n;
}
_STD::copy_backward(__m, __l, __re);
_VSTD::copy_backward(__m, __l, __re);
__l = __m;
__r -= __n;
}
@@ -649,7 +649,7 @@ copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
__bs = __n;
__lb = __le - __bs;
}
__r = _STD::copy_backward(__lb, __le, __r);
__r = _VSTD::copy_backward(__lb, __le, __r);
__n -= __bs;
__l -= __bs - 1;
}
@@ -677,7 +677,7 @@ copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
__bs = __n;
__lb = __le - __bs;
}
__r = _STD::copy_backward(__lb, __le, __r);
__r = _VSTD::copy_backward(__lb, __le, __r);
__n -= __bs;
__l -= __bs - 1;
}
@@ -708,7 +708,7 @@ move(_RAIter __f,
__n = __bs;
__m = __f + __n;
}
_STD::move(__f, __m, __rb);
_VSTD::move(__f, __m, __rb);
__f = __m;
__r += __n;
}
@@ -735,7 +735,7 @@ move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
__bs = __n;
__fe = __fb + __bs;
}
__r = _STD::move(__fb, __fe, __r);
__r = _VSTD::move(__fb, __fe, __r);
__n -= __bs;
__f += __bs;
}
@@ -762,7 +762,7 @@ move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
__bs = __n;
__fe = __fb + __bs;
}
__r = _STD::move(__fb, __fe, __r);
__r = _VSTD::move(__fb, __fe, __r);
__n -= __bs;
__f += __bs;
}
@@ -783,7 +783,7 @@ move_backward(_RAIter __f,
typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
while (__f != __l)
{
__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _STD::prev(__r);
__deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _VSTD::prev(__r);
pointer __rb = *__rp.__m_iter_;
pointer __re = __rp.__ptr_ + 1;
difference_type __bs = __re - __rb;
@@ -794,7 +794,7 @@ move_backward(_RAIter __f,
__n = __bs;
__m = __l - __n;
}
_STD::move_backward(__m, __l, __re);
_VSTD::move_backward(__m, __l, __re);
__l = __m;
__r -= __n;
}
@@ -822,7 +822,7 @@ move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
__bs = __n;
__lb = __le - __bs;
}
__r = _STD::move_backward(__lb, __le, __r);
__r = _VSTD::move_backward(__lb, __le, __r);
__n -= __bs;
__l -= __bs - 1;
}
@@ -850,7 +850,7 @@ move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
__bs = __n;
__lb = __le - __bs;
}
__r = _STD::move_backward(__lb, __le, __r);
__r = _VSTD::move_backward(__lb, __le, __r);
__n -= __bs;
__l -= __bs - 1;
}
@@ -961,7 +961,7 @@ protected:
_NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
is_nothrow_move_assignable<allocator_type>::value)
{
__map_ = _STD::move(__c.__map_);
__map_ = _VSTD::move(__c.__map_);
__start_ = __c.__start_;
size() = __c.size();
__move_assign_alloc(__c);
@@ -977,14 +977,14 @@ protected:
private:
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(const __deque_base& __c, true_type)
void __move_assign_alloc(__deque_base& __c, true_type)
_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
{
__alloc() = _STD::move(__c.__alloc());
__alloc() = _VSTD::move(__c.__alloc());
}
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(const __deque_base& __c, false_type) _NOEXCEPT
void __move_assign_alloc(__deque_base& __c, false_type) _NOEXCEPT
{}
_LIBCPP_INLINE_VISIBILITY
@@ -998,7 +998,7 @@ private:
static void __swap_alloc(allocator_type& __x, allocator_type& __y, true_type)
_NOEXCEPT_(__is_nothrow_swappable<allocator_type>::value)
{
using _STD::swap;
using _VSTD::swap;
swap(__x, __y);
}
@@ -1097,9 +1097,9 @@ __deque_base<_Tp, _Allocator>::~__deque_base()
template <class _Tp, class _Allocator>
__deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c)
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
: __map_(_STD::move(__c.__map_)),
__start_(_STD::move(__c.__start_)),
__size_(_STD::move(__c.__size_))
: __map_(_VSTD::move(__c.__map_)),
__start_(_VSTD::move(__c.__start_)),
__size_(_VSTD::move(__c.__size_))
{
__c.__start_ = 0;
__c.size() = 0;
@@ -1107,9 +1107,9 @@ __deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c)
template <class _Tp, class _Allocator>
__deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c, const allocator_type& __a)
: __map_(_STD::move(__c.__map_), __pointer_allocator(__a)),
__start_(_STD::move(__c.__start_)),
__size_(_STD::move(__c.size()), __a)
: __map_(_VSTD::move(__c.__map_), __pointer_allocator(__a)),
__start_(_VSTD::move(__c.__start_)),
__size_(_VSTD::move(__c.size()), __a)
{
if (__a == __c.__alloc())
{
@@ -1133,8 +1133,8 @@ __deque_base<_Tp, _Allocator>::swap(__deque_base& __c)
__is_nothrow_swappable<allocator_type>::value)
{
__map_.swap(__c.__map_);
_STD::swap(__start_, __c.__start_);
_STD::swap(size(), __c.size());
_VSTD::swap(__start_, __c.__start_);
_VSTD::swap(size(), __c.size());
__swap_alloc(__alloc(), __c.__alloc());
}
@@ -1144,7 +1144,7 @@ __deque_base<_Tp, _Allocator>::clear() _NOEXCEPT
{
allocator_type& __a = __alloc();
for (iterator __i = begin(), __e = end(); __i != __e; ++__i)
__alloc_traits::destroy(__a, _STD::addressof(*__i));
__alloc_traits::destroy(__a, _VSTD::addressof(*__i));
size() = 0;
while (__map_.size() > 2)
{
@@ -1184,8 +1184,8 @@ public:
typedef typename __base::pointer pointer;
typedef typename __base::const_pointer const_pointer;
typedef _STD::reverse_iterator<iterator> reverse_iterator;
typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
// construct/copy/destroy:
_LIBCPP_INLINE_VISIBILITY
@@ -1204,12 +1204,16 @@ 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);
@@ -1227,8 +1231,10 @@ 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;
@@ -1313,9 +1319,11 @@ 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);
@@ -1452,6 +1460,8 @@ 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)
{
@@ -1465,6 +1475,8 @@ 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)
@@ -1483,14 +1495,14 @@ template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
deque<_Tp, _Allocator>::deque(deque&& __c)
_NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
: __base(_STD::move(__c))
: __base(_VSTD::move(__c))
{
}
template <class _Tp, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
deque<_Tp, _Allocator>::deque(deque&& __c, const allocator_type& __a)
: __base(_STD::move(__c), __a)
: __base(_VSTD::move(__c), __a)
{
if (__a != __c.__alloc())
{
@@ -1562,11 +1574,11 @@ deque<_Tp, _Allocator>::assign(_RAIter __f, _RAIter __l,
if (static_cast<size_type>(__l - __f) > __base::size())
{
_RAIter __m = __f + __base::size();
_STD::copy(__f, __m, __base::begin());
_VSTD::copy(__f, __m, __base::begin());
__append(__m, __l);
}
else
__erase_to_end(_STD::copy(__f, __l, __base::begin()));
__erase_to_end(_VSTD::copy(__f, __l, __base::begin()));
}
template <class _Tp, class _Allocator>
@@ -1575,12 +1587,12 @@ deque<_Tp, _Allocator>::assign(size_type __n, const value_type& __v)
{
if (__n > __base::size())
{
_STD::fill_n(__base::begin(), __base::size(), __v);
_VSTD::fill_n(__base::begin(), __base::size(), __v);
__n -= __base::size();
__append(__n, __v);
}
else
__erase_to_end(_STD::fill_n(__base::begin(), __n, __v));
__erase_to_end(_VSTD::fill_n(__base::begin(), __n, __v));
}
template <class _Tp, class _Allocator>
@@ -1726,7 +1738,7 @@ deque<_Tp, _Allocator>::push_back(const value_type& __v)
if (__back_spare() == 0)
__add_back_capacity();
// __back_spare() >= 1
__alloc_traits::construct(__a, _STD::addressof(*__base::end()), __v);
__alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), __v);
++__base::size();
}
@@ -1740,7 +1752,7 @@ deque<_Tp, _Allocator>::push_back(value_type&& __v)
if (__back_spare() == 0)
__add_back_capacity();
// __back_spare() >= 1
__alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::move(__v));
__alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::move(__v));
++__base::size();
}
@@ -1755,7 +1767,7 @@ deque<_Tp, _Allocator>::emplace_back(_Args&&... __args)
if (__back_spare() == 0)
__add_back_capacity();
// __back_spare() >= 1
__alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::forward<_Args>(__args)...);
__alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::forward<_Args>(__args)...);
++__base::size();
}
@@ -1770,7 +1782,7 @@ deque<_Tp, _Allocator>::push_front(const value_type& __v)
if (__front_spare() == 0)
__add_front_capacity();
// __front_spare() >= 1
__alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), __v);
__alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v);
--__base::__start_;
++__base::size();
}
@@ -1785,7 +1797,7 @@ deque<_Tp, _Allocator>::push_front(value_type&& __v)
if (__front_spare() == 0)
__add_front_capacity();
// __front_spare() >= 1
__alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::move(__v));
__alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::move(__v));
--__base::__start_;
++__base::size();
}
@@ -1801,7 +1813,7 @@ deque<_Tp, _Allocator>::emplace_front(_Args&&... __args)
if (__front_spare() == 0)
__add_front_capacity();
// __front_spare() >= 1
__alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::forward<_Args>(__args)...);
__alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::forward<_Args>(__args)...);
--__base::__start_;
++__base::size();
}
@@ -1823,7 +1835,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
// __front_spare() >= 1
if (__pos == 0)
{
__alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), __v);
__alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v);
--__base::__start_;
++__base::size();
}
@@ -1831,14 +1843,14 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
{
const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
iterator __b = __base::begin();
iterator __bm1 = _STD::prev(__b);
iterator __bm1 = _VSTD::prev(__b);
if (__vt == pointer_traits<const_pointer>::pointer_to(*__b))
__vt = pointer_traits<const_pointer>::pointer_to(*__bm1);
__alloc_traits::construct(__a, _STD::addressof(*__bm1), _STD::move(*__b));
__alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
--__base::__start_;
++__base::size();
if (__pos > 1)
__b = __move_and_check(_STD::next(__b), __b + __pos, __b, __vt);
__b = __move_and_check(_VSTD::next(__b), __b + __pos, __b, __vt);
*__b = *__vt;
}
}
@@ -1850,17 +1862,17 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
size_type __de = __base::size() - __pos;
if (__de == 0)
{
__alloc_traits::construct(__a, _STD::addressof(*__base::end()), __v);
__alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), __v);
++__base::size();
}
else
{
const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
iterator __e = __base::end();
iterator __em1 = _STD::prev(__e);
iterator __em1 = _VSTD::prev(__e);
if (__vt == pointer_traits<const_pointer>::pointer_to(*__em1))
__vt = pointer_traits<const_pointer>::pointer_to(*__e);
__alloc_traits::construct(__a, _STD::addressof(*__e), _STD::move(*__em1));
__alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1));
++__base::size();
if (__de > 1)
__e = __move_backward_and_check(__e - __de, __em1, __e, __vt);
@@ -1886,20 +1898,20 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
// __front_spare() >= 1
if (__pos == 0)
{
__alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::move(__v));
__alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::move(__v));
--__base::__start_;
++__base::size();
}
else
{
iterator __b = __base::begin();
iterator __bm1 = _STD::prev(__b);
__alloc_traits::construct(__a, _STD::addressof(*__bm1), _STD::move(*__b));
iterator __bm1 = _VSTD::prev(__b);
__alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
--__base::__start_;
++__base::size();
if (__pos > 1)
__b = _STD::move(_STD::next(__b), __b + __pos, __b);
*__b = _STD::move(__v);
__b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b);
*__b = _VSTD::move(__v);
}
}
else
@@ -1910,18 +1922,18 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
size_type __de = __base::size() - __pos;
if (__de == 0)
{
__alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::move(__v));
__alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::move(__v));
++__base::size();
}
else
{
iterator __e = __base::end();
iterator __em1 = _STD::prev(__e);
__alloc_traits::construct(__a, _STD::addressof(*__e), _STD::move(*__em1));
iterator __em1 = _VSTD::prev(__e);
__alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1));
++__base::size();
if (__de > 1)
__e = _STD::move_backward(__e - __de, __em1, __e);
*--__e = _STD::move(__v);
__e = _VSTD::move_backward(__e - __de, __em1, __e);
*--__e = _VSTD::move(__v);
}
}
return __base::begin() + __pos;
@@ -1944,20 +1956,20 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
// __front_spare() >= 1
if (__pos == 0)
{
__alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::forward<_Args>(__args)...);
__alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::forward<_Args>(__args)...);
--__base::__start_;
++__base::size();
}
else
{
iterator __b = __base::begin();
iterator __bm1 = _STD::prev(__b);
__alloc_traits::construct(__a, _STD::addressof(*__bm1), _STD::move(*__b));
iterator __bm1 = _VSTD::prev(__b);
__alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
--__base::__start_;
++__base::size();
if (__pos > 1)
__b = _STD::move(_STD::next(__b), __b + __pos, __b);
*__b = value_type(_STD::forward<_Args>(__args)...);
__b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b);
*__b = value_type(_VSTD::forward<_Args>(__args)...);
}
}
else
@@ -1968,18 +1980,18 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
size_type __de = __base::size() - __pos;
if (__de == 0)
{
__alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::forward<_Args>(__args)...);
__alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::forward<_Args>(__args)...);
++__base::size();
}
else
{
iterator __e = __base::end();
iterator __em1 = _STD::prev(__e);
__alloc_traits::construct(__a, _STD::addressof(*__e), _STD::move(*__em1));
iterator __em1 = _VSTD::prev(__e);
__alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1));
++__base::size();
if (__de > 1)
__e = _STD::move_backward(__e - __de, __em1, __e);
*--__e = value_type(_STD::forward<_Args>(__args)...);
__e = _VSTD::move_backward(__e - __de, __em1, __e);
*--__e = value_type(_VSTD::forward<_Args>(__args)...);
}
}
return __base::begin() + __pos;
@@ -2006,7 +2018,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_ty
if (__n > __pos)
{
for (size_type __m = __n - __pos; __m; --__m, --__base::__start_, ++__base::size())
__alloc_traits::construct(__a, _STD::addressof(*--__i), __v);
__alloc_traits::construct(__a, _VSTD::addressof(*--__i), __v);
__n = __pos;
}
if (__n > 0)
@@ -2016,7 +2028,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_ty
__move_construct_backward_and_check(__old_begin, __obn, __i, __vt);
if (__n < __pos)
__old_begin = __move_and_check(__obn, __old_begin + __pos, __old_begin, __vt);
_STD::fill_n(__old_begin, __n, *__vt);
_VSTD::fill_n(__old_begin, __n, *__vt);
}
}
else
@@ -2032,7 +2044,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_ty
if (__n > __de)
{
for (size_type __m = __n - __de; __m; --__m, ++__i, ++__base::size())
__alloc_traits::construct(__a, _STD::addressof(*__i), __v);
__alloc_traits::construct(__a, _VSTD::addressof(*__i), __v);
__n = __de;
}
if (__n > 0)
@@ -2042,7 +2054,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_ty
__move_construct_and_check(__oen, __old_end, __i, __vt);
if (__n < __de)
__old_end = __move_backward_and_check(__old_end - __de, __oen, __old_end, __vt);
_STD::fill_n(__old_end - __n, __n, *__vt);
_VSTD::fill_n(__old_end - __n, __n, *__vt);
}
}
return __base::begin() + __pos;
@@ -2067,7 +2079,7 @@ typename deque<_Tp, _Allocator>::iterator
deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
typename enable_if<__is_bidirectional_iterator<_BiIter>::value>::type*)
{
size_type __n = _STD::distance(__f, __l);
size_type __n = _VSTD::distance(__f, __l);
size_type __pos = __p - __base::begin();
size_type __to_end = __base::size() - __pos;
allocator_type& __a = __base::__alloc();
@@ -2082,9 +2094,9 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
_BiIter __m = __f;
if (__n > __pos)
{
__m = __pos < __n / 2 ? _STD::prev(__l, __pos) : _STD::next(__f, __n - __pos);
__m = __pos < __n / 2 ? _VSTD::prev(__l, __pos) : _VSTD::next(__f, __n - __pos);
for (_BiIter __j = __m; __j != __f; --__base::__start_, ++__base::size())
__alloc_traits::construct(__a, _STD::addressof(*--__i), *--__j);
__alloc_traits::construct(__a, _VSTD::addressof(*--__i), *--__j);
__n = __pos;
}
if (__n > 0)
@@ -2092,13 +2104,13 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
iterator __obn = __old_begin + __n;
for (iterator __j = __obn; __j != __old_begin;)
{
__alloc_traits::construct(__a, _STD::addressof(*--__i), _STD::move(*--__j));
__alloc_traits::construct(__a, _VSTD::addressof(*--__i), _VSTD::move(*--__j));
--__base::__start_;
++__base::size();
}
if (__n < __pos)
__old_begin = _STD::move(__obn, __old_begin + __pos, __old_begin);
_STD::copy(__m, __l, __old_begin);
__old_begin = _VSTD::move(__obn, __old_begin + __pos, __old_begin);
_VSTD::copy(__m, __l, __old_begin);
}
}
else
@@ -2114,19 +2126,19 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
size_type __de = __base::size() - __pos;
if (__n > __de)
{
__m = __de < __n / 2 ? _STD::next(__f, __de) : _STD::prev(__l, __n - __de);
__m = __de < __n / 2 ? _VSTD::next(__f, __de) : _VSTD::prev(__l, __n - __de);
for (_BiIter __j = __m; __j != __l; ++__i, ++__j, ++__base::size())
__alloc_traits::construct(__a, _STD::addressof(*__i), *__j);
__alloc_traits::construct(__a, _VSTD::addressof(*__i), *__j);
__n = __de;
}
if (__n > 0)
{
iterator __oen = __old_end - __n;
for (iterator __j = __oen; __j != __old_end; ++__i, ++__j, ++__base::size())
__alloc_traits::construct(__a, _STD::addressof(*__i), _STD::move(*__j));
__alloc_traits::construct(__a, _VSTD::addressof(*__i), _VSTD::move(*__j));
if (__n < __de)
__old_end = _STD::move_backward(__old_end - __de, __oen, __old_end);
_STD::copy_backward(__f, __m, __old_end);
__old_end = _VSTD::move_backward(__old_end - __de, __oen, __old_end);
_VSTD::copy_backward(__f, __m, __old_end);
}
}
return __base::begin() + __pos;
@@ -2149,14 +2161,14 @@ void
deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,
typename enable_if<__is_forward_iterator<_ForIter>::value>::type*)
{
size_type __n = _STD::distance(__f, __l);
size_type __n = _VSTD::distance(__f, __l);
allocator_type& __a = __base::__alloc();
size_type __back_capacity = __back_spare();
if (__n > __back_capacity)
__add_back_capacity(__n - __back_capacity);
// __n <= __back_capacity
for (iterator __i = __base::end(); __f != __l; ++__i, ++__f, ++__base::size())
__alloc_traits::construct(__a, _STD::addressof(*__i), *__f);
__alloc_traits::construct(__a, _VSTD::addressof(*__i), *__f);
}
template <class _Tp, class _Allocator>
@@ -2169,7 +2181,7 @@ deque<_Tp, _Allocator>::__append(size_type __n)
__add_back_capacity(__n - __back_capacity);
// __n <= __back_capacity
for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size())
__alloc_traits::construct(__a, _STD::addressof(*__i));
__alloc_traits::construct(__a, _VSTD::addressof(*__i));
}
template <class _Tp, class _Allocator>
@@ -2182,7 +2194,7 @@ deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v)
__add_back_capacity(__n - __back_capacity);
// __n <= __back_capacity
for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size())
__alloc_traits::construct(__a, _STD::addressof(*__i), __v);
__alloc_traits::construct(__a, _VSTD::addressof(*__i), __v);
}
// Create front capacity for one block of elements.
@@ -2240,10 +2252,10 @@ deque<_Tp, _Allocator>::__add_front_capacity()
for (typename __base::__map_pointer __i = __base::__map_.begin();
__i != __base::__map_.end(); ++__i)
__buf.push_back(*__i);
_STD::swap(__base::__map_.__first_, __buf.__first_);
_STD::swap(__base::__map_.__begin_, __buf.__begin_);
_STD::swap(__base::__map_.__end_, __buf.__end_);
_STD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
_VSTD::swap(__base::__map_.__first_, __buf.__first_);
_VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
_VSTD::swap(__base::__map_.__end_, __buf.__end_);
_VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
__base::__start_ = __base::__map_.size() == 1 ?
__base::__block_size / 2 :
__base::__start_ + __base::__block_size;
@@ -2260,7 +2272,7 @@ deque<_Tp, _Allocator>::__add_front_capacity(size_type __n)
size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
// Number of unused blocks at back:
size_type __back_capacity = __back_spare() / __base::__block_size;
__back_capacity = _STD::min(__back_capacity, __nb); // don't take more than you need
__back_capacity = _VSTD::min(__back_capacity, __nb); // don't take more than you need
__nb -= __back_capacity; // number of blocks need to allocate
// If __nb == 0, then we have sufficient capacity.
if (__nb == 0)
@@ -2327,10 +2339,10 @@ deque<_Tp, _Allocator>::__add_front_capacity(size_type __n)
for (typename __base::__map_pointer __i = __base::__map_.begin();
__i != __base::__map_.end(); ++__i)
__buf.push_back(*__i);
_STD::swap(__base::__map_.__first_, __buf.__first_);
_STD::swap(__base::__map_.__begin_, __buf.__begin_);
_STD::swap(__base::__map_.__end_, __buf.__end_);
_STD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
_VSTD::swap(__base::__map_.__first_, __buf.__first_);
_VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
_VSTD::swap(__base::__map_.__end_, __buf.__end_);
_VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
__base::__start_ += __ds;
}
}
@@ -2388,10 +2400,10 @@ deque<_Tp, _Allocator>::__add_back_capacity()
for (typename __base::__map_pointer __i = __base::__map_.end();
__i != __base::__map_.begin();)
__buf.push_front(*--__i);
_STD::swap(__base::__map_.__first_, __buf.__first_);
_STD::swap(__base::__map_.__begin_, __buf.__begin_);
_STD::swap(__base::__map_.__end_, __buf.__end_);
_STD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
_VSTD::swap(__base::__map_.__first_, __buf.__first_);
_VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
_VSTD::swap(__base::__map_.__end_, __buf.__end_);
_VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
}
}
@@ -2405,7 +2417,7 @@ deque<_Tp, _Allocator>::__add_back_capacity(size_type __n)
size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
// Number of unused blocks at front:
size_type __front_capacity = __front_spare() / __base::__block_size;
__front_capacity = _STD::min(__front_capacity, __nb); // don't take more than you need
__front_capacity = _VSTD::min(__front_capacity, __nb); // don't take more than you need
__nb -= __front_capacity; // number of blocks need to allocate
// If __nb == 0, then we have sufficient capacity.
if (__nb == 0)
@@ -2474,10 +2486,10 @@ deque<_Tp, _Allocator>::__add_back_capacity(size_type __n)
for (typename __base::__map_pointer __i = __base::__map_.end();
__i != __base::__map_.begin();)
__buf.push_front(*--__i);
_STD::swap(__base::__map_.__first_, __buf.__first_);
_STD::swap(__base::__map_.__begin_, __buf.__begin_);
_STD::swap(__base::__map_.__end_, __buf.__end_);
_STD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
_VSTD::swap(__base::__map_.__first_, __buf.__first_);
_VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
_VSTD::swap(__base::__map_.__end_, __buf.__end_);
_VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
__base::__start_ -= __ds;
}
}
@@ -2525,7 +2537,7 @@ deque<_Tp, _Allocator>::__move_and_check(iterator __f, iterator __l, iterator __
{
// as if
// for (; __f != __l; ++__f, ++__r)
// *__r = _STD::move(*__f);
// *__r = _VSTD::move(*__f);
difference_type __n = __l - __f;
while (__n > 0)
{
@@ -2539,7 +2551,7 @@ deque<_Tp, _Allocator>::__move_and_check(iterator __f, iterator __l, iterator __
}
if (__fb <= __vt && __vt < __fe)
__vt = (const_iterator(__f.__m_iter_, __vt) -= __f - __r).__ptr_;
__r = _STD::move(__fb, __fe, __r);
__r = _VSTD::move(__fb, __fe, __r);
__n -= __bs;
__f += __bs;
}
@@ -2555,7 +2567,7 @@ deque<_Tp, _Allocator>::__move_backward_and_check(iterator __f, iterator __l, it
{
// as if
// while (__f != __l)
// *--__r = _STD::move(*--__l);
// *--__r = _VSTD::move(*--__l);
difference_type __n = __l - __f;
while (__n > 0)
{
@@ -2570,7 +2582,7 @@ deque<_Tp, _Allocator>::__move_backward_and_check(iterator __f, iterator __l, it
}
if (__lb <= __vt && __vt < __le)
__vt = (const_iterator(__l.__m_iter_, __vt) += __r - __l - 1).__ptr_;
__r = _STD::move_backward(__lb, __le, __r);
__r = _VSTD::move_backward(__lb, __le, __r);
__n -= __bs;
__l -= __bs - 1;
}
@@ -2587,7 +2599,7 @@ deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l,
allocator_type& __a = __base::__alloc();
// as if
// for (; __f != __l; ++__r, ++__f, ++__base::size())
// __alloc_traits::construct(__a, _STD::addressof(*__r), _STD::move(*__f));
// __alloc_traits::construct(__a, _VSTD::addressof(*__r), _VSTD::move(*__f));
difference_type __n = __l - __f;
while (__n > 0)
{
@@ -2602,7 +2614,7 @@ deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l,
if (__fb <= __vt && __vt < __fe)
__vt = (const_iterator(__f.__m_iter_, __vt) += __r - __f).__ptr_;
for (; __fb != __fe; ++__fb, ++__r, ++__base::size())
__alloc_traits::construct(__a, _STD::addressof(*__r), _STD::move(*__fb));
__alloc_traits::construct(__a, _VSTD::addressof(*__r), _VSTD::move(*__fb));
__n -= __bs;
__f += __bs;
}
@@ -2619,7 +2631,7 @@ deque<_Tp, _Allocator>::__move_construct_backward_and_check(iterator __f, iterat
// as if
// for (iterator __j = __l; __j != __f;)
// {
// __alloc_traitsconstruct(__a, _STD::addressof(*--__r), _STD::move(*--__j));
// __alloc_traitsconstruct(__a, _VSTD::addressof(*--__r), _VSTD::move(*--__j));
// --__base::__start_;
// ++__base::size();
// }
@@ -2639,7 +2651,7 @@ deque<_Tp, _Allocator>::__move_construct_backward_and_check(iterator __f, iterat
__vt = (const_iterator(__l.__m_iter_, __vt) -= __l - __r + 1).__ptr_;
while (__le != __lb)
{
__alloc_traits::construct(__a, _STD::addressof(*--__r), _STD::move(*--__le));
__alloc_traits::construct(__a, _VSTD::addressof(*--__r), _VSTD::move(*--__le));
--__base::__start_;
++__base::size();
}
@@ -2659,8 +2671,8 @@ deque<_Tp, _Allocator>::erase(const_iterator __f)
allocator_type& __a = __base::__alloc();
if (__pos < (__base::size() - 1) / 2)
{ // erase from front
_STD::move_backward(__b, __p, _STD::next(__p));
__alloc_traits::destroy(__a, _STD::addressof(*__b));
_VSTD::move_backward(__b, __p, _VSTD::next(__p));
__alloc_traits::destroy(__a, _VSTD::addressof(*__b));
--__base::size();
++__base::__start_;
if (__front_spare() >= 2 * __base::__block_size)
@@ -2672,8 +2684,8 @@ deque<_Tp, _Allocator>::erase(const_iterator __f)
}
else
{ // erase from back
iterator __i = _STD::move(_STD::next(__p), __base::end(), __p);
__alloc_traits::destroy(__a, _STD::addressof(*__i));
iterator __i = _VSTD::move(_VSTD::next(__p), __base::end(), __p);
__alloc_traits::destroy(__a, _VSTD::addressof(*__i));
--__base::size();
if (__back_spare() >= 2 * __base::__block_size)
{
@@ -2697,9 +2709,9 @@ deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)
allocator_type& __a = __base::__alloc();
if (__pos < (__base::size() - __n) / 2)
{ // erase from front
iterator __i = _STD::move_backward(__b, __p, __p + __n);
iterator __i = _VSTD::move_backward(__b, __p, __p + __n);
for (; __b != __i; ++__b)
__alloc_traits::destroy(__a, _STD::addressof(*__b));
__alloc_traits::destroy(__a, _VSTD::addressof(*__b));
__base::size() -= __n;
__base::__start_ += __n;
while (__front_spare() >= 2 * __base::__block_size)
@@ -2711,9 +2723,9 @@ deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)
}
else
{ // erase from back
iterator __i = _STD::move(__p + __n, __base::end(), __p);
iterator __i = _VSTD::move(__p + __n, __base::end(), __p);
for (iterator __e = __base::end(); __i != __e; ++__i)
__alloc_traits::destroy(__a, _STD::addressof(*__i));
__alloc_traits::destroy(__a, _VSTD::addressof(*__i));
__base::size() -= __n;
while (__back_spare() >= 2 * __base::__block_size)
{
@@ -2737,7 +2749,7 @@ deque<_Tp, _Allocator>::__erase_to_end(const_iterator __f)
iterator __b = __base::begin();
difference_type __pos = __f - __b;
for (iterator __p = __b + __pos; __p != __e; ++__p)
__alloc_traits::destroy(__a, _STD::addressof(*__p));
__alloc_traits::destroy(__a, _VSTD::addressof(*__p));
__base::size() -= __n;
while (__back_spare() >= 2 * __base::__block_size)
{
@@ -2771,7 +2783,7 @@ bool
operator==(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
{
const typename deque<_Tp, _Allocator>::size_type __sz = __x.size();
return __sz == __y.size() && _STD::equal(__x.begin(), __x.end(), __y.begin());
return __sz == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
}
template <class _Tp, class _Allocator>
@@ -2787,7 +2799,7 @@ _LIBCPP_INLINE_VISIBILITY inline
bool
operator< (const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
{
return _STD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
}
template <class _Tp, class _Allocator>

View File

@@ -199,7 +199,7 @@ throw_with_nested (_Tp& __t, typename enable_if<
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
#ifndef _LIBCPP_NO_EXCEPTIONS
throw __nested<typename remove_reference<_Tp>::type>(_STD::forward<_Tp>(__t));
throw __nested<typename remove_reference<_Tp>::type>(_VSTD::forward<_Tp>(__t));
#endif
}
@@ -218,7 +218,7 @@ throw_with_nested (_Tp& __t, typename enable_if<
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
#ifndef _LIBCPP_NO_EXCEPTIONS
throw _STD::forward<_Tp>(__t);
throw _VSTD::forward<_Tp>(__t);
#endif
}

46
include/ext/__hash Normal file
View File

@@ -0,0 +1,46 @@
// -*- 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

View File

@@ -203,8 +203,11 @@ 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
@@ -341,9 +344,9 @@ public:
void operator()(pointer __p)
{
if (__second_constructed)
__alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.second));
__alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.second));
if (__first_constructed)
__alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.first));
__alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.first));
if (__p)
__alloc_traits::deallocate(__na_, __p, 1);
}
@@ -466,6 +469,7 @@ 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;
@@ -549,6 +553,8 @@ 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);
@@ -666,11 +672,11 @@ 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), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_.first), __k);
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), __k);
__h.get_deleter().__first_constructed = true;
__node_traits::construct(__na, _STD::addressof(__h->__value_.second));
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
__h.get_deleter().__second_constructed = true;
return _STD::move(__h);
return _VSTD::move(__h);
}
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
@@ -742,6 +748,7 @@ 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;
@@ -823,6 +830,8 @@ 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);
@@ -963,9 +972,9 @@ operator==(const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
{
_EqRng __xeq = __x.equal_range(__i->first);
_EqRng __yeq = __y.equal_range(__i->first);
if (_STD::distance(__xeq.first, __xeq.second) !=
_STD::distance(__yeq.first, __yeq.second) ||
!_STD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
if (_VSTD::distance(__xeq.first, __xeq.second) !=
_VSTD::distance(__yeq.first, __yeq.second) ||
!_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
return false;
__i = __xeq.second;
}

View File

@@ -196,14 +196,17 @@ 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 = std::hash<_Value>, class _Pred = equal_to<_Value>,
template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
class _Alloc = allocator<_Value> >
class _LIBCPP_VISIBLE hash_set
{
@@ -272,6 +275,8 @@ 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);
@@ -490,6 +495,8 @@ 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);
@@ -627,9 +634,9 @@ operator==(const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
{
_EqRng __xeq = __x.equal_range(*__i);
_EqRng __yeq = __y.equal_range(*__i);
if (_STD::distance(__xeq.first, __xeq.second) !=
_STD::distance(__yeq.first, __yeq.second) ||
!_STD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
if (_VSTD::distance(__xeq.first, __xeq.second) !=
_VSTD::distance(__yeq.first, __yeq.second) ||
!_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
return false;
__i = __xeq.second;
}

View File

@@ -178,7 +178,7 @@ template <class T, class Allocator>
_LIBCPP_BEGIN_NAMESPACE_STD
template <class, class> struct __forward_list_node;
template <class _Tp, class _VoidPtr> struct __forward_list_node;
template <class _NodePtr>
struct __forward_begin_node
@@ -208,8 +208,8 @@ struct __forward_list_node
value_type __value_;
};
template<class, class> class forward_list;
template<class> class __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
@@ -446,7 +446,7 @@ private:
_LIBCPP_INLINE_VISIBILITY
void __move_assign_alloc(__forward_list_base& __x, true_type)
_NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
{__alloc() = _STD::move(__x.__alloc());}
{__alloc() = _VSTD::move(__x.__alloc());}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(__node_allocator& __x, __node_allocator& __y)
@@ -464,7 +464,7 @@ private:
true_type)
_NOEXCEPT_(__is_nothrow_swappable<__node_allocator>::value)
{
using _STD::swap;
using _VSTD::swap;
swap(__x, __y);
}
};
@@ -475,7 +475,7 @@ template <class _Tp, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
__forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x)
_NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value)
: __before_begin_(_STD::move(__x.__before_begin_))
: __before_begin_(_VSTD::move(__x.__before_begin_))
{
__x.__before_begin()->__next_ = nullptr;
}
@@ -509,7 +509,7 @@ __forward_list_base<_Tp, _Alloc>::swap(__forward_list_base& __x)
__is_nothrow_swappable<__node_allocator>::value)
{
__swap_alloc(__alloc(), __x.__alloc());
using _STD::swap;
using _VSTD::swap;
swap(__before_begin()->__next_, __x.__before_begin()->__next_);
}
@@ -521,7 +521,7 @@ __forward_list_base<_Tp, _Alloc>::clear() _NOEXCEPT
for (__node_pointer __p = __before_begin()->__next_; __p != nullptr;)
{
__node_pointer __next = __p->__next_;
__node_traits::destroy(__a, _STD::addressof(__p->__value_));
__node_traits::destroy(__a, _VSTD::addressof(__p->__value_));
__node_traits::deallocate(__a, __p, 1);
__p = __next;
}
@@ -577,11 +577,13 @@ public:
_LIBCPP_INLINE_VISIBILITY
forward_list(forward_list&& __x)
_NOEXCEPT_(is_nothrow_move_constructible<base>::value)
: base(_STD::move(__x)) {}
: 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;
@@ -592,7 +594,9 @@ 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
@@ -602,7 +606,9 @@ 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
@@ -677,8 +683,10 @@ 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);
@@ -718,7 +726,7 @@ public:
template <class _Compare>
_LIBCPP_INLINE_VISIBILITY
void merge(forward_list&& __x, _Compare __comp)
{merge(__x, _STD::move(__comp));}
{merge(__x, _VSTD::move(__comp));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
void merge(forward_list& __x) {merge(__x, __less<value_type>());}
@@ -766,7 +774,7 @@ forward_list<_Tp, _Alloc>::forward_list(size_type __n)
__p = __p->__next_)
{
__h.reset(__node_traits::allocate(__a, 1));
__node_traits::construct(__a, _STD::addressof(__h->__value_));
__node_traits::construct(__a, _VSTD::addressof(__h->__value_));
__h->__next_ = nullptr;
__p->__next_ = __h.release();
}
@@ -832,7 +840,7 @@ forward_list<_Tp, _Alloc>::forward_list(const forward_list& __x,
template <class _Tp, class _Alloc>
forward_list<_Tp, _Alloc>::forward_list(forward_list&& __x,
const allocator_type& __a)
: base(_STD::move(__x), __a)
: base(_VSTD::move(__x), __a)
{
if (base::__alloc() != __x.__alloc())
{
@@ -843,6 +851,8 @@ forward_list<_Tp, _Alloc>::forward_list(forward_list&& __x,
#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)
{
@@ -857,6 +867,8 @@ 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)
@@ -910,6 +922,8 @@ 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>&
@@ -919,6 +933,8 @@ 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
@@ -929,7 +945,7 @@ typename enable_if
forward_list<_Tp, _Alloc>::assign(_InputIterator __f, _InputIterator __l)
{
iterator __i = before_begin();
iterator __j = _STD::next(__i);
iterator __j = _VSTD::next(__i);
iterator __e = end();
for (; __j != __e && __f != __l; ++__i, ++__j, ++__f)
*__j = *__f;
@@ -944,7 +960,7 @@ void
forward_list<_Tp, _Alloc>::assign(size_type __n, const value_type& __v)
{
iterator __i = before_begin();
iterator __j = _STD::next(__i);
iterator __j = _VSTD::next(__i);
iterator __e = end();
for (; __j != __e && __n > 0; --__n, ++__i, ++__j)
*__j = __v;
@@ -954,6 +970,8 @@ 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
@@ -962,6 +980,8 @@ 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
@@ -973,8 +993,8 @@ forward_list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
__node_allocator& __a = base::__alloc();
typedef __allocator_destructor<__node_allocator> _D;
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
__node_traits::construct(__a, _STD::addressof(__h->__value_),
_STD::forward<_Args>(__args)...);
__node_traits::construct(__a, _VSTD::addressof(__h->__value_),
_VSTD::forward<_Args>(__args)...);
__h->__next_ = base::__before_begin()->__next_;
base::__before_begin()->__next_ = __h.release();
}
@@ -988,7 +1008,7 @@ forward_list<_Tp, _Alloc>::push_front(value_type&& __v)
__node_allocator& __a = base::__alloc();
typedef __allocator_destructor<__node_allocator> _D;
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
__node_traits::construct(__a, _STD::addressof(__h->__value_), _STD::move(__v));
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
__h->__next_ = base::__before_begin()->__next_;
base::__before_begin()->__next_ = __h.release();
}
@@ -1002,7 +1022,7 @@ forward_list<_Tp, _Alloc>::push_front(const value_type& __v)
__node_allocator& __a = base::__alloc();
typedef __allocator_destructor<__node_allocator> _D;
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
__node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
__h->__next_ = base::__before_begin()->__next_;
base::__before_begin()->__next_ = __h.release();
}
@@ -1014,7 +1034,7 @@ forward_list<_Tp, _Alloc>::pop_front()
__node_allocator& __a = base::__alloc();
__node_pointer __p = base::__before_begin()->__next_;
base::__before_begin()->__next_ = __p->__next_;
__node_traits::destroy(__a, _STD::addressof(__p->__value_));
__node_traits::destroy(__a, _VSTD::addressof(__p->__value_));
__node_traits::deallocate(__a, __p, 1);
}
@@ -1030,8 +1050,8 @@ forward_list<_Tp, _Alloc>::emplace_after(const_iterator __p, _Args&&... __args)
__node_allocator& __a = base::__alloc();
typedef __allocator_destructor<__node_allocator> _D;
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
__node_traits::construct(__a, _STD::addressof(__h->__value_),
_STD::forward<_Args>(__args)...);
__node_traits::construct(__a, _VSTD::addressof(__h->__value_),
_VSTD::forward<_Args>(__args)...);
__h->__next_ = __r->__next_;
__r->__next_ = __h.release();
return iterator(__r->__next_);
@@ -1047,7 +1067,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, value_type&& __v)
__node_allocator& __a = base::__alloc();
typedef __allocator_destructor<__node_allocator> _D;
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
__node_traits::construct(__a, _STD::addressof(__h->__value_), _STD::move(__v));
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
__h->__next_ = __r->__next_;
__r->__next_ = __h.release();
return iterator(__r->__next_);
@@ -1063,7 +1083,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, const value_type& __
__node_allocator& __a = base::__alloc();
typedef __allocator_destructor<__node_allocator> _D;
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
__node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
__h->__next_ = __r->__next_;
__r->__next_ = __h.release();
return iterator(__r->__next_);
@@ -1080,7 +1100,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
__node_allocator& __a = base::__alloc();
typedef __allocator_destructor<__node_allocator> _D;
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
__node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
__node_pointer __first = __h.release();
__node_pointer __last = __first;
#ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1090,7 +1110,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
for (--__n; __n != 0; --__n, __last = __last->__next_)
{
__h.reset(__node_traits::allocate(__a, 1));
__node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
__last->__next_ = __h.release();
}
#ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1100,7 +1120,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
while (__first != nullptr)
{
__node_pointer __next = __first->__next_;
__node_traits::destroy(__a, _STD::addressof(__first->__value_));
__node_traits::destroy(__a, _VSTD::addressof(__first->__value_));
__node_traits::deallocate(__a, __first, 1);
__first = __next;
}
@@ -1130,7 +1150,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
__node_allocator& __a = base::__alloc();
typedef __allocator_destructor<__node_allocator> _D;
unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
__node_traits::construct(__a, _STD::addressof(__h->__value_), *__f);
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f);
__node_pointer __first = __h.release();
__node_pointer __last = __first;
#ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1140,7 +1160,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
for (++__f; __f != __l; ++__f, __last = __last->__next_)
{
__h.reset(__node_traits::allocate(__a, 1));
__node_traits::construct(__a, _STD::addressof(__h->__value_), *__f);
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f);
__last->__next_ = __h.release();
}
#ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1150,7 +1170,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
while (__first != nullptr)
{
__node_pointer __next = __first->__next_;
__node_traits::destroy(__a, _STD::addressof(__first->__value_));
__node_traits::destroy(__a, _VSTD::addressof(__first->__value_));
__node_traits::deallocate(__a, __first, 1);
__first = __next;
}
@@ -1172,7 +1192,7 @@ forward_list<_Tp, _Alloc>::erase_after(const_iterator __f)
__node_pointer __n = __p->__next_;
__p->__next_ = __n->__next_;
__node_allocator& __a = base::__alloc();
__node_traits::destroy(__a, _STD::addressof(__n->__value_));
__node_traits::destroy(__a, _VSTD::addressof(__n->__value_));
__node_traits::deallocate(__a, __n, 1);
return iterator(__p->__next_);
}
@@ -1193,7 +1213,7 @@ forward_list<_Tp, _Alloc>::erase_after(const_iterator __f, const_iterator __l)
do
{
__p = __n->__next_;
__node_traits::destroy(__a, _STD::addressof(__n->__value_));
__node_traits::destroy(__a, _VSTD::addressof(__n->__value_));
__node_traits::deallocate(__a, __n, 1);
__n = __p;
} while (__n != __e);
@@ -1226,7 +1246,7 @@ forward_list<_Tp, _Alloc>::resize(size_type __n)
__ptr = __ptr->__next_)
{
__h.reset(__node_traits::allocate(__a, 1));
__node_traits::construct(__a, _STD::addressof(__h->__value_));
__node_traits::construct(__a, _VSTD::addressof(__h->__value_));
__h->__next_ = nullptr;
__ptr->__next_ = __h.release();
}
@@ -1258,7 +1278,7 @@ forward_list<_Tp, _Alloc>::resize(size_type __n, const value_type& __v)
__ptr = __ptr->__next_)
{
__h.reset(__node_traits::allocate(__a, 1));
__node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
__node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
__h->__next_ = nullptr;
__ptr->__next_ = __h.release();
}
@@ -1293,7 +1313,7 @@ forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
forward_list& __x,
const_iterator __i)
{
const_iterator __lm1 = _STD::next(__i);
const_iterator __lm1 = _VSTD::next(__i);
if (__p != __i && __p != __lm1)
{
const_cast<__node_pointer>(__i.__ptr_)->__next_ =
@@ -1370,7 +1390,7 @@ forward_list<_Tp, _Alloc>::remove(const value_type& __v)
{
if (__i.__ptr_->__next_->__value_ == __v)
{
iterator __j = _STD::next(__i, 2);
iterator __j = _VSTD::next(__i, 2);
for (; __j != __e && *__j == __v; ++__j)
;
erase_after(__i, __j);
@@ -1393,7 +1413,7 @@ forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred)
{
if (__pred(__i.__ptr_->__next_->__value_))
{
iterator __j = _STD::next(__i, 2);
iterator __j = _VSTD::next(__i, 2);
for (; __j != __e && __pred(*__j); ++__j)
;
erase_after(__i, __j);
@@ -1413,7 +1433,7 @@ forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
{
for (iterator __i = begin(), __e = end(); __i != __e;)
{
iterator __j = _STD::next(__i);
iterator __j = _VSTD::next(__i);
for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
;
if (__i.__ptr_->__next_ != __j.__ptr_)
@@ -1488,7 +1508,7 @@ void
forward_list<_Tp, _Alloc>::sort(_Compare __comp)
{
base::__before_begin()->__next_ = __sort(base::__before_begin()->__next_,
_STD::distance(begin(), end()), __comp);
_VSTD::distance(begin(), end()), __comp);
}
template <class _Tp, class _Alloc>
@@ -1514,7 +1534,7 @@ forward_list<_Tp, _Alloc>::__sort(__node_pointer __f1, difference_type __sz,
}
difference_type __sz1 = __sz / 2;
difference_type __sz2 = __sz - __sz1;
__node_pointer __t = _STD::next(iterator(__f1), __sz1 - 1).__ptr_;
__node_pointer __t = _VSTD::next(iterator(__f1), __sz1 - 1).__ptr_;
__node_pointer __f2 = __t->__next_;
__t->__next_ = nullptr;
return __merge(__sort(__f1, __sz1, __comp),
@@ -1570,7 +1590,7 @@ inline _LIBCPP_INLINE_VISIBILITY
bool operator< (const forward_list<_Tp, _Alloc>& __x,
const forward_list<_Tp, _Alloc>& __y)
{
return _STD::lexicographical_compare(__x.begin(), __x.end(),
return _VSTD::lexicographical_compare(__x.begin(), __x.end(),
__y.begin(), __y.end());
}

View File

@@ -362,9 +362,9 @@ basic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs)
basic_streambuf<char_type, traits_type>::swap(__rhs);
if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_)
{
_STD::swap(__extbuf_, __rhs.__extbuf_);
_STD::swap(__extbufnext_, __rhs.__extbufnext_);
_STD::swap(__extbufend_, __rhs.__extbufend_);
_VSTD::swap(__extbuf_, __rhs.__extbuf_);
_VSTD::swap(__extbufnext_, __rhs.__extbufnext_);
_VSTD::swap(__extbufend_, __rhs.__extbufend_);
}
else
{
@@ -387,17 +387,17 @@ basic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs)
__rhs.__extbufnext_ = __rhs.__extbuf_ + __ln;
__rhs.__extbufend_ = __rhs.__extbuf_ + __le;
}
_STD::swap(__ebs_, __rhs.__ebs_);
_STD::swap(__intbuf_, __rhs.__intbuf_);
_STD::swap(__ibs_, __rhs.__ibs_);
_STD::swap(__file_, __rhs.__file_);
_STD::swap(__cv_, __rhs.__cv_);
_STD::swap(__st_, __rhs.__st_);
_STD::swap(__om_, __rhs.__om_);
_STD::swap(__cm_, __rhs.__cm_);
_STD::swap(__owns_eb_, __rhs.__owns_eb_);
_STD::swap(__owns_ib_, __rhs.__owns_ib_);
_STD::swap(__always_noconv_, __rhs.__always_noconv_);
_VSTD::swap(__ebs_, __rhs.__ebs_);
_VSTD::swap(__intbuf_, __rhs.__intbuf_);
_VSTD::swap(__ibs_, __rhs.__ibs_);
_VSTD::swap(__file_, __rhs.__file_);
_VSTD::swap(__cv_, __rhs.__cv_);
_VSTD::swap(__st_, __rhs.__st_);
_VSTD::swap(__om_, __rhs.__om_);
_VSTD::swap(__cm_, __rhs.__cm_);
_VSTD::swap(__owns_eb_, __rhs.__owns_eb_);
_VSTD::swap(__owns_ib_, __rhs.__owns_ib_);
_VSTD::swap(__always_noconv_, __rhs.__always_noconv_);
if (this->eback() == (char_type*)__rhs.__extbuf_min_)
{
ptrdiff_t __n = this->gptr() - this->eback();
@@ -587,7 +587,7 @@ 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 = _STD::min(static_cast<size_t>(this->egptr() - this->eback() - __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;
state_type __svs = __st_;
@@ -1019,8 +1019,8 @@ basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::ope
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
basic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs)
: basic_istream<char_type, traits_type>(_STD::move(__rhs)),
__sb_(_STD::move(__rhs.__sb_))
: basic_istream<char_type, traits_type>(_VSTD::move(__rhs)),
__sb_(_VSTD::move(__rhs.__sb_))
{
this->set_rdbuf(&__sb_);
}
@@ -1030,8 +1030,8 @@ inline _LIBCPP_INLINE_VISIBILITY
basic_ifstream<_CharT, _Traits>&
basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs)
{
basic_istream<char_type, traits_type>::operator=(_STD::move(__rhs));
__sb_ = _STD::move(__rhs.__sb_);
basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
__sb_ = _VSTD::move(__rhs.__sb_);
return *this;
}
@@ -1164,8 +1164,8 @@ basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::ope
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
basic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs)
: basic_ostream<char_type, traits_type>(_STD::move(__rhs)),
__sb_(_STD::move(__rhs.__sb_))
: basic_ostream<char_type, traits_type>(_VSTD::move(__rhs)),
__sb_(_VSTD::move(__rhs.__sb_))
{
this->set_rdbuf(&__sb_);
}
@@ -1175,8 +1175,8 @@ inline _LIBCPP_INLINE_VISIBILITY
basic_ofstream<_CharT, _Traits>&
basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs)
{
basic_ostream<char_type, traits_type>::operator=(_STD::move(__rhs));
__sb_ = _STD::move(__rhs.__sb_);
basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
__sb_ = _VSTD::move(__rhs.__sb_);
return *this;
}
@@ -1309,8 +1309,8 @@ basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openm
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
basic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs)
: basic_iostream<char_type, traits_type>(_STD::move(__rhs)),
__sb_(_STD::move(__rhs.__sb_))
: basic_iostream<char_type, traits_type>(_VSTD::move(__rhs)),
__sb_(_VSTD::move(__rhs.__sb_))
{
this->set_rdbuf(&__sb_);
}
@@ -1320,8 +1320,8 @@ inline _LIBCPP_INLINE_VISIBILITY
basic_fstream<_CharT, _Traits>&
basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs)
{
basic_iostream<char_type, traits_type>::operator=(_STD::move(__rhs));
__sb_ = _STD::move(__rhs.__sb_);
basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
__sb_ = _VSTD::move(__rhs.__sb_);
return *this;
}

View File

@@ -884,7 +884,7 @@ public:
typename __invoke_return<type, _ArgTypes...>::type
operator() (_ArgTypes&&... __args)
{
return __invoke(__f_, _STD::forward<_ArgTypes>(__args)...);
return __invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...);
}
};
@@ -992,9 +992,9 @@ class __func<_F, _Alloc, _R(_ArgTypes...)>
__compressed_pair<_F, _Alloc> __f_;
public:
_LIBCPP_INLINE_VISIBILITY
explicit __func(_F __f) : __f_(_STD::move(__f)) {}
explicit __func(_F __f) : __f_(_VSTD::move(__f)) {}
_LIBCPP_INLINE_VISIBILITY
explicit __func(_F __f, _Alloc __a) : __f_(_STD::move(__f), _STD::move(__a)) {}
explicit __func(_F __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
virtual __base<_R(_ArgTypes...)>* __clone() const;
virtual void __clone(__base<_R(_ArgTypes...)>*) const;
virtual void destroy() _NOEXCEPT;
@@ -1046,7 +1046,7 @@ template<class _F, class _Alloc, class _R, class ..._ArgTypes>
_R
__func<_F, _Alloc, _R(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
{
return __invoke(__f_.first(), _STD::forward<_ArgTypes>(__arg)...);
return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
}
#ifndef _LIBCPP_NO_RTTI
@@ -1162,7 +1162,7 @@ public:
template<class _F, class _Alloc>
_LIBCPP_INLINE_VISIBILITY
void assign(_F&& __f, const _Alloc& __a)
{function(allocator_arg, __a, _STD::forward<_F>(__f)).swap(*this);}
{function(allocator_arg, __a, _VSTD::forward<_F>(__f)).swap(*this);}
// function capacity:
_LIBCPP_INLINE_VISIBILITY
@@ -1263,7 +1263,7 @@ function<_R(_ArgTypes...)>::function(_F __f,
if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_F>::value)
{
__f_ = (__base*)&__buf_;
::new (__f_) _FF(_STD::move(__f));
::new (__f_) _FF(_VSTD::move(__f));
}
else
{
@@ -1271,7 +1271,7 @@ function<_R(_ArgTypes...)>::function(_F __f,
_A __a;
typedef __allocator_destructor<_A> _D;
unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
::new (__hold.get()) _FF(_STD::move(__f), allocator<_F>(__a));
::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_F>(__a));
__f_ = __hold.release();
}
}
@@ -1290,7 +1290,7 @@ function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _F __f
if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_F>::value)
{
__f_ = (__base*)&__buf_;
::new (__f_) _FF(_STD::move(__f));
::new (__f_) _FF(_VSTD::move(__f));
}
else
{
@@ -1304,7 +1304,7 @@ function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _F __f
_A __a(__a0);
typedef __allocator_destructor<_A> _D;
unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
::new (__hold.get()) _FF(_STD::move(__f), _Alloc(__a));
::new (__hold.get()) _FF(_VSTD::move(__f), _Alloc(__a));
__f_ = __hold.release();
}
}
@@ -1361,7 +1361,7 @@ typename enable_if
>::type
function<_R(_ArgTypes...)>::operator=(_F&& __f)
{
function(_STD::forward<_F>(__f)).swap(*this);
function(_VSTD::forward<_F>(__f)).swap(*this);
return *this;
}
@@ -1408,7 +1408,7 @@ function<_R(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
__f_ = (__base*)&__buf_;
}
else
_STD::swap(__f_, __f.__f_);
_VSTD::swap(__f_, __f.__f_);
}
template<class _R, class ..._ArgTypes>
@@ -1419,7 +1419,7 @@ function<_R(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
if (__f_ == 0)
throw bad_function_call();
#endif // _LIBCPP_NO_EXCEPTIONS
return (*__f_)(_STD::forward<_ArgTypes>(__arg)...);
return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
}
#ifndef _LIBCPP_NO_RTTI
@@ -1524,7 +1524,7 @@ inline _LIBCPP_INLINE_VISIBILITY
typename __invoke_of<_Ti&, _Uj...>::type
__mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
{
return __ti(_STD::forward<_Uj>(get<_Indx>(__uj))...);
return __ti(_VSTD::forward<_Uj>(get<_Indx>(__uj))...);
}
template <class _Ti, class ..._Uj>
@@ -1559,7 +1559,7 @@ typename enable_if
__mu(_Ti&, _Uj& __uj)
{
const size_t _Indx = is_placeholder<_Ti>::value - 1;
return _STD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
}
template <class _Ti, class _Uj>
@@ -1666,16 +1666,41 @@ class __bind
typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
public:
#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
_LIBCPP_INLINE_VISIBILITY
__bind(const __bind& __b)
: __f_(__b.__f_),
__bound_args_(__b.__bound_args_) {}
_LIBCPP_INLINE_VISIBILITY
__bind& operator=(const __bind& __b)
{
__f_ = __b.__f_;
__bound_args_ = __b.__bound_args_;
return *this;
}
_LIBCPP_INLINE_VISIBILITY
__bind(__bind&& __b)
: __f_(_STD::move(__b.__f_)),
__bound_args_(_STD::move(__b.__bound_args_)) {}
: __f_(_VSTD::move(__b.__f_)),
__bound_args_(_VSTD::move(__b.__bound_args_)) {}
_LIBCPP_INLINE_VISIBILITY
__bind& operator=(__bind&& __b)
{
__f_ = _VSTD::move(__b.__f_);
__bound_args_ = _VSTD::move(__b.__bound_args_);
return *this;
}
#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
template <class _G, class ..._BA>
_LIBCPP_INLINE_VISIBILITY
explicit __bind(_G&& __f, _BA&& ...__bound_args)
: __f_(_STD::forward<_G>(__f)),
__bound_args_(_STD::forward<_BA>(__bound_args)...) {}
: __f_(_VSTD::forward<_G>(__f)),
__bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
template <class ..._Args>
_LIBCPP_INLINE_VISIBILITY
@@ -1683,7 +1708,7 @@ public:
operator()(_Args&& ...__args)
{
return __apply_functor(__f_, __bound_args_, __indices(),
tuple<_Args&&...>(_STD::forward<_Args>(__args)...));
tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
}
template <class ..._Args>
@@ -1692,7 +1717,7 @@ public:
operator()(_Args&& ...__args) const
{
return __apply_functor(__f_, __bound_args_, __indices(),
tuple<_Args&&...>(_STD::forward<_Args>(__args)...));
tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
}
};
@@ -1707,22 +1732,44 @@ class __bind_r
public:
typedef _R result_type;
#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
_LIBCPP_INLINE_VISIBILITY
__bind_r(const __bind_r& __b)
: base(_VSTD::forward<const base&>(__b)) {}
_LIBCPP_INLINE_VISIBILITY
__bind_r& operator=(const __bind_r& __b)
{
base::operator=(_VSTD::forward<const base&>(__b));
return *this;
}
_LIBCPP_INLINE_VISIBILITY
__bind_r(__bind_r&& __b)
: base(_STD::forward<base>(__b)) {}
: base(_VSTD::forward<base>(__b)) {}
_LIBCPP_INLINE_VISIBILITY
__bind_r& operator=(__bind_r&& __b)
{
base::operator=(_VSTD::forward<base>(__b));
return *this;
}
#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
template <class _G, class ..._BA>
_LIBCPP_INLINE_VISIBILITY
explicit __bind_r(_G&& __f, _BA&& ...__bound_args)
: base(_STD::forward<_G>(__f),
_STD::forward<_BA>(__bound_args)...) {}
: base(_VSTD::forward<_G>(__f),
_VSTD::forward<_BA>(__bound_args)...) {}
template <class ..._Args>
_LIBCPP_INLINE_VISIBILITY
result_type
operator()(_Args&& ...__args)
{
return base::operator()(_STD::forward<_Args>(__args)...);
return base::operator()(_VSTD::forward<_Args>(__args)...);
}
template <class ..._Args>
@@ -1730,7 +1777,7 @@ public:
result_type
operator()(_Args&& ...__args) const
{
return base::operator()(_STD::forward<_Args>(__args)...);
return base::operator()(_VSTD::forward<_Args>(__args)...);
}
};
@@ -1743,7 +1790,7 @@ __bind<_F, _BoundArgs...>
bind(_F&& __f, _BoundArgs&&... __bound_args)
{
typedef __bind<_F, _BoundArgs...> type;
return type(_STD::forward<_F>(__f), _STD::forward<_BoundArgs>(__bound_args)...);
return type(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
}
template<class _R, class _F, class ..._BoundArgs>
@@ -1752,7 +1799,7 @@ __bind_r<_R, _F, _BoundArgs...>
bind(_F&& __f, _BoundArgs&&... __bound_args)
{
typedef __bind_r<_R, _F, _BoundArgs...> type;
return type(_STD::forward<_F>(__f), _STD::forward<_BoundArgs>(__bound_args)...);
return type(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
}
#endif // _LIBCPP_HAS_NO_VARIADICS

View File

@@ -452,6 +452,8 @@ public:
_LIBCPP_INLINE_VISIBILITY
const error_code& code() const throw() {return __ec_;}
virtual ~future_error() _NOEXCEPT;
};
class __assoc_sub_state
@@ -583,9 +585,11 @@ __assoc_state<_R>::set_value(_Arg& __arg)
#endif
{
unique_lock<mutex> __lk(this->__mut_);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (this->__has_value())
throw future_error(make_error_code(future_errc::promise_already_satisfied));
::new(&__value_) _R(_STD::forward<_Arg>(__arg));
#endif
::new(&__value_) _R(_VSTD::forward<_Arg>(__arg));
this->__state_ |= base::__constructed | base::ready;
__lk.unlock();
__cv_.notify_all();
@@ -601,9 +605,11 @@ __assoc_state<_R>::set_value_at_thread_exit(_Arg& __arg)
#endif
{
unique_lock<mutex> __lk(this->__mut_);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (this->__has_value())
throw future_error(make_error_code(future_errc::promise_already_satisfied));
::new(&__value_) _R(_STD::forward<_Arg>(__arg));
#endif
::new(&__value_) _R(_VSTD::forward<_Arg>(__arg));
this->__state_ |= base::__constructed;
__thread_local_data()->__make_ready_at_thread_exit(this);
__lk.unlock();
@@ -617,7 +623,7 @@ __assoc_state<_R>::move()
this->__sub_wait(__lk);
if (this->__exception_ != nullptr)
rethrow_exception(this->__exception_);
return _STD::move(*reinterpret_cast<_R*>(&__value_));
return _VSTD::move(*reinterpret_cast<_R*>(&__value_));
}
template <class _R>
@@ -661,8 +667,10 @@ void
__assoc_state<_R&>::set_value(_R& __arg)
{
unique_lock<mutex> __lk(this->__mut_);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (this->__has_value())
throw future_error(make_error_code(future_errc::promise_already_satisfied));
#endif
__value_ = &__arg;
this->__state_ |= base::__constructed | base::ready;
__lk.unlock();
@@ -674,8 +682,10 @@ void
__assoc_state<_R&>::set_value_at_thread_exit(_R& __arg)
{
unique_lock<mutex> __lk(this->__mut_);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (this->__has_value())
throw future_error(make_error_code(future_errc::promise_already_satisfied));
#endif
__value_ = &__arg;
this->__state_ |= base::__constructed;
__thread_local_data()->__make_ready_at_thread_exit(this);
@@ -786,7 +796,7 @@ public:
template <class _R, class _F>
inline _LIBCPP_INLINE_VISIBILITY
__deferred_assoc_state<_R, _F>::__deferred_assoc_state(_F&& __f)
: __func_(_STD::forward<_F>(__f))
: __func_(_VSTD::forward<_F>(__f))
{
this->__set_deferred();
}
@@ -832,7 +842,7 @@ public:
template <class _F>
inline _LIBCPP_INLINE_VISIBILITY
__deferred_assoc_state<void, _F>::__deferred_assoc_state(_F&& __f)
: __func_(_STD::forward<_F>(__f))
: __func_(_VSTD::forward<_F>(__f))
{
this->__set_deferred();
}
@@ -880,7 +890,7 @@ public:
template <class _R, class _F>
inline _LIBCPP_INLINE_VISIBILITY
__async_assoc_state<_R, _F>::__async_assoc_state(_F&& __f)
: __func_(_STD::forward<_F>(__f))
: __func_(_VSTD::forward<_F>(__f))
{
}
@@ -934,7 +944,7 @@ public:
template <class _F>
inline _LIBCPP_INLINE_VISIBILITY
__async_assoc_state<void, _F>::__async_assoc_state(_F&& __f)
: __func_(_STD::forward<_F>(__f))
: __func_(_VSTD::forward<_F>(__f))
{
}
@@ -967,9 +977,8 @@ __async_assoc_state<void, _F>::__on_zero_shared() _NOEXCEPT
base::__on_zero_shared();
}
template <class> class promise;
template <class> class shared_future;
template <class> class atomic_future;
template <class _R> class promise;
template <class _R> class shared_future;
// future
@@ -1000,7 +1009,6 @@ class _LIBCPP_VISIBLE future
template <class> friend class promise;
template <class> friend class shared_future;
template <class> friend class atomic_future;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _R1, class _F>
@@ -1042,7 +1050,7 @@ public:
_R get();
_LIBCPP_INLINE_VISIBILITY
void swap(future& __rhs) {_STD::swap(__state_, __rhs.__state_);}
void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
// functions to check state
_LIBCPP_INLINE_VISIBILITY
@@ -1066,8 +1074,10 @@ template <class _R>
future<_R>::future(__assoc_state<_R>* __state)
: __state_(__state)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_->__has_future_attached())
throw future_error(make_error_code(future_errc::future_already_retrieved));
#endif
__state_->__add_shared();
__state_->__set_future_attached();
}
@@ -1103,7 +1113,6 @@ class _LIBCPP_VISIBLE future<_R&>
template <class> friend class promise;
template <class> friend class shared_future;
template <class> friend class atomic_future;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _R1, class _F>
@@ -1145,7 +1154,7 @@ public:
_R& get();
_LIBCPP_INLINE_VISIBILITY
void swap(future& __rhs) {_STD::swap(__state_, __rhs.__state_);}
void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
// functions to check state
_LIBCPP_INLINE_VISIBILITY
@@ -1169,8 +1178,10 @@ template <class _R>
future<_R&>::future(__assoc_state<_R&>* __state)
: __state_(__state)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_->__has_future_attached())
throw future_error(make_error_code(future_errc::future_already_retrieved));
#endif
__state_->__add_shared();
__state_->__set_future_attached();
}
@@ -1201,7 +1212,6 @@ class _LIBCPP_VISIBLE future<void>
template <class> friend class promise;
template <class> friend class shared_future;
template <class> friend class atomic_future;
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _R1, class _F>
@@ -1243,7 +1253,7 @@ public:
void get();
_LIBCPP_INLINE_VISIBILITY
void swap(future& __rhs) {_STD::swap(__state_, __rhs.__state_);}
void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
// functions to check state
_LIBCPP_INLINE_VISIBILITY
@@ -1273,7 +1283,7 @@ swap(future<_R>& __x, future<_R>& __y)
// promise<R>
template <class> class packaged_task;
template <class _Callable> class packaged_task;
template <class _R>
class _LIBCPP_VISIBLE promise
@@ -1315,7 +1325,7 @@ private:
public:
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
void swap(promise& __rhs) {_STD::swap(__state_, __rhs.__state_);}
void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
// retrieving the result
future<_R> get_future();
@@ -1370,8 +1380,10 @@ template <class _R>
future<_R>
promise<_R>::get_future()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
return future<_R>(__state_);
}
@@ -1379,8 +1391,10 @@ template <class _R>
void
promise<_R>::set_value(const _R& __r)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
__state_->set_value(__r);
}
@@ -1390,9 +1404,11 @@ template <class _R>
void
promise<_R>::set_value(_R&& __r)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
__state_->set_value(_STD::move(__r));
#endif
__state_->set_value(_VSTD::move(__r));
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1401,8 +1417,10 @@ template <class _R>
void
promise<_R>::set_exception(exception_ptr __p)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
__state_->set_exception(__p);
}
@@ -1410,8 +1428,10 @@ template <class _R>
void
promise<_R>::set_value_at_thread_exit(const _R& __r)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
__state_->set_value_at_thread_exit(__r);
}
@@ -1421,9 +1441,11 @@ template <class _R>
void
promise<_R>::set_value_at_thread_exit(_R&& __r)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
__state_->set_value_at_thread_exit(_STD::move(__r));
#endif
__state_->set_value_at_thread_exit(_VSTD::move(__r));
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1432,8 +1454,10 @@ template <class _R>
void
promise<_R>::set_exception_at_thread_exit(exception_ptr __p)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
__state_->set_exception_at_thread_exit(__p);
}
@@ -1480,7 +1504,7 @@ private:
public:
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
void swap(promise& __rhs) {_STD::swap(__state_, __rhs.__state_);}
void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
// retrieving the result
future<_R&> get_future();
@@ -1529,8 +1553,10 @@ template <class _R>
future<_R&>
promise<_R&>::get_future()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
return future<_R&>(__state_);
}
@@ -1538,8 +1564,10 @@ template <class _R>
void
promise<_R&>::set_value(_R& __r)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
__state_->set_value(__r);
}
@@ -1547,8 +1575,10 @@ template <class _R>
void
promise<_R&>::set_exception(exception_ptr __p)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
__state_->set_exception(__p);
}
@@ -1556,8 +1586,10 @@ template <class _R>
void
promise<_R&>::set_value_at_thread_exit(_R& __r)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
__state_->set_value_at_thread_exit(__r);
}
@@ -1565,8 +1597,10 @@ template <class _R>
void
promise<_R&>::set_exception_at_thread_exit(exception_ptr __p)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
__state_->set_exception_at_thread_exit(__p);
}
@@ -1613,7 +1647,7 @@ private:
public:
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
void swap(promise& __rhs) {_STD::swap(__state_, __rhs.__state_);}
void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
// retrieving the result
future<void> get_future();
@@ -1683,13 +1717,13 @@ public:
_LIBCPP_INLINE_VISIBILITY
explicit __packaged_task_func(const _F& __f) : __f_(__f) {}
_LIBCPP_INLINE_VISIBILITY
explicit __packaged_task_func(_F&& __f) : __f_(_STD::move(__f)) {}
explicit __packaged_task_func(_F&& __f) : __f_(_VSTD::move(__f)) {}
_LIBCPP_INLINE_VISIBILITY
__packaged_task_func(const _F& __f, const _Alloc& __a)
: __f_(__f, __a) {}
_LIBCPP_INLINE_VISIBILITY
__packaged_task_func(_F&& __f, const _Alloc& __a)
: __f_(_STD::move(__f), __a) {}
: __f_(_VSTD::move(__f), __a) {}
virtual void __move_to(__packaged_task_base<_R(_ArgTypes...)>*);
virtual void destroy();
virtual void destroy_deallocate();
@@ -1701,7 +1735,7 @@ void
__packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::__move_to(
__packaged_task_base<_R(_ArgTypes...)>* __p)
{
::new (__p) __packaged_task_func(_STD::move(__f_.first()), _STD::move(__f_.second()));
::new (__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second()));
}
template<class _F, class _Alloc, class _R, class ..._ArgTypes>
@@ -1725,10 +1759,10 @@ template<class _F, class _Alloc, class _R, class ..._ArgTypes>
_R
__packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
{
return __invoke(__f_.first(), _STD::forward<_ArgTypes>(__arg)...);
return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
}
template <class> class __packaged_task_function;
template <class _Callable> class __packaged_task_function;
template<class _R, class ..._ArgTypes>
class __packaged_task_function<_R(_ArgTypes...)>
@@ -1788,7 +1822,7 @@ __packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(_F&& __f)
if (sizeof(_FF) <= sizeof(__buf_))
{
__f_ = (__base*)&__buf_;
::new (__f_) _FF(_STD::forward<_F>(__f));
::new (__f_) _FF(_VSTD::forward<_F>(__f));
}
else
{
@@ -1796,7 +1830,7 @@ __packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(_F&& __f)
_A __a;
typedef __allocator_destructor<_A> _D;
unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
::new (__hold.get()) _FF(_STD::forward<_F>(__f), allocator<_FR>(__a));
::new (__hold.get()) _FF(_VSTD::forward<_F>(__f), allocator<_FR>(__a));
__f_ = __hold.release();
}
}
@@ -1813,7 +1847,7 @@ __packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(
if (sizeof(_FF) <= sizeof(__buf_))
{
__f_ = (__base*)&__buf_;
::new (__f_) _FF(_STD::forward<_F>(__f));
::new (__f_) _FF(_VSTD::forward<_F>(__f));
}
else
{
@@ -1827,7 +1861,7 @@ __packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(
_A __a(__a0);
typedef __allocator_destructor<_A> _D;
unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
::new (__hold.get()) _FF(_STD::forward<_F>(__f), _Alloc(__a));
::new (__hold.get()) _FF(_VSTD::forward<_F>(__f), _Alloc(__a));
__f_ = __hold.release();
}
}
@@ -1898,7 +1932,7 @@ __packaged_task_function<_R(_ArgTypes...)>::swap(__packaged_task_function& __f)
__f_ = (__base*)&__buf_;
}
else
_STD::swap(__f_, __f.__f_);
_VSTD::swap(__f_, __f.__f_);
}
template<class _R, class ..._ArgTypes>
@@ -1906,7 +1940,7 @@ inline _LIBCPP_INLINE_VISIBILITY
_R
__packaged_task_function<_R(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
{
return (*__f_)(_STD::forward<_ArgTypes>(__arg)...);
return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
}
template<class _R, class ..._ArgTypes>
@@ -1925,11 +1959,11 @@ public:
packaged_task() : __p_(nullptr) {}
template <class _F>
_LIBCPP_INLINE_VISIBILITY
explicit packaged_task(_F&& __f) : __f_(_STD::forward<_F>(__f)) {}
explicit packaged_task(_F&& __f) : __f_(_VSTD::forward<_F>(__f)) {}
template <class _F, class _Allocator>
_LIBCPP_INLINE_VISIBILITY
explicit packaged_task(allocator_arg_t, const _Allocator& __a, _F&& __f)
: __f_(allocator_arg, __a, _STD::forward<_F>(__f)),
: __f_(allocator_arg, __a, _VSTD::forward<_F>(__f)),
__p_(allocator_arg, __a) {}
// ~packaged_task() = default;
@@ -1940,12 +1974,12 @@ public:
// move support
_LIBCPP_INLINE_VISIBILITY
packaged_task(packaged_task&& __other)
: __f_(_STD::move(__other.__f_)), __p_(_STD::move(__other.__p_)) {}
: __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
_LIBCPP_INLINE_VISIBILITY
packaged_task& operator=(packaged_task&& __other)
{
__f_ = _STD::move(__other.__f_);
__p_ = _STD::move(__other.__p_);
__f_ = _VSTD::move(__other.__f_);
__p_ = _VSTD::move(__other.__p_);
return *this;
}
_LIBCPP_INLINE_VISIBILITY
@@ -1981,7 +2015,7 @@ packaged_task<_R(_ArgTypes...)>::operator()(_ArgTypes... __args)
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
__p_.set_value(__f_(_STD::forward<_ArgTypes>(__args)...));
__p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...));
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
@@ -2003,7 +2037,7 @@ packaged_task<_R(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
__p_.set_value_at_thread_exit(__f_(_STD::forward<_ArgTypes>(__args)...));
__p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...));
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
@@ -2040,11 +2074,11 @@ public:
packaged_task() : __p_(nullptr) {}
template <class _F>
_LIBCPP_INLINE_VISIBILITY
explicit packaged_task(_F&& __f) : __f_(_STD::forward<_F>(__f)) {}
explicit packaged_task(_F&& __f) : __f_(_VSTD::forward<_F>(__f)) {}
template <class _F, class _Allocator>
_LIBCPP_INLINE_VISIBILITY
explicit packaged_task(allocator_arg_t, const _Allocator& __a, _F&& __f)
: __f_(allocator_arg, __a, _STD::forward<_F>(__f)),
: __f_(allocator_arg, __a, _VSTD::forward<_F>(__f)),
__p_(allocator_arg, __a) {}
// ~packaged_task() = default;
@@ -2055,12 +2089,12 @@ public:
// move support
_LIBCPP_INLINE_VISIBILITY
packaged_task(packaged_task&& __other)
: __f_(_STD::move(__other.__f_)), __p_(_STD::move(__other.__p_)) {}
: __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
_LIBCPP_INLINE_VISIBILITY
packaged_task& operator=(packaged_task&& __other)
{
__f_ = _STD::move(__other.__f_);
__p_ = _STD::move(__other.__p_);
__f_ = _VSTD::move(__other.__f_);
__p_ = _VSTD::move(__other.__p_);
return *this;
}
_LIBCPP_INLINE_VISIBILITY
@@ -2096,7 +2130,7 @@ packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args)
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
__f_(_STD::forward<_ArgTypes>(__args)...);
__f_(_VSTD::forward<_ArgTypes>(__args)...);
__p_.set_value();
#ifndef _LIBCPP_NO_EXCEPTIONS
}
@@ -2119,7 +2153,7 @@ packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args
try
{
#endif // _LIBCPP_NO_EXCEPTIONS
__f_(_STD::forward<_ArgTypes>(__args)...);
__f_(_VSTD::forward<_ArgTypes>(__args)...);
__p_.set_value_at_thread_exit();
#ifndef _LIBCPP_NO_EXCEPTIONS
}
@@ -2162,7 +2196,7 @@ __make_deferred_assoc_state(_F __f)
#endif
{
unique_ptr<__deferred_assoc_state<_R, _F>, __release_shared_count>
__h(new __deferred_assoc_state<_R, _F>(_STD::forward<_F>(__f)));
__h(new __deferred_assoc_state<_R, _F>(_VSTD::forward<_F>(__f)));
return future<_R>(__h.get());
}
@@ -2175,8 +2209,8 @@ __make_async_assoc_state(_F __f)
#endif
{
unique_ptr<__async_assoc_state<_R, _F>, __release_shared_count>
__h(new __async_assoc_state<_R, _F>(_STD::forward<_F>(__f)));
_STD::thread(&__async_assoc_state<_R, _F>::__execute, __h.get()).detach();
__h(new __async_assoc_state<_R, _F>(_VSTD::forward<_F>(__f)));
_VSTD::thread(&__async_assoc_state<_R, _F>::__execute, __h.get()).detach();
return future<_R>(__h.get());
}
@@ -2190,10 +2224,10 @@ public:
_LIBCPP_INLINE_VISIBILITY
explicit __async_func(_F&& __f, _Args&&... __args)
: __f_(_STD::move(__f), _STD::move(__args)...) {}
: __f_(_VSTD::move(__f), _VSTD::move(__args)...) {}
_LIBCPP_INLINE_VISIBILITY
__async_func(__async_func&& __f) : __f_(_STD::move(__f.__f_)) {}
__async_func(__async_func&& __f) : __f_(_VSTD::move(__f.__f_)) {}
_R operator()()
{
@@ -2205,7 +2239,7 @@ private:
_R
__execute(__tuple_indices<_Indices...>)
{
return __invoke(_STD::move(_STD::get<0>(__f_)), _STD::move(_STD::get<_Indices>(__f_))...);
return __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...);
}
};
@@ -2217,11 +2251,11 @@ async(launch __policy, _F&& __f, _Args&&... __args)
typedef typename _BF::_R _R;
future<_R> __r;
if (__policy & launch::async)
__r = _STD::__make_async_assoc_state<_R>(_BF(__decay_copy(_STD::forward<_F>(__f)),
__decay_copy(_STD::forward<_Args>(__args))...));
__r = _VSTD::__make_async_assoc_state<_R>(_BF(__decay_copy(_VSTD::forward<_F>(__f)),
__decay_copy(_VSTD::forward<_Args>(__args))...));
else if (__policy & launch::deferred)
__r = _STD::__make_deferred_assoc_state<_R>(_BF(__decay_copy(_STD::forward<_F>(__f)),
__decay_copy(_STD::forward<_Args>(__args))...));
__r = _VSTD::__make_deferred_assoc_state<_R>(_BF(__decay_copy(_VSTD::forward<_F>(__f)),
__decay_copy(_VSTD::forward<_Args>(__args))...));
return __r;
}
@@ -2230,8 +2264,8 @@ inline _LIBCPP_INLINE_VISIBILITY
future<typename __invoke_of<typename decay<_F>::type, typename decay<_Args>::type...>::type>
async(_F&& __f, _Args&&... __args)
{
return _STD::async(launch::any, _STD::forward<_F>(__f),
_STD::forward<_Args>(__args)...);
return _VSTD::async(launch::any, _VSTD::forward<_F>(__f),
_VSTD::forward<_Args>(__args)...);
}
#endif // _LIBCPP_HAS_NO_VARIADICS
@@ -2273,7 +2307,7 @@ public:
const _R& get() const {return __state_->copy();}
_LIBCPP_INLINE_VISIBILITY
void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);}
void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
// functions to check state
_LIBCPP_INLINE_VISIBILITY
@@ -2347,7 +2381,7 @@ public:
_R& get() const {return __state_->copy();}
_LIBCPP_INLINE_VISIBILITY
void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);}
void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
// functions to check state
_LIBCPP_INLINE_VISIBILITY
@@ -2421,7 +2455,7 @@ public:
void get() const {__state_->copy();}
_LIBCPP_INLINE_VISIBILITY
void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);}
void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
// functions to check state
_LIBCPP_INLINE_VISIBILITY
@@ -2454,7 +2488,7 @@ inline _LIBCPP_INLINE_VISIBILITY
shared_future<_R>
future<_R>::share()
{
return shared_future<_R>(_STD::move(*this));
return shared_future<_R>(_VSTD::move(*this));
}
template <class _R>
@@ -2462,7 +2496,7 @@ inline _LIBCPP_INLINE_VISIBILITY
shared_future<_R&>
future<_R&>::share()
{
return shared_future<_R&>(_STD::move(*this));
return shared_future<_R&>(_VSTD::move(*this));
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -2471,7 +2505,7 @@ inline _LIBCPP_INLINE_VISIBILITY
shared_future<void>
future<void>::share()
{
return shared_future<void>(_STD::move(*this));
return shared_future<void>(_VSTD::move(*this));
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

View File

@@ -51,6 +51,8 @@ template<class E> const E* end(initializer_list<E> il) noexcept;
namespace std // purposefully not versioned
{
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _E>
class _LIBCPP_VISIBLE initializer_list
{
@@ -94,6 +96,8 @@ end(initializer_list<_E> __il) _NOEXCEPT
return __il.end();
}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
} // std
#endif // _LIBCPP_INITIALIZER_LIST

View File

@@ -266,8 +266,8 @@ public:
enum seekdir {beg, cur, end};
typedef seekdir seek_dir;
typedef _STD::streamoff streamoff;
typedef _STD::streampos streampos;
typedef _VSTD::streamoff streamoff;
typedef _VSTD::streampos streampos;
class Init;
@@ -776,8 +776,8 @@ void
basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs)
{
ios_base::swap(__rhs);
_STD::swap(__tie_, __rhs.__tie_);
_STD::swap(__fill_, __rhs.__fill_);
_VSTD::swap(__tie_, __rhs.__tie_);
_VSTD::swap(__fill_, __rhs.__fill_);
}
template <class _CharT, class _Traits>

View File

@@ -177,11 +177,13 @@ public:
virtual ~basic_istream();
protected:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
basic_istream(basic_istream&& __rhs);
#endif
// 27.7.1.1.2 Assign/swap:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
basic_istream& operator=(basic_istream&& __rhs);
#endif
void swap(basic_istream& __rhs);
@@ -321,7 +323,7 @@ inline _LIBCPP_INLINE_VISIBILITY
void
basic_istream<_CharT, _Traits>::swap(basic_istream& __rhs)
{
_STD::swap(__gc_, __rhs.__gc_);
_VSTD::swap(__gc_, __rhs.__gc_);
basic_ios<char_type, traits_type>::swap(__rhs);
}
@@ -740,26 +742,29 @@ 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());
_I __i(__is);
_I __eof;
for (; __i != __eof && __c < __n-1; ++__i, ++__s, ++__c)
ios_base::iostate __err = ios_base::goodbit;
while (__c < __n-1)
{
_CharT __ch = *__i;
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 (__ct.is(__ct.space, __ch))
break;
*__s = __ch;
*__s++ = __ch;
++__c;
__is.rdbuf()->sbumpc();
}
*__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);
@@ -801,25 +806,11 @@ 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
}
@@ -859,42 +850,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
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)
{
*__o = *__i;
if (__o.failed())
break;
}
ios_base::iostate __err = ios_base::goodbit;
if (__i == __eof)
__err |= ios_base::eofbit;
if (__c == 0)
while (true)
{
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()))
break;
++__gc_;
this->rdbuf()->sbumpc();
}
if (__gc_ == 0)
__err |= ios_base::failbit;
this->setstate(__err);
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
if (__c == 0)
if (__gc_ == 0)
this->__set_failbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
}
else
this->setstate(ios_base::failbit);
__gc_ = __c;
}
#ifndef _LIBCPP_NO_EXCEPTIONS
}
@@ -919,22 +910,11 @@ basic_istream<_CharT, _Traits>::get()
sentry __s(*this, true);
if (__s)
{
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;
}
__r = this->rdbuf()->sbumpc();
if (traits_type::eq_int_type(__r, traits_type::eof()))
this->setstate(ios_base::failbit | ios_base::eofbit);
else
__err |= ios_base::failbit | ios_base::eofbit;
this->setstate(__err);
__gc_ = __c;
__gc_ = 1;
}
#ifndef _LIBCPP_NO_EXCEPTIONS
}
@@ -969,30 +949,31 @@ basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __
sentry __sen(*this, true);
if (__sen)
{
streamsize __c = 0;
if (__n > 0)
{
typedef istreambuf_iterator<char_type, traits_type> _I;
_I __i(*this);
_I __eof;
for (; __i != __eof && __n > 1; ++__i, ++__s, ++__c)
ios_base::iostate __err = ios_base::goodbit;
while (__gc_ < __n-1)
{
char_type __ch = *__i;
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);
if (traits_type::eq(__ch, __dlm))
break;
*__s = __ch;
*__s++ = __ch;
++__gc_;
this->rdbuf()->sbumpc();
}
*__s = char_type();
ios_base::iostate __err = ios_base::goodbit;
if (__i == __eof)
__err |= ios_base::eofbit;
if (__c == 0)
if (__gc_ == 0)
__err |= ios_base::failbit;
this->setstate(__err);
}
else
this->setstate(ios_base::failbit);
__gc_ = __c;
}
#ifndef _LIBCPP_NO_EXCEPTIONS
}
@@ -1025,38 +1006,36 @@ 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
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)
while (true)
{
char_type __ch = *__i;
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);
if (traits_type::eq(__ch, __dlm))
break;
*__o = __ch;
if (__o.failed())
if (traits_type::eq_int_type(__sb.sputc(__ch), traits_type::eof()))
break;
++__gc_;
this->rdbuf()->sbumpc();
}
if (__i == __eof)
__err |= ios_base::eofbit;
#ifndef _LIBCPP_NO_EXCEPTIONS
}
catch (...)
{
}
#endif // _LIBCPP_NO_EXCEPTIONS
if (__c == 0)
if (__gc_ == 0)
__err |= ios_base::failbit;
this->setstate(__err);
__gc_ = __c;
}
#ifndef _LIBCPP_NO_EXCEPTIONS
}
@@ -1088,33 +1067,36 @@ basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_typ
sentry __sen(*this, true);
if (__sen)
{
streamsize __c = 0;
typedef istreambuf_iterator<char_type, traits_type> _I;
_I __i(*this);
_I __eof;
for (; __i != __eof; ++__s, --__n)
ios_base::iostate __err = ios_base::goodbit;
while (true)
{
char_type __ch = *__i;
++__i;
++__c;
if (traits_type::eq(__ch, __dlm))
break;
if (__n < 2)
typename traits_type::int_type __i = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__i, traits_type::eof()))
{
this->setstate(ios_base::failbit);
__err |= ios_base::eofbit;
break;
}
char_type __ch = traits_type::to_char_type(__i);
if (traits_type::eq(__ch, __dlm))
{
this->rdbuf()->sbumpc();
++__gc_;
break;
}
*__s = __ch;
if (__gc_ >= __n-1)
{
__err |= ios_base::failbit;
break;
}
*__s++ = __ch;
this->rdbuf()->sbumpc();
++__gc_;
}
if (__n)
if (__n > 0)
*__s = char_type();
ios_base::iostate __err = ios_base::goodbit;
if (__i == __eof)
__err |= ios_base::eofbit;
if (__c == 0)
if (__gc_ == 0)
__err |= ios_base::failbit;
this->setstate(__err);
__gc_ = __c;
}
#ifndef _LIBCPP_NO_EXCEPTIONS
}
@@ -1146,35 +1128,40 @@ basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm)
sentry __sen(*this, true);
if (__sen)
{
streamsize __c = 0;
typedef istreambuf_iterator<char_type, traits_type> _I;
_I __i(*this);
_I __eof;
if (__n != numeric_limits<streamsize>::max())
ios_base::iostate __err = ios_base::goodbit;
if (__n == numeric_limits<streamsize>::max())
{
for (; __n > 0 && __i != __eof; --__n)
while (true)
{
char_type __ch = *__i;
++__i;
++__c;
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, __dlm))
break;
}
}
else
{
while (__i != __eof)
while (__gc_ < __n)
{
char_type __ch = *__i;
++__i;
++__c;
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, __dlm))
break;
}
}
if (__i == __eof)
this->setstate(ios_base::eofbit);
__gc_ = __c;
this->setstate(__err);
}
#ifndef _LIBCPP_NO_EXCEPTIONS
}
@@ -1221,20 +1208,17 @@ basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n)
sentry __sen(*this, true);
if (__sen)
{
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)
ios_base::iostate __err = ios_base::goodbit;
for (; __gc_ < __n; ++__gc_)
{
ios_base::iostate __err = ios_base::eofbit;
if (__n > 0)
__err |= ios_base::failbit;
this->setstate(__err);
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);
}
__gc_ = __c;
}
else
this->setstate(ios_base::failbit);
@@ -1252,45 +1236,19 @@ template<class _CharT, class _Traits>
streamsize
basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
{
__gc_ = 0;
streamsize __c = 0;
#ifndef _LIBCPP_NO_EXCEPTIONS
try
streamsize __c = this->rdbuf()->in_avail();
switch (__c)
{
#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 = _STD::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
case -1:
this->setstate(ios_base::eofbit);
break;
case 0:
break;
default:
read(__s, _VSTD::min(__c, __n));
break;
}
catch (...)
{
this->__set_badbit_and_consider_rethrow();
}
#endif // _LIBCPP_NO_EXCEPTIONS
return __c;
return __gc_;
}
template<class _CharT, class _Traits>
@@ -1453,15 +1411,19 @@ 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());
_I __i(__is);
_I __eof;
for (; __i != __eof; ++__i)
if (!__ct.is(__ct.space, *__i))
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)))
break;
if (__i == __eof)
__is.setstate(ios_base::failbit | ios_base::eofbit);
__is.rdbuf()->sbumpc();
}
}
#ifndef _LIBCPP_NO_EXCEPTIONS
}
@@ -1504,11 +1466,13 @@ public:
virtual ~basic_iostream();
protected:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
basic_iostream(basic_iostream&& __rhs);
#endif
// assign/swap
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
basic_iostream& operator=(basic_iostream&& __rhs);
#endif
void swap(basic_iostream& __rhs);
@@ -1527,7 +1491,7 @@ basic_iostream<_CharT, _Traits>::basic_iostream(basic_streambuf<char_type, trait
template <class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs)
: basic_istream<_CharT, _Traits>(_STD::move(__rhs))
: basic_istream<_CharT, _Traits>(_VSTD::move(__rhs))
{
}
@@ -1568,27 +1532,30 @@ 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());
_I __i(__is);
_I __eof;
for (; __i != __eof && __c < __n; ++__i, ++__c)
ios_base::iostate __err = ios_base::goodbit;
while (__c < __n)
{
_CharT __ch = *__i;
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 (__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);
@@ -1618,31 +1585,28 @@ getline(basic_istream<_CharT, _Traits>& __is,
if (__sen)
{
__str.clear();
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;)
ios_base::iostate __err = ios_base::goodbit;
streamsize __extr = 0;
while (true)
{
_CharT __ch = *__i;
++__i;
++__c;
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);
if (_Traits::eq(__ch, __dlm))
break;
if (__c == __n)
__str.push_back(__ch);
if (__str.size() == __str.max_size())
{
__is.setstate(ios_base::failbit);
__err |= ios_base::failbit;
break;
}
__str.push_back(__ch);
}
ios_base::iostate __err = ios_base::goodbit;
if (__i == __eof)
__err |= ios_base::eofbit;
if (__c == 0)
if (__extr == 0)
__err |= ios_base::failbit;
__is.setstate(__err);
}
@@ -1700,24 +1664,26 @@ 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');
_I __i(__is);
_I __eof;
for (; __i != __eof && __c < _Size; ++__i, ++__c)
while (__c < _Size)
{
_CharT __ch = *__i;
if (__ch != __zero && __ch != __one)
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))
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);

View File

@@ -488,7 +488,7 @@ next(_ForwardIter __x,
typename iterator_traits<_ForwardIter>::difference_type __n = 1,
typename enable_if<__is_forward_iterator<_ForwardIter>::value>::type* = 0)
{
_STD::advance(__x, __n);
_VSTD::advance(__x, __n);
return __x;
}
@@ -499,7 +499,7 @@ prev(_BidiretionalIter __x,
typename iterator_traits<_BidiretionalIter>::difference_type __n = 1,
typename enable_if<__is_bidirectional_iterator<_BidiretionalIter>::value>::type* = 0)
{
_STD::advance(__x, -__n);
_VSTD::advance(__x, -__n);
return __x;
}
@@ -628,7 +628,7 @@ public:
{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(_STD::move(__value)); return *this;}
{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;}
@@ -661,7 +661,7 @@ public:
{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(_STD::move(__value)); return *this;}
{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;}
@@ -696,7 +696,7 @@ public:
{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, _STD::move(__value)); ++iter; return *this;}
{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;}
@@ -1035,7 +1035,7 @@ operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
template <class _Iter>
__wrap_iter<_Iter>
operator+(typename __wrap_iter<_Iter>::difference_type, const __wrap_iter<_Iter>&) _NOEXCEPT;
operator+(typename __wrap_iter<_Iter>::difference_type, __wrap_iter<_Iter>) _NOEXCEPT;
template <class _I, class _O> _O copy(_I, _I, _O);
template <class _B1, class _B2> _B2 copy_backward(_B1, _B1, _B2);
@@ -1063,33 +1063,108 @@ public:
private:
iterator_type __i;
public:
_LIBCPP_INLINE_VISIBILITY __wrap_iter() _NOEXCEPT {}
_LIBCPP_INLINE_VISIBILITY __wrap_iter() _NOEXCEPT
{
#if _LIBCPP_DEBUG_LEVEL >= 2
__get_db()->__insert_i(this);
#endif
}
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()) {}
_LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT {return *__i;}
: __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;
}
_LIBCPP_INLINE_VISIBILITY pointer operator->() const _NOEXCEPT {return &(operator*());}
_LIBCPP_INLINE_VISIBILITY __wrap_iter& operator++() _NOEXCEPT {++__i; return *this;}
_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++(int) _NOEXCEPT
{__wrap_iter __tmp(*this); ++__i; return __tmp;}
_LIBCPP_INLINE_VISIBILITY __wrap_iter& operator--() _NOEXCEPT {--__i; return *this;}
{__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;
}
_LIBCPP_INLINE_VISIBILITY __wrap_iter operator--(int) _NOEXCEPT
{__wrap_iter __tmp(*this); --__i; return __tmp;}
{__wrap_iter __tmp(*this); --(*this); return __tmp;}
_LIBCPP_INLINE_VISIBILITY __wrap_iter operator+ (difference_type __n) const _NOEXCEPT
{return __wrap_iter(__i + __n);}
{__wrap_iter __w(*this); __w += __n; return __w;}
_LIBCPP_INLINE_VISIBILITY __wrap_iter& operator+=(difference_type __n) _NOEXCEPT
{__i += __n; return *this;}
{
#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;
}
_LIBCPP_INLINE_VISIBILITY __wrap_iter operator- (difference_type __n) const _NOEXCEPT
{return __wrap_iter(__i - __n);}
{return *this + (-__n);}
_LIBCPP_INLINE_VISIBILITY __wrap_iter& operator-=(difference_type __n) _NOEXCEPT
{__i -= __n; return *this;}
{*this += -__n; return *this;}
_LIBCPP_INLINE_VISIBILITY reference operator[](difference_type __n) const _NOEXCEPT
{return __i[__n];}
{
#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];
}
_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;
@@ -1133,7 +1208,7 @@ private:
template <class _Iter1>
friend
__wrap_iter<_Iter1>
operator+(typename __wrap_iter<_Iter1>::difference_type, const __wrap_iter<_Iter1>&) _NOEXCEPT;
operator+(typename __wrap_iter<_Iter1>::difference_type, __wrap_iter<_Iter1>) _NOEXCEPT;
template <class _I, class _O> friend _O copy(_I, _I, _O);
template <class _B1, class _B2> friend _B2 copy_backward(_B1, _B1, _B2);
@@ -1155,6 +1230,10 @@ 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();
}
@@ -1163,6 +1242,10 @@ 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();
}
@@ -1171,7 +1254,7 @@ inline _LIBCPP_INLINE_VISIBILITY
bool
operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
{
return __x.base() != __y.base();
return !(__x == __y);
}
template <class _Iter1, class _Iter2>
@@ -1179,7 +1262,7 @@ inline _LIBCPP_INLINE_VISIBILITY
bool
operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
{
return __x.base() > __y.base();
return __y < __x;
}
template <class _Iter1, class _Iter2>
@@ -1187,7 +1270,7 @@ inline _LIBCPP_INLINE_VISIBILITY
bool
operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
{
return __x.base() >= __y.base();
return !(__x < __y);
}
template <class _Iter1, class _Iter2>
@@ -1195,7 +1278,7 @@ inline _LIBCPP_INLINE_VISIBILITY
bool
operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
{
return __x.base() <= __y.base();
return !(__y < __x);
}
template <class _Iter1, class _Iter2>
@@ -1203,6 +1286,10 @@ 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();
}
@@ -1210,9 +1297,10 @@ template <class _Iter>
inline _LIBCPP_INLINE_VISIBILITY
__wrap_iter<_Iter>
operator+(typename __wrap_iter<_Iter>::difference_type __n,
const __wrap_iter<_Iter>& __x) _NOEXCEPT
__wrap_iter<_Iter> __x) _NOEXCEPT
{
return __wrap_iter<_Iter>(__x.base() + __n);
__x += __n;
return __x;
}
#ifdef _LIBCPP_DEBUG

File diff suppressed because it is too large Load Diff

View File

@@ -186,155 +186,221 @@ template <class charT> class messages_byname;
#endif
#include <cstdlib>
#include <ctime>
#if _WIN32
#include <support/win32/locale_win32.h>
#else // _WIN32
#include <nl_types.h>
#endif // !_WIN32
#pragma GCC system_header
_LIBCPP_BEGIN_NAMESPACE_STD
#if __APPLE__ || __FreeBSD__
# define _LIBCPP_GET_C_LOCALE 0
#else
# define _LIBCPP_GET_C_LOCALE __cloc()
// Get the C locale object
locale_t __cloc();
#define __cloc_defined
#endif
typedef _VSTD::remove_pointer<locale_t>::type __locale_struct;
typedef _VSTD::unique_ptr<__locale_struct, decltype(&freelocale)> __locale_unique_ptr;
typedef _VSTD::unique_ptr<__locale_struct, decltype(&uselocale)> __locale_raii;
// OSX has nice foo_l() functions that let you turn off use of the global
// locale. Linux, not so much. The following functions avoid the locale when
// that's possible and otherwise do the wrong thing. FIXME.
#if __APPLE__
#ifdef __linux__
template <class _Tp>
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
decltype(MB_CUR_MAX_L(_VSTD::declval<locale_t>()))
inline _LIBCPP_INLINE_VISIBILITY
int
__nolocale_sprintf(char* __restrict __str,
const char* __restrict __format, _Tp __v)
__mb_cur_max_l(locale_t __l)
{
return sprintf_l(__str, 0, __format, __v);
return MB_CUR_MAX_L(__l);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
int
__nolocale_snprintf(char* __restrict __str, size_t __size,
const char* __restrict __format, _Tp __v)
#else // _LIBCPP_LOCALE__L_EXTENSIONS
_LIBCPP_ALWAYS_INLINE inline
decltype(MB_CUR_MAX) __mb_cur_max_l(locale_t __l)
{
return snprintf_l(__str, __size, 0, __format, __v);
__locale_raii __current(uselocale(__l), uselocale);
return MB_CUR_MAX;
}
#endif // _LIBCPP_LOCALE__L_EXTENSIONS
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
int
__nolocale_snprintf(char* __restrict __str, size_t __size,
const char* __restrict __format, int __prec, _Tp __v)
_LIBCPP_ALWAYS_INLINE inline
wint_t __btowc_l(int __c, locale_t __l)
{
return snprintf_l(__str, __size, 0, __format, __prec, __v);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
int
__nolocale_asprintf(char** __ret, const char* __restrict __format, _Tp __v)
{
return asprintf_l(__ret, 0, __format, __v);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
int
__nolocale_asprintf(char** __ret, const char* __restrict __format, int __prec,
_Tp __v)
{
return asprintf_l(__ret, 0, __format, __prec, __v);
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
int
__nolocale_sscanf(const char* __restrict __str,
const char* __restrict __format, _Tp* __v)
{
return sscanf_l(__str, 0, __format, __v);
}
inline _LIBCPP_INLINE_VISIBILITY
int
__nolocale_isxdigit(int __c)
{
return isxdigit_l(__c, 0);
}
inline _LIBCPP_INLINE_VISIBILITY
int
__nolocale_isdigit(int __c)
{
return isdigit_l(__c, 0);
}
#else // __APPLE__
inline
#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
_LIBCPP_INLINE_VISIBILITY
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
return btowc_l(__c, __l);
#else
__locale_raii __current(uselocale(__l), uselocale);
return btowc(__c);
#endif
int
__nolocale_sprintf(char* __restrict __str,
const char* __restrict __format, ...)
{
va_list __ap;
va_start(__ap, __format);
int __result = vsprintf(__str, __format, __ap);
va_end(__ap);
return __result;
}
inline
#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
_LIBCPP_INLINE_VISIBILITY
#endif
int
__nolocale_snprintf(char* __restrict __str, size_t __size,
const char* __restrict __format, ...)
{
va_list __ap;
va_start(__ap, __format);
int __result = vsnprintf(__str, __size, __format, __ap);
va_end(__ap);
return __result;
}
inline
#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
_LIBCPP_INLINE_VISIBILITY
#endif
int
__nolocale_asprintf(char** __ret,
const char* __restrict __format, ...)
{
va_list __ap;
va_start(__ap, __format);
int __result = vasprintf(__ret, __format, __ap);
va_end(__ap);
return __result;
}
inline
#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
_LIBCPP_INLINE_VISIBILITY
#endif
int
__nolocale_sscanf(const char* __restrict __str,
const char* __restrict __format, ...)
{
va_list __ap;
va_start(__ap, __format);
int __result = vsscanf(__str, __format, __ap);
va_end(__ap);
return __result;
}
inline _LIBCPP_INLINE_VISIBILITY
int
__nolocale_isxdigit(int __c)
{
return isxdigit(__c);
}
inline _LIBCPP_INLINE_VISIBILITY
int
__nolocale_isdigit(int __c)
_LIBCPP_ALWAYS_INLINE inline
int __wctob_l(wint_t __c, locale_t __l)
{
return isdigit(__c);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
return wctob_l(__c, __l);
#else
__locale_raii __current(uselocale(__l), uselocale);
return wctob(__c);
#endif
}
#endif // __APPLE__
_LIBCPP_ALWAYS_INLINE inline
size_t __wcsnrtombs_l(char *__dest, const wchar_t **__src, size_t __nwc,
size_t __len, mbstate_t *__ps, locale_t __l)
{
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
return wcsnrtombs_l(__dest, __src, __nwc, __len, __ps, __l);
#else
__locale_raii __current(uselocale(__l), uselocale);
return wcsnrtombs(__dest, __src, __nwc, __len, __ps);
#endif
}
_LIBCPP_ALWAYS_INLINE inline
size_t __wcrtomb_l(char *__s, wchar_t __wc, mbstate_t *__ps, locale_t __l)
{
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
return wcrtomb_l(__s, __wc, __ps, __l);
#else
__locale_raii __current(uselocale(__l), uselocale);
return wcrtomb(__s, __wc, __ps);
#endif
}
_LIBCPP_ALWAYS_INLINE inline
size_t __mbsnrtowcs_l(wchar_t * __dest, const char **__src, size_t __nms,
size_t __len, mbstate_t *__ps, locale_t __l)
{
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
return mbsnrtowcs_l(__dest, __src, __nms, __len, __ps, __l);
#else
__locale_raii __current(uselocale(__l), uselocale);
return mbsnrtowcs(__dest, __src, __nms, __len, __ps);
#endif
}
_LIBCPP_ALWAYS_INLINE inline
size_t __mbrtowc_l(wchar_t *__pwc, const char *__s, size_t __n,
mbstate_t *__ps, locale_t __l)
{
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
return mbrtowc_l(__pwc, __s, __n, __ps, __l);
#else
__locale_raii __current(uselocale(__l), uselocale);
return mbrtowc(__pwc, __s, __n, __ps);
#endif
}
_LIBCPP_ALWAYS_INLINE inline
int __mbtowc_l(wchar_t *__pwc, const char *__pmb, size_t __max, locale_t __l)
{
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
return mbtowc_l(__pwc, __pmb, __max, __l);
#else
__locale_raii __current(uselocale(__l), uselocale);
return mbtowc(__pwc, __pmb, __max);
#endif
}
_LIBCPP_ALWAYS_INLINE inline
size_t __mbrlen_l(const char *__s, size_t __n, mbstate_t *__ps, locale_t __l)
{
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
return mbrlen_l(__s, __n, __ps, __l);
#else
__locale_raii __current(uselocale(__l), uselocale);
return mbrlen(__s, __n, __ps);
#endif
}
_LIBCPP_ALWAYS_INLINE inline
lconv *__localeconv_l(locale_t __l)
{
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
return localeconv_l(__l);
#else
__locale_raii __current(uselocale(__l), uselocale);
return localeconv();
#endif
}
_LIBCPP_ALWAYS_INLINE inline
size_t __mbsrtowcs_l(wchar_t *__dest, const char **__src, size_t __len,
mbstate_t *__ps, locale_t __l)
{
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
return mbsrtowcs_l(__dest, __src, __len, __ps, __l);
#else
__locale_raii __current(uselocale(__l), uselocale);
return mbsrtowcs(__dest, __src, __len, __ps);
#endif
}
_LIBCPP_ALWAYS_INLINE inline
int __sprintf_l(char *__s, locale_t __l, const char *__format, ...) {
va_list __va;
va_start(__va, __format);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
int __res = vsprintf_l(__s, __l, __format, __va);
#else
__locale_raii __current(uselocale(__l), uselocale);
int __res = vsprintf(__s, __format, __va);
#endif
va_end(__va);
return __res;
}
_LIBCPP_ALWAYS_INLINE inline
int __snprintf_l(char *__s, size_t __n, locale_t __l, const char *__format, ...) {
va_list __va;
va_start(__va, __format);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
int __res = vsnprintf_l(__s, __n, __l, __format, __va);
#else
__locale_raii __current(uselocale(__l), uselocale);
int __res = vsnprintf(__s, __n, __format, __va);
#endif
va_end(__va);
return __res;
}
_LIBCPP_ALWAYS_INLINE inline
int __asprintf_l(char **__s, locale_t __l, const char *__format, ...) {
va_list __va;
va_start(__va, __format);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
int __res = vasprintf_l(__s, __l, __format, __va);
#else
__locale_raii __current(uselocale(__l), uselocale);
int __res = vasprintf(__s, __format, __va);
#endif
va_end(__va);
return __res;
}
_LIBCPP_ALWAYS_INLINE inline
int __sscanf_l(const char *__s, locale_t __l, const char *__format, ...) {
va_list __va;
va_start(__va, __format);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
int __res = vsscanf_l(__s, __l, __format, __va);
#else
__locale_raii __current(uselocale(__l), uselocale);
int __res = vsscanf(__s, __format, __va);
#endif
va_end(__va);
return __res;
}
#endif // __linux__
// __scan_keyword
// Scans [__b, __e) until a match is found in the basic_strings range
@@ -363,7 +429,7 @@ __scan_keyword(_InputIterator& __b, _InputIterator __e,
bool __case_sensitive = true)
{
typedef typename iterator_traits<_InputIterator>::value_type _CharT;
size_t __nkw = _STD::distance(__kb, __ke);
size_t __nkw = _VSTD::distance(__kb, __ke);
const unsigned char __doesnt_match = '\0';
const unsigned char __might_match = '\1';
const unsigned char __does_match = '\2';
@@ -748,7 +814,7 @@ __num_get_signed_integral(const char* __a, const char* __a_end,
int __save_errno = errno;
errno = 0;
char *__p2;
long long __ll = strtoll_l(__a, &__p2, __base, 0);
long long __ll = strtoll_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
int __current_errno = errno;
if (__current_errno == 0)
errno = __save_errno;
@@ -788,7 +854,7 @@ __num_get_unsigned_integral(const char* __a, const char* __a_end,
int __save_errno = errno;
errno = 0;
char *__p2;
unsigned long long __ll = strtoull_l(__a, &__p2, __base, 0);
unsigned long long __ll = strtoull_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
int __current_errno = errno;
if (__current_errno == 0)
errno = __save_errno;
@@ -816,7 +882,7 @@ __num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err)
if (__a != __a_end)
{
char *__p2;
long double __ld = strtold_l(__a, &__p2, 0);
long double __ld = strtold_l(__a, &__p2, _LIBCPP_GET_C_LOCALE);
if (__p2 != __a_end)
{
__err = ios_base::failbit;
@@ -1221,7 +1287,11 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
break;
// Stage 3
__a[sizeof(__a)-1] = 0;
if (__nolocale_sscanf(__a, "%p", &__v) != 1)
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
if (sscanf_l(__a, _LIBCPP_GET_C_LOCALE, "%p", &__v) != 1)
#else
if (__sscanf_l(__a, __cloc(), "%p", &__v) != 1)
#endif
__err = ios_base::failbit;
// EOF checked
if (__b == __e)
@@ -1326,13 +1396,13 @@ __num_put<_CharT>::__widen_and_group_float(char* __nb, char* __np, char* __ne,
*__oe++ = __ct.widen(*__nf++);
*__oe++ = __ct.widen(*__nf++);
for (__ns = __nf; __ns < __ne; ++__ns)
if (!__nolocale_isxdigit(*__ns))
if (!isxdigit_l(*__ns, _LIBCPP_GET_C_LOCALE))
break;
}
else
{
for (__ns = __nf; __ns < __ne; ++__ns)
if (!__nolocale_isdigit(*__ns))
if (!isdigit_l(*__ns, _LIBCPP_GET_C_LOCALE))
break;
}
if (__grouping.empty())
@@ -1530,7 +1600,11 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
+ ((numeric_limits<long>::digits % 3) != 0)
+ 1;
char __nar[__nbuf];
int __nc = __nolocale_sprintf(__nar, __fmt, __v);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
int __nc = sprintf_l(__nar, _LIBCPP_GET_C_LOCALE, __fmt, __v);
#else
int __nc = __sprintf_l(__nar, __cloc(), __fmt, __v);
#endif
char* __ne = __nar + __nc;
char* __np = this->__identify_padding(__nar, __ne, __iob);
// Stage 2 - Widen __nar while adding thousands separators
@@ -1556,7 +1630,11 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
+ ((numeric_limits<long long>::digits % 3) != 0)
+ 1;
char __nar[__nbuf];
int __nc = __nolocale_sprintf(__nar, __fmt, __v);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
int __nc = sprintf_l(__nar, _LIBCPP_GET_C_LOCALE, __fmt, __v);
#else
int __nc = __sprintf_l(__nar, __cloc(), __fmt, __v);
#endif
char* __ne = __nar + __nc;
char* __np = this->__identify_padding(__nar, __ne, __iob);
// Stage 2 - Widen __nar while adding thousands separators
@@ -1582,7 +1660,11 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
+ ((numeric_limits<unsigned long>::digits % 3) != 0)
+ 1;
char __nar[__nbuf];
int __nc = __nolocale_sprintf(__nar, __fmt, __v);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
int __nc = sprintf_l(__nar, _LIBCPP_GET_C_LOCALE, __fmt, __v);
#else
int __nc = __sprintf_l(__nar, __cloc(), __fmt, __v);
#endif
char* __ne = __nar + __nc;
char* __np = this->__identify_padding(__nar, __ne, __iob);
// Stage 2 - Widen __nar while adding thousands separators
@@ -1608,7 +1690,11 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
+ ((numeric_limits<unsigned long long>::digits % 3) != 0)
+ 1;
char __nar[__nbuf];
int __nc = __nolocale_sprintf(__nar, __fmt, __v);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
int __nc = sprintf_l(__nar, _LIBCPP_GET_C_LOCALE, __fmt, __v);
#else
int __nc = __sprintf_l(__nar, __cloc(), __fmt, __v);
#endif
char* __ne = __nar + __nc;
char* __np = this->__identify_padding(__nar, __ne, __iob);
// Stage 2 - Widen __nar while adding thousands separators
@@ -1635,18 +1721,35 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
char* __nb = __nar;
int __nc;
if (__specify_precision)
__nc = __nolocale_snprintf(__nb, __nbuf, __fmt,
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
__nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
(int)__iob.precision(), __v);
#else
__nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt,
(int)__iob.precision(), __v);
#endif
else
__nc = __nolocale_snprintf(__nb, __nbuf, __fmt, __v);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
__nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
#else
__nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt, __v);
#endif
unique_ptr<char, void(*)(void*)> __nbh(0, free);
if (__nc > static_cast<int>(__nbuf-1))
{
if (__specify_precision)
__nc = __nolocale_asprintf(&__nb, __fmt, (int)__iob.precision(),
__v);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
__nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
#else
__nc = __asprintf_l(&__nb, __cloc(), __fmt,
(int)__iob.precision(), __v);
#endif
else
__nc = __nolocale_asprintf(&__nb, __fmt, __v);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
__nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
#else
__nc = __asprintf_l(&__nb, __cloc(), __fmt, (int)__iob.precision(), __v);
#endif
if (__nb == 0)
__throw_bad_alloc();
__nbh.reset(__nb);
@@ -1687,18 +1790,35 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
char* __nb = __nar;
int __nc;
if (__specify_precision)
__nc = __nolocale_snprintf(__nb, __nbuf, __fmt,
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
__nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
(int)__iob.precision(), __v);
#else
__nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt,
(int)__iob.precision(), __v);
#endif
else
__nc = __nolocale_snprintf(__nb, __nbuf, __fmt, __v);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
__nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
#else
__nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt, __v);
#endif
unique_ptr<char, void(*)(void*)> __nbh(0, free);
if (__nc > static_cast<int>(__nbuf-1))
{
if (__specify_precision)
__nc = __nolocale_asprintf(&__nb, __fmt, (int)__iob.precision(),
__v);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
__nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
#else
__nc = __asprintf_l(&__nb, __cloc(), __fmt,
(int)__iob.precision(), __v);
#endif
else
__nc = __nolocale_asprintf(&__nb, __fmt, __v);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
__nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
#else
__nc = __asprintf_l(&__nb, __cloc(), __fmt, __v);
#endif
if (__nb == 0)
__throw_bad_alloc();
__nbh.reset(__nb);
@@ -1734,7 +1854,11 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
char __fmt[6] = "%p";
const unsigned __nbuf = 20;
char __nar[__nbuf];
int __nc = __nolocale_sprintf(__nar, __fmt, __v);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
int __nc = sprintf_l(__nar, _LIBCPP_GET_C_LOCALE, __fmt, __v);
#else
int __nc = __sprintf_l(__nar, __cloc(), __fmt, __v);
#endif
char* __ne = __nar + __nc;
char* __np = this->__identify_padding(__nar, __ne, __iob);
// Stage 2 - Widen __nar
@@ -2511,7 +2635,7 @@ class __time_put
{
locale_t __loc_;
protected:
_LIBCPP_ALWAYS_INLINE __time_put() : __loc_(0) {}
_LIBCPP_ALWAYS_INLINE __time_put() : __loc_(_LIBCPP_GET_C_LOCALE) {}
__time_put(const char* __nm);
__time_put(const string& __nm);
~__time_put();
@@ -2614,7 +2738,7 @@ time_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
char_type* __nb = __nar;
char_type* __ne = __nb + 100;
__do_put(__nb, __ne, __tm, __fmt, __mod);
return _STD::copy(__nb, __ne, __s);
return _VSTD::copy(__nb, __ne, __s);
}
extern template class time_put<char>;
@@ -3282,7 +3406,7 @@ __money_put<_CharT>::__format(char_type* __mb, char_type*& __mi, char_type*& __m
break;
case money_base::symbol:
if (!__sym.empty() && (__flags & ios_base::showbase))
__me = _STD::copy(__sym.begin(), __sym.end(), __me);
__me = _VSTD::copy(__sym.begin(), __sym.end(), __me);
break;
case money_base::value:
{
@@ -3341,7 +3465,7 @@ __money_put<_CharT>::__format(char_type* __mb, char_type*& __mi, char_type*& __m
}
// print rest of sign, if any
if (__sn.size() > 1)
__me = _STD::copy(__sn.begin()+1, __sn.end(), __me);
__me = _VSTD::copy(__sn.begin()+1, __sn.end(), __me);
// set alignment
if ((__flags & ios_base::adjustfield) == ios_base::left)
__mi = __me;
@@ -3414,7 +3538,11 @@ money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
// secure memory for digit storage
if (__n > __bs-1)
{
__n = __nolocale_asprintf(&__bb, "%.0Lf", __units);
#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
__n = asprintf_l(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units);
#else
__n = __asprintf_l(&__bb, __cloc(), "%.0Lf", __units);
#endif
if (__bb == 0)
__throw_bad_alloc();
__hn.reset(__bb);
@@ -3565,10 +3693,14 @@ template <class _CharT>
typename messages<_CharT>::catalog
messages<_CharT>::do_open(const basic_string<char>& __nm, const locale&) const
{
catalog __cat = reinterpret_cast<catalog>(catopen(__nm.c_str(), NL_CAT_LOCALE));
#if _WIN32
return -1;
#else // _WIN32
catalog __cat = (catalog)catopen(__nm.c_str(), NL_CAT_LOCALE);
if (__cat != -1)
__cat = static_cast<catalog>((static_cast<size_t>(__cat) >> 1));
return __cat;
#endif // _WIN32
}
template <class _CharT>
@@ -3576,28 +3708,34 @@ typename messages<_CharT>::string_type
messages<_CharT>::do_get(catalog __c, int __set, int __msgid,
const string_type& __dflt) const
{
#if _WIN32
return __dflt;
#else // _WIN32
string __ndflt;
__narrow_to_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__ndflt),
__dflt.c_str(),
__dflt.c_str() + __dflt.size());
if (__c != -1)
__c <<= 1;
nl_catd __cat = reinterpret_cast<nl_catd>(__c);
nl_catd __cat = (nl_catd)__c;
char* __n = catgets(__cat, __set, __msgid, __ndflt.c_str());
string_type __w;
__widen_from_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__w),
__n, __n + strlen(__n));
return __w;
#endif // _WIN32
}
template <class _CharT>
void
messages<_CharT>::do_close(catalog __c) const
{
#if !_WIN32
if (__c != -1)
__c <<= 1;
nl_catd __cat = reinterpret_cast<nl_catd>(__c);
nl_catd __cat = (nl_catd)__c;
catclose(__cat);
#endif // !_WIN32
}
extern template class messages<char>;
@@ -3716,8 +3854,8 @@ template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
inline _LIBCPP_ALWAYS_INLINE
wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
wstring_convert(wstring_convert&& __wc)
: __byte_err_string_(_STD::move(__wc.__byte_err_string_)),
__wide_err_string_(_STD::move(__wc.__wide_err_string_)),
: __byte_err_string_(_VSTD::move(__wc.__byte_err_string_)),
__wide_err_string_(_VSTD::move(__wc.__wide_err_string_)),
__cvtptr_(__wc.__cvtptr_),
__cvtstate_(__wc.__cvtstate_), __cvtcount_(__wc.__cvtstate_)
{
@@ -4010,7 +4148,7 @@ wbuffer_convert<_Codecvt, _Elem, _Tr>::underflow()
memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
__extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
__extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
streamsize __nmemb = _STD::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
streamsize __nmemb = _VSTD::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
static_cast<streamsize>(__extbufend_ - __extbufnext_));
codecvt_base::result __r;
state_type __svs = __st_;

View File

@@ -516,17 +516,19 @@ public:
void operator()(pointer __p) _NOEXCEPT
{
if (__second_constructed)
__alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.second));
__alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.second));
if (__first_constructed)
__alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.first));
__alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.first));
if (__p)
__alloc_traits::deallocate(__na_, __p, 1);
}
};
template <class, class, class, class> class map;
template <class, class, class, class> class multimap;
template <class> class __map_const_iterator;
template <class _Key, class _Tp, class _Compare, class _Allocator>
class map;
template <class _Key, class _Tp, class _Compare, class _Allocator>
class multimap;
template <class _TreeIterator> class __map_const_iterator;
template <class _TreeIterator>
class _LIBCPP_VISIBLE __map_iterator
@@ -713,8 +715,8 @@ public:
typedef typename __alloc_traits::difference_type difference_type;
typedef __map_iterator<typename __base::iterator> iterator;
typedef __map_const_iterator<typename __base::const_iterator> const_iterator;
typedef _STD::reverse_iterator<iterator> reverse_iterator;
typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
_LIBCPP_INLINE_VISIBILITY
explicit map(const key_compare& __comp = key_compare())
@@ -753,17 +755,36 @@ public:
insert(__m.begin(), __m.end());
}
_LIBCPP_INLINE_VISIBILITY
map& operator=(const map& __m)
{
__tree_ = __m.__tree_;
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
map(map&& __m)
_NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
: __tree_(_STD::move(__m.__tree_))
: __tree_(_VSTD::move(__m.__tree_))
{
}
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))
@@ -778,14 +799,6 @@ public:
insert(__il.begin(), __il.end());
}
_LIBCPP_INLINE_VISIBILITY
map& operator=(map&& __m)
_NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
{
__tree_ = _STD::move(__m.__tree_);
return *this;
}
_LIBCPP_INLINE_VISIBILITY
map& operator=(initializer_list<value_type> __il)
{
@@ -793,7 +806,7 @@ public:
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
_LIBCPP_INLINE_VISIBILITY
explicit map(const allocator_type& __a)
@@ -867,16 +880,16 @@ public:
emplace() {return __tree_.__emplace_unique();}
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
_LIBCPP_INLINE_VISIBILITY
pair<iterator, bool>
emplace(_A0&& __a0)
{return __tree_.__emplace_unique(_STD::forward<_A0>(__a0));}
{return __tree_.__emplace_unique(_VSTD::forward<_A0>(__a0));}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _A0, class ..._Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
pair<iterator, bool>
emplace(_A0&& __a0, _Args&& ...__args);
@@ -888,32 +901,32 @@ public:
{return __tree_.__emplace_hint_unique(__p.__i_);}
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator
emplace_hint(const_iterator __p, _A0&& __a0)
{return __tree_.__emplace_hint_unique(__p.__i_, _STD::forward<_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_convertible<_A0, key_type>::value>::type>
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_convertible<_P, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _P>::value>::type>
_LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> insert(_P&& __p)
{return __tree_.__insert_unique(_STD::forward<_P>(__p));}
{return __tree_.__insert_unique(_VSTD::forward<_P>(__p));}
template <class _P,
class = typename enable_if<is_convertible<_P, value_type>::value>::type>
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_, _STD::forward<_P>(__p));}
{return __tree_.__insert_unique(__pos.__i_, _VSTD::forward<_P>(__p));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -934,10 +947,14 @@ 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
@@ -993,11 +1010,11 @@ private:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
__node_holder __construct_node();
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
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 ..._Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
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
@@ -1095,7 +1112,7 @@ map<_Key, _Tp, _Compare, _Allocator>::__find_equal_key(const_iterator __hint,
else if (__tree_.value_comp().key_comp()(__hint->first, __k)) // check after
{
// *__hint < __k
const_iterator __next = _STD::next(__hint);
const_iterator __next = _VSTD::next(__hint);
if (__next == end() || __tree_.value_comp().key_comp()(__k, __next->first))
{
// *__hint < __k < *next(__hint)
@@ -1167,14 +1184,14 @@ map<_Key, _Tp, _Compare, _Allocator>::__find_equal_key(__node_base_const_pointer
template <class _Key, class _Tp, class _Compare, class _Allocator>
map<_Key, _Tp, _Compare, _Allocator>::map(map&& __m, const allocator_type& __a)
: __tree_(_STD::move(__m.__tree_), __a)
: __tree_(_VSTD::move(__m.__tree_), __a)
{
if (__a != __m.get_allocator())
{
const_iterator __e = cend();
while (!__m.empty())
__tree_.__insert_unique(__e.__i_,
_STD::move(__m.__tree_.remove(__m.begin().__i_)->__value_));
_VSTD::move(__m.__tree_.remove(__m.begin().__i_)->__value_));
}
}
@@ -1184,9 +1201,9 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node()
{
__node_allocator& __na = __tree_.__node_alloc();
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_.first));
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first));
__h.get_deleter().__first_constructed = true;
__node_traits::construct(__na, _STD::addressof(__h->__value_.second));
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
__h.get_deleter().__second_constructed = true;
return __h;
}
@@ -1199,7 +1216,7 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
{
__node_allocator& __na = __tree_.__node_alloc();
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_A0>(__a0));
__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;
@@ -1215,9 +1232,9 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _Args&& ...__
{
__node_allocator& __na = __tree_.__node_alloc();
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_.first), _STD::forward<_A0>(__a0));
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), _VSTD::forward<_A0>(__a0));
__h.get_deleter().__first_constructed = true;
__node_traits::construct(__na, _STD::addressof(__h->__value_.second), _STD::forward<_Args>(__args)...);
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second), _VSTD::forward<_Args>(__args)...);
__h.get_deleter().__second_constructed = true;
return __h;
}
@@ -1232,11 +1249,11 @@ 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), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_.first), __k);
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), __k);
__h.get_deleter().__first_constructed = true;
__node_traits::construct(__na, _STD::addressof(__h->__value_.second));
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
__h.get_deleter().__second_constructed = true;
return _STD::move(__h);
return _VSTD::move(__h);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1268,7 +1285,7 @@ map<_Key, _Tp, _Compare, _Allocator>::operator[](key_type&& __k)
__node_pointer __r = static_cast<__node_pointer>(__child);
if (__child == nullptr)
{
__node_holder __h = __construct_node(_STD::move(__k));
__node_holder __h = __construct_node(_VSTD::move(__k));
__tree_.__insert_node_at(__parent, __child, __h.get());
__r = __h.release();
}
@@ -1307,13 +1324,13 @@ map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) const
template <class _Key, class _Tp, class _Compare, class _Allocator>
template <class _A0, class ..._Args,
class //= typename enable_if<is_convertible<_A0, _Key>::value>::type
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(_A0&& __a0, _Args&& ...__args)
{
__node_holder __h = __construct_node(_STD::forward<_A0>(__a0),
_STD::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();
@@ -1322,14 +1339,14 @@ map<_Key, _Tp, _Compare, _Allocator>::emplace(_A0&& __a0, _Args&& ...__args)
template <class _Key, class _Tp, class _Compare, class _Allocator>
template <class _A0, class ..._Args,
class //= typename enable_if<is_convertible<_A0, _Key>::value>::type
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,
_A0&& __a0, _Args&& ...__args)
{
__node_holder __h = __construct_node(_STD::forward<_A0>(__a0),
_STD::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();
@@ -1344,7 +1361,7 @@ bool
operator==(const map<_Key, _Tp, _Compare, _Allocator>& __x,
const map<_Key, _Tp, _Compare, _Allocator>& __y)
{
return __x.size() == __y.size() && _STD::equal(__x.begin(), __x.end(), __y.begin());
return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
}
template <class _Key, class _Tp, class _Compare, class _Allocator>
@@ -1353,7 +1370,7 @@ bool
operator< (const map<_Key, _Tp, _Compare, _Allocator>& __x,
const map<_Key, _Tp, _Compare, _Allocator>& __y)
{
return _STD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
}
template <class _Key, class _Tp, class _Compare, class _Allocator>
@@ -1454,8 +1471,8 @@ public:
typedef typename __alloc_traits::difference_type difference_type;
typedef __map_iterator<typename __base::iterator> iterator;
typedef __map_const_iterator<typename __base::const_iterator> const_iterator;
typedef _STD::reverse_iterator<iterator> reverse_iterator;
typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
_LIBCPP_INLINE_VISIBILITY
explicit multimap(const key_compare& __comp = key_compare())
@@ -1495,17 +1512,36 @@ public:
insert(__m.begin(), __m.end());
}
_LIBCPP_INLINE_VISIBILITY
multimap& operator=(const multimap& __m)
{
__tree_ = __m.__tree_;
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
multimap(multimap&& __m)
_NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
: __tree_(_STD::move(__m.__tree_))
: __tree_(_VSTD::move(__m.__tree_))
{
}
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))
@@ -1520,21 +1556,14 @@ public:
insert(__il.begin(), __il.end());
}
_LIBCPP_INLINE_VISIBILITY
multimap& operator=(multimap&& __m)
_NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
{
__tree_ = _STD::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_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
_LIBCPP_INLINE_VISIBILITY
explicit multimap(const allocator_type& __a)
@@ -1599,16 +1628,16 @@ public:
iterator emplace() {return __tree_.__emplace_multi();}
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator
emplace(_A0&& __a0)
{return __tree_.__emplace_multi(_STD::forward<_A0>(__a0));}
{return __tree_.__emplace_multi(_VSTD::forward<_A0>(__a0));}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _A0, class ..._Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
iterator
emplace(_A0&& __a0, _Args&& ...__args);
@@ -1619,32 +1648,32 @@ public:
{return __tree_.__emplace_hint_multi(__p.__i_);}
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator
emplace_hint(const_iterator __p, _A0&& __a0)
{return __tree_.__emplace_hint_multi(__p.__i_, _STD::forward<_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_convertible<_A0, key_type>::value>::type>
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_convertible<_P, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _P>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator insert(_P&& __p)
{return __tree_.__insert_multi(_STD::forward<_P>(__p));}
{return __tree_.__insert_multi(_VSTD::forward<_P>(__p));}
template <class _P,
class = typename enable_if<is_convertible<_P, value_type>::value>::type>
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_, _STD::forward<_P>(__p));}
{return __tree_.__insert_multi(__pos.__i_, _VSTD::forward<_P>(__p));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1663,10 +1692,14 @@ 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,11 +1752,11 @@ private:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
__node_holder __construct_node();
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
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 ..._Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
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
@@ -1733,14 +1766,14 @@ private:
template <class _Key, class _Tp, class _Compare, class _Allocator>
multimap<_Key, _Tp, _Compare, _Allocator>::multimap(multimap&& __m, const allocator_type& __a)
: __tree_(_STD::move(__m.__tree_), __a)
: __tree_(_VSTD::move(__m.__tree_), __a)
{
if (__a != __m.get_allocator())
{
const_iterator __e = cend();
while (!__m.empty())
__tree_.__insert_multi(__e.__i_,
_STD::move(__m.__tree_.remove(__m.begin().__i_)->__value_));
_VSTD::move(__m.__tree_.remove(__m.begin().__i_)->__value_));
}
}
@@ -1750,23 +1783,23 @@ multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node()
{
__node_allocator& __na = __tree_.__node_alloc();
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_.first));
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first));
__h.get_deleter().__first_constructed = true;
__node_traits::construct(__na, _STD::addressof(__h->__value_.second));
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
__h.get_deleter().__second_constructed = true;
return __h;
}
template <class _Key, class _Tp, class _Compare, class _Allocator>
template <class _A0,
class // = typename enable_if<is_convertible<_A0, value_type>::value>::type
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), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_A0>(__a0));
__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;
@@ -1776,16 +1809,16 @@ multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
template <class _Key, class _Tp, class _Compare, class _Allocator>
template <class _A0, class ..._Args,
class // = typename enable_if<is_convertible<_A0, key_type>::value>::type
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, _Args&& ...__args)
{
__node_allocator& __na = __tree_.__node_alloc();
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_.first), _STD::forward<_A0>(__a0));
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), _VSTD::forward<_A0>(__a0));
__h.get_deleter().__first_constructed = true;
__node_traits::construct(__na, _STD::addressof(__h->__value_.second), _STD::forward<_Args>(__args)...);
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second), _VSTD::forward<_Args>(__args)...);
__h.get_deleter().__second_constructed = true;
return __h;
}
@@ -1797,13 +1830,13 @@ multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _Args&&
template <class _Key, class _Tp, class _Compare, class _Allocator>
template <class _A0, class ..._Args,
class //= typename enable_if<is_convertible<_A0, _Key>::value>::type
class //= typename enable_if<is_constructible<_Key, _A0>::value>::type
>
typename multimap<_Key, _Tp, _Compare, _Allocator>::iterator
multimap<_Key, _Tp, _Compare, _Allocator>::emplace(_A0&& __a0, _Args&& ...__args)
{
__node_holder __h = __construct_node(_STD::forward<_A0>(__a0),
_STD::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;
@@ -1811,15 +1844,15 @@ multimap<_Key, _Tp, _Compare, _Allocator>::emplace(_A0&& __a0, _Args&& ...__args
template <class _Key, class _Tp, class _Compare, class _Allocator>
template <class _A0, class ..._Args,
class //= typename enable_if<is_convertible<_A0, _Key>::value>::type
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(_STD::forward<_A0>(__a0),
_STD::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;
@@ -1833,7 +1866,7 @@ bool
operator==(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
{
return __x.size() == __y.size() && _STD::equal(__x.begin(), __x.end(), __y.begin());
return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
}
template <class _Key, class _Tp, class _Compare, class _Allocator>
@@ -1842,7 +1875,7 @@ bool
operator< (const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
{
return _STD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
}
template <class _Key, class _Tp, class _Compare, class _Allocator>

View File

@@ -595,6 +595,7 @@ void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
#include <limits>
#include <iterator>
#include <__functional_base>
#include <iosfwd>
#if defined(_LIBCPP_NO_EXCEPTIONS)
#include <cassert>
#endif
@@ -619,6 +620,46 @@ addressof(_Tp& __x) _NOEXCEPT
return (_Tp*)&(char&)__x;
}
#if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF)
// Objective-C++ Automatic Reference Counting uses qualified pointers
// that require special addressof() signatures. When
// _LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF is defined, the compiler
// itself is providing these definitions. Otherwise, we provide them.
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
__strong _Tp*
addressof(__strong _Tp& __x) _NOEXCEPT
{
return &__x;
}
#ifdef _LIBCPP_HAS_OBJC_ARC_WEAK
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
__weak _Tp*
addressof(__weak _Tp& __x) _NOEXCEPT
{
return &__x;
}
#endif
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
__autoreleasing _Tp*
addressof(__autoreleasing _Tp& __x) _NOEXCEPT
{
return &__x;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
__unsafe_unretained _Tp*
addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT
{
return &__x;
}
#endif
template <class _Tp> class allocator;
template <>
@@ -898,7 +939,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
static pointer pointer_to(typename conditional<is_void<element_type>::value,
__nat, element_type>::type& __r) _NOEXCEPT
{return _STD::addressof(__r);}
{return _VSTD::addressof(__r);}
};
// allocator_traits
@@ -1032,7 +1073,7 @@ inline _LIBCPP_INLINE_VISIBILITY
typename pointer_traits<_Pointer>::element_type*
__to_raw_pointer(_Pointer __p) _NOEXCEPT
{
return _STD::__to_raw_pointer(__p.operator->());
return _VSTD::__to_raw_pointer(__p.operator->());
}
template <class _Tp>
@@ -1253,11 +1294,11 @@ struct __has_allocate_hint
#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE
#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
#if !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE) && !defined(_LIBCPP_HAS_NO_VARIADICS)
template <class _Alloc, class _Tp, class ..._Args>
decltype(_STD::declval<_Alloc>().construct(_STD::declval<_Tp*>(),
_STD::declval<_Args>()...),
decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Tp*>(),
_VSTD::declval<_Args>()...),
true_type())
__has_construct_test(_Alloc&& __a, _Tp* __p, _Args&& ...__args);
@@ -1427,7 +1468,7 @@ struct _LIBCPP_VISIBLE allocator_traits
_LIBCPP_INLINE_VISIBILITY
static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args)
{__construct(__has_construct<allocator_type, pointer, _Args...>(),
__a, __p, _STD::forward<_Args>(__args)...);}
__a, __p, _VSTD::forward<_Args>(__args)...);}
#else // _LIBCPP_HAS_NO_VARIADICS
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
@@ -1488,12 +1529,12 @@ private:
template <class _Tp, class... _Args>
_LIBCPP_INLINE_VISIBILITY
static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args)
{__a.construct(__p, _STD::forward<_Args>(__args)...);}
{__a.construct(__p, _VSTD::forward<_Args>(__args)...);}
template <class _Tp, class... _Args>
_LIBCPP_INLINE_VISIBILITY
static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args)
{
::new ((void*)__p) _Tp(_STD::forward<_Args>(__args)...);
::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);
}
#endif // _LIBCPP_HAS_NO_VARIADICS
@@ -1598,9 +1639,9 @@ public:
_LIBCPP_INLINE_VISIBILITY allocator() _NOEXCEPT {}
template <class _Up> _LIBCPP_INLINE_VISIBILITY allocator(const allocator<_Up>&) _NOEXCEPT {}
_LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const _NOEXCEPT
{return _STD::addressof(__x);}
{return _VSTD::addressof(__x);}
_LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT
{return _STD::addressof(__x);}
{return _VSTD::addressof(__x);}
_LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
{return static_cast<pointer>(::operator new(__n * sizeof(_Tp)));}
_LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT
@@ -1613,7 +1654,7 @@ public:
void
construct(_Up* __p, _Args&&... __args)
{
::new((void*)__p) _Up(_STD::forward<_Args>(__args)...);
::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
}
#else // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY
@@ -1654,7 +1695,7 @@ public:
>::type
construct(pointer __p, _A0 __a0)
{
::new((void*)__p) _Tp(_STD::move(__a0));
::new((void*)__p) _Tp(_VSTD::move(__a0));
}
# endif // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
template <class _A0, class _A1>
@@ -1843,19 +1884,54 @@ public:
_LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {}
_LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1, int = 0)
: __first_(_STD::forward<_T1_param>(__t1)) {}
: __first_(_VSTD::forward<_T1_param>(__t1)) {}
_LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2, int* = 0)
: __second_(_STD::forward<_T2_param>(__t2)) {}
: __second_(_VSTD::forward<_T2_param>(__t2)) {}
_LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
: __first_(_STD::forward<_T1_param>(__t1)), __second_(_STD::forward<_T2_param>(__t2)) {}
: __first_(_VSTD::forward<_T1_param>(__t1)), __second_(_VSTD::forward<_T2_param>(__t2)) {}
#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p)
_NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value &&
is_nothrow_copy_constructible<_T2>::value)
: __first_(__p.first()),
__second_(__p.second()) {}
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p)
_NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value &&
is_nothrow_copy_assignable<_T2>::value)
{
__first_ = __p.first();
__second_ = __p.second();
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p)
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p)
_NOEXCEPT_(is_nothrow_move_constructible<_T1>::value &&
is_nothrow_move_constructible<_T2>::value)
: __first_(_STD::forward<_T1>(__p.first())), __second_(_STD::forward<_T2>(__p.second())) {}
: __first_(_VSTD::forward<_T1>(__p.first())),
__second_(_VSTD::forward<_T2>(__p.second())) {}
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p)
_NOEXCEPT_(is_nothrow_move_assignable<_T1>::value &&
is_nothrow_move_assignable<_T2>::value)
{
__first_ = _VSTD::forward<_T1>(__p.first());
__second_ = _VSTD::forward<_T2>(__p.second());
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
_LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return __first_;}
_LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return __first_;}
@@ -1866,7 +1942,7 @@ public:
_NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
__is_nothrow_swappable<_T1>::value)
{
using _STD::swap;
using _VSTD::swap;
swap(__first_, __x.__first_);
swap(__second_, __x.__second_);
}
@@ -1890,19 +1966,52 @@ public:
_LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {}
_LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1, int = 0)
: _T1(_STD::forward<_T1_param>(__t1)) {}
: _T1(_VSTD::forward<_T1_param>(__t1)) {}
_LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2, int* = 0)
: __second_(_STD::forward<_T2_param>(__t2)) {}
: __second_(_VSTD::forward<_T2_param>(__t2)) {}
_LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
: _T1(_STD::forward<_T1_param>(__t1)), __second_(_STD::forward<_T2_param>(__t2)) {}
: _T1(_VSTD::forward<_T1_param>(__t1)), __second_(_VSTD::forward<_T2_param>(__t2)) {}
#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p)
_NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value &&
is_nothrow_copy_constructible<_T2>::value)
: _T1(__p.first()), __second_(__p.second()) {}
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p)
_NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value &&
is_nothrow_copy_assignable<_T2>::value)
{
_T1::operator=(__p.first());
__second_ = __p.second();
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p)
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p)
_NOEXCEPT_(is_nothrow_move_constructible<_T1>::value &&
is_nothrow_move_constructible<_T2>::value)
: _T1(_STD::move(__p.first())), __second_(_STD::forward<_T2>(__p.second())) {}
: _T1(_VSTD::move(__p.first())), __second_(_VSTD::forward<_T2>(__p.second())) {}
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p)
_NOEXCEPT_(is_nothrow_move_assignable<_T1>::value &&
is_nothrow_move_assignable<_T2>::value)
{
_T1::operator=(_VSTD::move(__p.first()));
__second_ = _VSTD::forward<_T2>(__p.second());
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
_LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return *this;}
_LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return *this;}
@@ -1913,7 +2022,7 @@ public:
_NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
__is_nothrow_swappable<_T1>::value)
{
using _STD::swap;
using _VSTD::swap;
swap(__second_, __x.__second_);
}
};
@@ -1936,19 +2045,54 @@ public:
_LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {}
_LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1)
: __first_(_STD::forward<_T1_param>(__t1)) {}
: __first_(_VSTD::forward<_T1_param>(__t1)) {}
_LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2)
: _T2(_STD::forward<_T2_param>(__t2)) {}
: _T2(_VSTD::forward<_T2_param>(__t2)) {}
_LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
_NOEXCEPT_(is_nothrow_move_constructible<_T1>::value &&
is_nothrow_move_constructible<_T2>::value)
: _T2(_STD::forward<_T2_param>(__t2)), __first_(_STD::forward<_T1_param>(__t1)) {}
: _T2(_VSTD::forward<_T2_param>(__t2)), __first_(_VSTD::forward<_T1_param>(__t1)) {}
#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p)
_NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value &&
is_nothrow_copy_constructible<_T2>::value)
: _T2(__p.second()), __first_(__p.first()) {}
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p)
_NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value &&
is_nothrow_copy_assignable<_T2>::value)
{
_T2::operator=(__p.second());
__first_ = __p.first();
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p)
: _T2(_STD::forward<_T2>(__p.second())), __first_(_STD::move(__p.first())) {}
_NOEXCEPT_(is_nothrow_move_constructible<_T1>::value &&
is_nothrow_move_constructible<_T2>::value)
: _T2(_VSTD::forward<_T2>(__p.second())), __first_(_VSTD::move(__p.first())) {}
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p)
_NOEXCEPT_(is_nothrow_move_assignable<_T1>::value &&
is_nothrow_move_assignable<_T2>::value)
{
_T2::operator=(_VSTD::forward<_T2>(__p.second()));
__first_ = _VSTD::move(__p.first());
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
_LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return __first_;}
_LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return __first_;}
@@ -1959,7 +2103,7 @@ public:
_NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
__is_nothrow_swappable<_T1>::value)
{
using _STD::swap;
using _VSTD::swap;
swap(__first_, __x.__first_);
}
};
@@ -1981,19 +2125,52 @@ public:
_LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {}
_LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1)
: _T1(_STD::forward<_T1_param>(__t1)) {}
: _T1(_VSTD::forward<_T1_param>(__t1)) {}
_LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2)
: _T2(_STD::forward<_T2_param>(__t2)) {}
: _T2(_VSTD::forward<_T2_param>(__t2)) {}
_LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
: _T1(_STD::forward<_T1_param>(__t1)), _T2(_STD::forward<_T2_param>(__t2)) {}
: _T1(_VSTD::forward<_T1_param>(__t1)), _T2(_VSTD::forward<_T2_param>(__t2)) {}
#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p)
_NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value &&
is_nothrow_copy_constructible<_T2>::value)
: _T1(__p.first()), _T2(__p.second()) {}
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p)
_NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value &&
is_nothrow_copy_assignable<_T2>::value)
{
_T1::operator=(__p.first());
_T2::operator=(__p.second());
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p)
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p)
_NOEXCEPT_(is_nothrow_move_constructible<_T1>::value &&
is_nothrow_move_constructible<_T2>::value)
: _T1(_STD::move(__p.first())), _T2(_STD::move(__p.second())) {}
: _T1(_VSTD::move(__p.first())), _T2(_VSTD::move(__p.second())) {}
_LIBCPP_INLINE_VISIBILITY
__libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p)
_NOEXCEPT_(is_nothrow_move_assignable<_T1>::value &&
is_nothrow_move_assignable<_T2>::value)
{
_T1::operator=(_VSTD::move(__p.first()));
_T2::operator=(_VSTD::move(__p.second()));
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
_LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return *this;}
_LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return *this;}
@@ -2024,19 +2201,48 @@ public:
_LIBCPP_INLINE_VISIBILITY __compressed_pair() {}
_LIBCPP_INLINE_VISIBILITY explicit __compressed_pair(_T1_param __t1, int = 0)
: base(_STD::forward<_T1_param>(__t1)) {}
: base(_VSTD::forward<_T1_param>(__t1)) {}
_LIBCPP_INLINE_VISIBILITY explicit __compressed_pair(_T2_param __t2, int* = 0)
: base(_STD::forward<_T2_param>(__t2)) {}
: base(_VSTD::forward<_T2_param>(__t2)) {}
_LIBCPP_INLINE_VISIBILITY __compressed_pair(_T1_param __t1, _T2_param __t2)
: base(_STD::forward<_T1_param>(__t1), _STD::forward<_T2_param>(__t2)) {}
: base(_VSTD::forward<_T1_param>(__t1), _VSTD::forward<_T2_param>(__t2)) {}
#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
_LIBCPP_INLINE_VISIBILITY
__compressed_pair(const __compressed_pair& __p)
_NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value &&
is_nothrow_copy_constructible<_T2>::value)
: base(__p) {}
_LIBCPP_INLINE_VISIBILITY
__compressed_pair& operator=(const __compressed_pair& __p)
_NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value &&
is_nothrow_copy_assignable<_T2>::value)
{
base::operator=(__p);
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
__compressed_pair(__compressed_pair&& __p)
_NOEXCEPT_(is_nothrow_move_constructible<_T1>::value &&
is_nothrow_move_constructible<_T2>::value)
: base(_STD::move(__p)) {}
: base(_VSTD::move(__p)) {}
_LIBCPP_INLINE_VISIBILITY
__compressed_pair& operator=(__compressed_pair&& __p)
_NOEXCEPT_(is_nothrow_move_assignable<_T1>::value &&
is_nothrow_move_assignable<_T2>::value)
{
base::operator=(_VSTD::move(__p));
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
_LIBCPP_INLINE_VISIBILITY _T1_reference first() _NOEXCEPT {return base::first();}
_LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return base::first();}
@@ -2127,7 +2333,7 @@ public:
"unique_ptr constructed with null function pointer deleter");
}
_LIBCPP_INLINE_VISIBILITY explicit unique_ptr(pointer __p) _NOEXCEPT
: __ptr_(_STD::move(__p))
: __ptr_(_VSTD::move(__p))
{
static_assert(!is_pointer<deleter_type>::value,
"unique_ptr constructed with null function pointer deleter");
@@ -2143,12 +2349,12 @@ public:
_LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, typename remove_reference<deleter_type>::type&& __d)
_NOEXCEPT
: __ptr_(__p, _STD::move(__d))
: __ptr_(__p, _VSTD::move(__d))
{
static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
}
_LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr&& __u) _NOEXCEPT
: __ptr_(__u.release(), _STD::forward<deleter_type>(__u.get_deleter())) {}
: __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {}
template <class _Up, class _Ep>
_LIBCPP_INLINE_VISIBILITY
unique_ptr(unique_ptr<_Up, _Ep>&& __u,
@@ -2163,7 +2369,7 @@ public:
),
__nat
>::type = __nat()) _NOEXCEPT
: __ptr_(__u.release(), _STD::forward<_Ep>(__u.get_deleter())) {}
: __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {}
template <class _Up>
_LIBCPP_INLINE_VISIBILITY unique_ptr(auto_ptr<_Up>&& __p,
@@ -2179,7 +2385,7 @@ public:
_LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT
{
reset(__u.release());
__ptr_.second() = _STD::forward<deleter_type>(__u.get_deleter());
__ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
return *this;
}
@@ -2193,7 +2399,7 @@ public:
operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
{
reset(__u.release());
__ptr_.second() = _STD::forward<_Ep>(__u.get_deleter());
__ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
return *this;
}
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -2204,18 +2410,18 @@ public:
}
_LIBCPP_INLINE_VISIBILITY unique_ptr(__rv<unique_ptr> __u)
: __ptr_(__u->release(), _STD::forward<deleter_type>(__u->get_deleter())) {}
: __ptr_(__u->release(), _VSTD::forward<deleter_type>(__u->get_deleter())) {}
template <class _Up, class _Ep>
_LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr<_Up, _Ep> __u)
{
reset(__u.release());
__ptr_.second() = _STD::forward<deleter_type>(__u.get_deleter());
__ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
return *this;
}
_LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, deleter_type __d)
: __ptr_(_STD::move(__p), _STD::move(__d)) {}
: __ptr_(_VSTD::move(__p), _VSTD::move(__d)) {}
template <class _Up>
_LIBCPP_INLINE_VISIBILITY
@@ -2340,25 +2546,25 @@ public:
>
_LIBCPP_INLINE_VISIBILITY unique_ptr(_P __p, typename remove_reference<deleter_type>::type&& __d)
_NOEXCEPT
: __ptr_(__p, _STD::move(__d))
: __ptr_(__p, _VSTD::move(__d))
{
static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
}
_LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t, typename remove_reference<deleter_type>::type&& __d)
_NOEXCEPT
: __ptr_(pointer(), _STD::move(__d))
: __ptr_(pointer(), _VSTD::move(__d))
{
static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
}
_LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr&& __u) _NOEXCEPT
: __ptr_(__u.release(), _STD::forward<deleter_type>(__u.get_deleter())) {}
: __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {}
_LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT
{
reset(__u.release());
__ptr_.second() = _STD::forward<deleter_type>(__u.get_deleter());
__ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
return *this;
}
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -2371,10 +2577,10 @@ public:
}
_LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, deleter_type __d)
: __ptr_(__p, _STD::forward<deleter_type>(__d)) {}
: __ptr_(__p, _VSTD::forward<deleter_type>(__d)) {}
_LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t, deleter_type __d)
: __ptr_(pointer(), _STD::forward<deleter_type>(__d)) {}
: __ptr_(pointer(), _VSTD::forward<deleter_type>(__d)) {}
_LIBCPP_INLINE_VISIBILITY operator __rv<unique_ptr>()
{
@@ -2382,12 +2588,12 @@ public:
}
_LIBCPP_INLINE_VISIBILITY unique_ptr(__rv<unique_ptr> __u)
: __ptr_(__u->release(), _STD::forward<deleter_type>(__u->get_deleter())) {}
: __ptr_(__u->release(), _VSTD::forward<deleter_type>(__u->get_deleter())) {}
_LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(__rv<unique_ptr> __u)
{
reset(__u->release());
__ptr_.second() = _STD::forward<deleter_type>(__u->get_deleter());
__ptr_.second() = _VSTD::forward<deleter_type>(__u->get_deleter());
return *this;
}
@@ -2507,7 +2713,7 @@ inline _LIBCPP_INLINE_VISIBILITY
bool
operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);}
template <class> struct hash;
template <class _Tp> struct hash;
template<class _Tp>
struct _LIBCPP_VISIBLE hash<_Tp*>
@@ -2697,9 +2903,7 @@ public:
long use_count() const _NOEXCEPT {return __shared_count::use_count();}
__shared_weak_count* lock() _NOEXCEPT;
#ifndef _LIBCPP_NO_RTTI
virtual const void* __get_deleter(const type_info&) const _NOEXCEPT;
#endif
private:
virtual void __on_zero_shared_weak() _NOEXCEPT = 0;
};
@@ -2712,7 +2916,7 @@ class __shared_ptr_pointer
public:
_LIBCPP_INLINE_VISIBILITY
__shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a)
: __data_(__compressed_pair<_Tp, _Dp>(__p, _STD::move(__d)), _STD::move(__a)) {}
: __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a)) {}
#ifndef _LIBCPP_NO_RTTI
virtual const void* __get_deleter(const type_info&) const _NOEXCEPT;
@@ -2761,12 +2965,12 @@ public:
_LIBCPP_INLINE_VISIBILITY
__shared_ptr_emplace(_Alloc __a)
: __data_(_STD::move(__a)) {}
: __data_(_VSTD::move(__a)) {}
template <class ..._Args>
_LIBCPP_INLINE_VISIBILITY
__shared_ptr_emplace(_Alloc __a, _Args&& ...__args)
: __data_(_STD::move(__a), _Tp(_STD::forward<_Args>(__args)...)) {}
: __data_(_VSTD::move(__a), _Tp(_VSTD::forward<_Args>(__args)...)) {}
#else // _LIBCPP_HAS_NO_VARIADICS
@@ -3231,7 +3435,7 @@ shared_ptr<_Tp>::make_shared(_Args&& ...__args)
typedef __allocator_destructor<_A2> _D2;
_A2 __a2;
unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
::new(__hold2.get()) _CntrlBlk(__a2, _STD::forward<_Args>(__args)...);
::new(__hold2.get()) _CntrlBlk(__a2, _VSTD::forward<_Args>(__args)...);
shared_ptr<_Tp> __r;
__r.__ptr_ = __hold2.get()->get();
__r.__cntrl_ = __hold2.release();
@@ -3249,7 +3453,7 @@ shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _Args&& ...__args)
typedef __allocator_destructor<_A2> _D2;
_A2 __a2(__a);
unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
::new(__hold2.get()) _CntrlBlk(__a, _STD::forward<_Args>(__args)...);
::new(__hold2.get()) _CntrlBlk(__a, _VSTD::forward<_Args>(__args)...);
shared_ptr<_Tp> __r;
__r.__ptr_ = __hold2.get()->get();
__r.__cntrl_ = __hold2.release();
@@ -3437,7 +3641,7 @@ inline _LIBCPP_INLINE_VISIBILITY
shared_ptr<_Tp>&
shared_ptr<_Tp>::operator=(shared_ptr&& __r) _NOEXCEPT
{
shared_ptr(_STD::move(__r)).swap(*this);
shared_ptr(_VSTD::move(__r)).swap(*this);
return *this;
}
@@ -3447,7 +3651,7 @@ inline _LIBCPP_INLINE_VISIBILITY
shared_ptr<_Tp>&
shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r)
{
shared_ptr(_STD::move(__r)).swap(*this);
shared_ptr(_VSTD::move(__r)).swap(*this);
return *this;
}
@@ -3457,7 +3661,7 @@ inline _LIBCPP_INLINE_VISIBILITY
shared_ptr<_Tp>&
shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r)
{
shared_ptr(_STD::move(__r)).swap(*this);
shared_ptr(_VSTD::move(__r)).swap(*this);
return *this;
}
@@ -3467,7 +3671,7 @@ inline _LIBCPP_INLINE_VISIBILITY
shared_ptr<_Tp>&
shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r)
{
shared_ptr(_STD::move(__r)).swap(*this);
shared_ptr(_VSTD::move(__r)).swap(*this);
return *this;
}
@@ -3489,7 +3693,7 @@ inline _LIBCPP_INLINE_VISIBILITY
shared_ptr<_Tp>&
shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp> __r)
{
shared_ptr(_STD::move(__r)).swap(*this);
shared_ptr(_VSTD::move(__r)).swap(*this);
return *this;
}
@@ -3500,8 +3704,8 @@ inline _LIBCPP_INLINE_VISIBILITY
void
shared_ptr<_Tp>::swap(shared_ptr& __r) _NOEXCEPT
{
_STD::swap(__ptr_, __r.__ptr_);
_STD::swap(__cntrl_, __r.__cntrl_);
_VSTD::swap(__ptr_, __r.__ptr_);
_VSTD::swap(__cntrl_, __r.__cntrl_);
}
template<class _Tp>
@@ -3546,7 +3750,7 @@ inline _LIBCPP_INLINE_VISIBILITY
shared_ptr<_Tp>
make_shared(_Args&& ...__args)
{
return shared_ptr<_Tp>::make_shared(_STD::forward<_Args>(__args)...);
return shared_ptr<_Tp>::make_shared(_VSTD::forward<_Args>(__args)...);
}
template<class _Tp, class _Alloc, class ..._Args>
@@ -3554,7 +3758,7 @@ inline _LIBCPP_INLINE_VISIBILITY
shared_ptr<_Tp>
allocate_shared(const _Alloc& __a, _Args&& ...__args)
{
return shared_ptr<_Tp>::allocate_shared(__a, _STD::forward<_Args>(__args)...);
return shared_ptr<_Tp>::allocate_shared(__a, _VSTD::forward<_Args>(__args)...);
}
#else // _LIBCPP_HAS_NO_VARIADICS
@@ -3826,8 +4030,8 @@ inline _LIBCPP_INLINE_VISIBILITY
void
weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT
{
_STD::swap(__ptr_, __r.__ptr_);
_STD::swap(__cntrl_, __r.__cntrl_);
_VSTD::swap(__ptr_, __r.__ptr_);
_VSTD::swap(__cntrl_, __r.__cntrl_);
}
template<class _Tp>
@@ -3943,6 +4147,11 @@ struct _LIBCPP_VISIBLE hash<shared_ptr<_Tp> >
}
};
template<class _CharT, class _Traits, class _Y>
inline _LIBCPP_INLINE_VISIBILITY
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Y> const& __p);
//enum class
struct _LIBCPP_VISIBLE pointer_safety
{
@@ -3965,7 +4174,7 @@ void declare_reachable(void* __p);
void declare_no_pointers(char* __p, size_t __n);
void undeclare_no_pointers(char* __p, size_t __n);
pointer_safety get_pointer_safety() _NOEXCEPT;
void* __undeclare_reachable(void*);
void* __undeclare_reachable(void* __p);
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
@@ -3975,7 +4184,7 @@ undeclare_reachable(_Tp* __p)
return static_cast<_Tp*>(__undeclare_reachable(__p));
}
void* align(size_t, size_t, void*&, size_t&);
void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
_LIBCPP_END_NAMESPACE_STD

View File

@@ -467,7 +467,7 @@ class __call_once_param
public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
explicit __call_once_param(_F&& __f) : __f_(_STD::move(__f)) {}
explicit __call_once_param(_F&& __f) : __f_(_VSTD::move(__f)) {}
#else
_LIBCPP_INLINE_VISIBILITY
explicit __call_once_param(const _F& __f) : __f_(__f) {}
@@ -485,7 +485,7 @@ private:
_LIBCPP_INLINE_VISIBILITY
void __execute(__tuple_indices<_Indices...>)
{
__invoke(_STD::move(_STD::get<0>(__f_)), _STD::move(_STD::get<_Indices>(__f_))...);
__invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...);
}
};
@@ -498,7 +498,7 @@ class __call_once_param
public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
explicit __call_once_param(_F&& __f) : __f_(_STD::move(__f)) {}
explicit __call_once_param(_F&& __f) : __f_(_VSTD::move(__f)) {}
#else
_LIBCPP_INLINE_VISIBILITY
explicit __call_once_param(const _F& __f) : __f_(__f) {}
@@ -533,8 +533,8 @@ call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args)
if (__builtin_expect(__flag.__state_ , ~0ul) != ~0ul)
{
typedef tuple<typename decay<_Callable>::type, typename decay<_Args>::type...> _G;
__call_once_param<_G> __p(_G(__decay_copy(_STD::forward<_Callable>(__func)),
__decay_copy(_STD::forward<_Args>(__args))...));
__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<_G>);
}
}

View File

@@ -89,23 +89,23 @@ _LIBCPP_VISIBLE new_handler get_new_handler() _NOEXCEPT;
} // std
_LIBCPP_VISIBLE void* operator new(std::size_t)
_LIBCPP_VISIBLE void* operator new(std::size_t __sz)
#if !__has_feature(cxx_noexcept)
throw(std::bad_alloc)
#endif
;
_LIBCPP_VISIBLE void* operator new(std::size_t, const std::nothrow_t&) _NOEXCEPT;
_LIBCPP_VISIBLE void operator delete(void*) _NOEXCEPT;
_LIBCPP_VISIBLE void operator delete(void*, const std::nothrow_t&) _NOEXCEPT;
_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;
_LIBCPP_VISIBLE void* operator new[](std::size_t)
_LIBCPP_VISIBLE void* operator new[](std::size_t __sz)
#if !__has_feature(cxx_noexcept)
throw(std::bad_alloc)
#endif
;
_LIBCPP_VISIBLE void* operator new[](std::size_t, const std::nothrow_t&) _NOEXCEPT;
_LIBCPP_VISIBLE void operator delete[](void*) _NOEXCEPT;
_LIBCPP_VISIBLE void operator delete[](void*, const std::nothrow_t&) _NOEXCEPT;
_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;
_LIBCPP_INLINE_VISIBILITY inline void* operator new (std::size_t, void* __p) _NOEXCEPT {return __p;}
_LIBCPP_INLINE_VISIBILITY inline void* operator new[](std::size_t, void* __p) _NOEXCEPT {return __p;}

View File

@@ -154,11 +154,13 @@ public:
virtual ~basic_ostream();
protected:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
basic_ostream(basic_ostream&& __rhs);
#endif
// 27.7.2.3 Assign/swap
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
basic_ostream& operator=(basic_ostream&& __rhs);
#endif
void swap(basic_ostream& __rhs);

View File

@@ -211,7 +211,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
queue(queue&& __q)
_NOEXCEPT_(is_nothrow_move_constructible<container_type>::value)
: c(_STD::move(__q.c)) {}
: c(_VSTD::move(__q.c)) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
@@ -221,14 +221,14 @@ public:
_LIBCPP_INLINE_VISIBILITY
queue& operator=(queue&& __q)
_NOEXCEPT_(is_nothrow_move_assignable<container_type>::value)
{c = _STD::move(__q.c); return *this;}
{c = _VSTD::move(__q.c); return *this;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
explicit queue(const container_type& __c) : c(__c) {}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
explicit queue(container_type&& __c) : c(_STD::move(__c)) {}
explicit queue(container_type&& __c) : c(_VSTD::move(__c)) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
@@ -254,13 +254,13 @@ public:
queue(container_type&& __c, const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0)
: c(_STD::move(__c), __a) {}
: c(_VSTD::move(__c), __a) {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
queue(queue&& __q, const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0)
: c(_STD::move(__q.c), __a) {}
: c(_VSTD::move(__q.c), __a) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -282,12 +282,12 @@ public:
void push(const value_type& __v) {c.push_back(__v);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
void push(value_type&& __v) {c.push_back(_STD::move(__v));}
void push(value_type&& __v) {c.push_back(_VSTD::move(__v));}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
void emplace(_Args&&... __args)
{c.emplace_back(_STD::forward<_Args>(__args)...);}
{c.emplace_back(_VSTD::forward<_Args>(__args)...);}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
@@ -297,7 +297,7 @@ public:
void swap(queue& __q)
_NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
{
using _STD::swap;
using _VSTD::swap;
swap(c, __q.c);
}
@@ -408,7 +408,7 @@ public:
priority_queue(priority_queue&& __q)
_NOEXCEPT_(is_nothrow_move_constructible<container_type>::value &&
is_nothrow_move_constructible<value_compare>::value)
: c(_STD::move(__q.c)), comp(_STD::move(__q.comp)) {}
: c(_VSTD::move(__q.c)), comp(_VSTD::move(__q.comp)) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
@@ -420,7 +420,7 @@ public:
priority_queue& operator=(priority_queue&& __q)
_NOEXCEPT_(is_nothrow_move_assignable<container_type>::value &&
is_nothrow_move_assignable<value_compare>::value)
{c = _STD::move(__q.c); comp = _STD::move(__q.comp); return *this;}
{c = _VSTD::move(__q.c); comp = _VSTD::move(__q.comp); return *this;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
@@ -498,7 +498,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp
: c(__c),
comp(__comp)
{
_STD::make_heap(c.begin(), c.end(), comp);
_VSTD::make_heap(c.begin(), c.end(), comp);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -507,10 +507,10 @@ template <class _Tp, class _Container, class _Compare>
inline _LIBCPP_INLINE_VISIBILITY
priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
container_type&& __c)
: c(_STD::move(__c)),
: c(_VSTD::move(__c)),
comp(__comp)
{
_STD::make_heap(c.begin(), c.end(), comp);
_VSTD::make_heap(c.begin(), c.end(), comp);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -523,7 +523,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
: c(__f, __l),
comp(__comp)
{
_STD::make_heap(c.begin(), c.end(), comp);
_VSTD::make_heap(c.begin(), c.end(), comp);
}
template <class _Tp, class _Container, class _Compare>
@@ -536,7 +536,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
comp(__comp)
{
c.insert(c.end(), __f, __l);
_STD::make_heap(c.begin(), c.end(), comp);
_VSTD::make_heap(c.begin(), c.end(), comp);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -547,11 +547,11 @@ inline _LIBCPP_INLINE_VISIBILITY
priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
const value_compare& __comp,
container_type&& __c)
: c(_STD::move(__c)),
: c(_VSTD::move(__c)),
comp(__comp)
{
c.insert(c.end(), __f, __l);
_STD::make_heap(c.begin(), c.end(), comp);
_VSTD::make_heap(c.begin(), c.end(), comp);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -589,7 +589,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
: c(__c, __a),
comp(__comp)
{
_STD::make_heap(c.begin(), c.end(), comp);
_VSTD::make_heap(c.begin(), c.end(), comp);
}
template <class _Tp, class _Container, class _Compare>
@@ -602,7 +602,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const priority_queue&
: c(__q.c, __a),
comp(__q.comp)
{
_STD::make_heap(c.begin(), c.end(), comp);
_VSTD::make_heap(c.begin(), c.end(), comp);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -615,10 +615,10 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type*)
: c(_STD::move(__c), __a),
: c(_VSTD::move(__c), __a),
comp(__comp)
{
_STD::make_heap(c.begin(), c.end(), comp);
_VSTD::make_heap(c.begin(), c.end(), comp);
}
template <class _Tp, class _Container, class _Compare>
@@ -628,10 +628,10 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q,
const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type*)
: c(_STD::move(__q.c), __a),
comp(_STD::move(__q.comp))
: c(_VSTD::move(__q.c), __a),
comp(_VSTD::move(__q.comp))
{
_STD::make_heap(c.begin(), c.end(), comp);
_VSTD::make_heap(c.begin(), c.end(), comp);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -642,7 +642,7 @@ void
priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v)
{
c.push_back(__v);
_STD::push_heap(c.begin(), c.end(), comp);
_VSTD::push_heap(c.begin(), c.end(), comp);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -652,8 +652,8 @@ inline _LIBCPP_INLINE_VISIBILITY
void
priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v)
{
c.push_back(_STD::move(__v));
_STD::push_heap(c.begin(), c.end(), comp);
c.push_back(_VSTD::move(__v));
_VSTD::push_heap(c.begin(), c.end(), comp);
}
#ifndef _LIBCPP_HAS_NO_VARIADICS
@@ -664,8 +664,8 @@ inline _LIBCPP_INLINE_VISIBILITY
void
priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args)
{
c.emplace_back(_STD::forward<_Args>(__args)...);
_STD::push_heap(c.begin(), c.end(), comp);
c.emplace_back(_VSTD::forward<_Args>(__args)...);
_VSTD::push_heap(c.begin(), c.end(), comp);
}
#endif // _LIBCPP_HAS_NO_VARIADICS
@@ -676,7 +676,7 @@ inline _LIBCPP_INLINE_VISIBILITY
void
priority_queue<_Tp, _Container, _Compare>::pop()
{
_STD::pop_heap(c.begin(), c.end(), comp);
_VSTD::pop_heap(c.begin(), c.end(), comp);
c.pop_back();
}
@@ -687,7 +687,7 @@ priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q)
_NOEXCEPT_(__is_nothrow_swappable<container_type>::value &&
__is_nothrow_swappable<value_compare>::value)
{
using _STD::swap;
using _VSTD::swap;
swap(c, __q.c);
swap(comp, __q.comp);
}

View File

@@ -2313,37 +2313,37 @@ operator==(const mersenne_twister_engine<_UI, _W, _N, _M, _R, _A, _U, _D, _S,
_B, _T, _C, _L, _F>& __y)
{
if (__x.__i_ == __y.__i_)
return _STD::equal(__x.__x_, __x.__x_ + _N, __y.__x_);
return _VSTD::equal(__x.__x_, __x.__x_ + _N, __y.__x_);
if (__x.__i_ == 0 || __y.__i_ == 0)
{
size_t __j = _STD::min(_N - __x.__i_, _N - __y.__i_);
if (!_STD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
size_t __j = _VSTD::min(_N - __x.__i_, _N - __y.__i_);
if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
__y.__x_ + __y.__i_))
return false;
if (__x.__i_ == 0)
return _STD::equal(__x.__x_ + __j, __x.__x_ + _N, __y.__x_);
return _STD::equal(__x.__x_, __x.__x_ + (_N - __j), __y.__x_ + __j);
return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _N, __y.__x_);
return _VSTD::equal(__x.__x_, __x.__x_ + (_N - __j), __y.__x_ + __j);
}
if (__x.__i_ < __y.__i_)
{
size_t __j = _N - __y.__i_;
if (!_STD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
__y.__x_ + __y.__i_))
return false;
if (!_STD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _N,
if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _N,
__y.__x_))
return false;
return _STD::equal(__x.__x_, __x.__x_ + __x.__i_,
return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
__y.__x_ + (_N - (__x.__i_ + __j)));
}
size_t __j = _N - __x.__i_;
if (!_STD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
__x.__x_ + __x.__i_))
return false;
if (!_STD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _N,
if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _N,
__x.__x_))
return false;
return _STD::equal(__y.__x_, __y.__x_ + __y.__i_,
return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
__x.__x_ + (_N - (__y.__i_ + __j)));
}
@@ -2562,8 +2562,11 @@ subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
__e(__sd == 0u ? default_seed : __sd);
for (size_t __i = 0; __i < __r; ++__i)
{
result_type __e0 = __e();
__x_[__i] = static_cast<result_type>(
(__e() + ((uint64_t)__e() << 32)) & _Max);
(__e0 + ((uint64_t)__e() << 32)) & _Max);
}
__c_ = __x_[__r-1] == 0;
__i_ = 0;
}
@@ -2621,37 +2624,37 @@ operator==(
if (__x.__c_ != __y.__c_)
return false;
if (__x.__i_ == __y.__i_)
return _STD::equal(__x.__x_, __x.__x_ + _R, __y.__x_);
return _VSTD::equal(__x.__x_, __x.__x_ + _R, __y.__x_);
if (__x.__i_ == 0 || __y.__i_ == 0)
{
size_t __j = _STD::min(_R - __x.__i_, _R - __y.__i_);
if (!_STD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
size_t __j = _VSTD::min(_R - __x.__i_, _R - __y.__i_);
if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
__y.__x_ + __y.__i_))
return false;
if (__x.__i_ == 0)
return _STD::equal(__x.__x_ + __j, __x.__x_ + _R, __y.__x_);
return _STD::equal(__x.__x_, __x.__x_ + (_R - __j), __y.__x_ + __j);
return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _R, __y.__x_);
return _VSTD::equal(__x.__x_, __x.__x_ + (_R - __j), __y.__x_ + __j);
}
if (__x.__i_ < __y.__i_)
{
size_t __j = _R - __y.__i_;
if (!_STD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
__y.__x_ + __y.__i_))
return false;
if (!_STD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _R,
if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _R,
__y.__x_))
return false;
return _STD::equal(__x.__x_, __x.__x_ + __x.__i_,
return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
__y.__x_ + (_R - (__x.__i_ + __j)));
}
size_t __j = _R - __x.__i_;
if (!_STD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
__x.__x_ + __x.__i_))
return false;
if (!_STD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _R,
if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _R,
__x.__x_))
return false;
return _STD::equal(__y.__x_, __y.__x_ + __y.__i_,
return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
__x.__x_ + (_R - (__y.__i_ + __j)));
}
@@ -2744,7 +2747,7 @@ public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
explicit discard_block_engine(_Engine&& __e)
: __e_(_STD::move(__e)), __n_(0) {}
: __e_(_VSTD::move(__e)), __n_(0) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {}
@@ -2944,7 +2947,7 @@ public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
explicit independent_bits_engine(_Engine&& __e)
: __e_(_STD::move(__e)) {}
: __e_(_VSTD::move(__e)) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
@@ -3167,7 +3170,7 @@ public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
explicit shuffle_order_engine(_Engine&& __e)
: __e_(_STD::move(__e)) {__init();}
: __e_(_VSTD::move(__e)) {__init();}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();}
@@ -3292,7 +3295,7 @@ operator==(
const shuffle_order_engine<_Eng, _K>& __x,
const shuffle_order_engine<_Eng, _K>& __y)
{
return __x._Y_ == __y._Y_ && _STD::equal(__x._V_, __x._V_ + _K, __y._V_) &&
return __x._Y_ == __y._Y_ && _VSTD::equal(__x._V_, __x._V_ + _K, __y._V_) &&
__x.__e_ == __y.__e_;
}
@@ -3399,9 +3402,11 @@ public:
// constructors
_LIBCPP_INLINE_VISIBILITY
seed_seq() {}
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _Tp>
_LIBCPP_INLINE_VISIBILITY
seed_seq(initializer_list<_Tp> __il) {init(__il.begin(), __il.end());}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _InputIterator>
_LIBCPP_INLINE_VISIBILITY
@@ -3418,7 +3423,7 @@ public:
template<class _OutputIterator>
_LIBCPP_INLINE_VISIBILITY
void param(_OutputIterator __dest) const
{_STD::copy(__v_.begin(), __v_.end(), __dest);}
{_VSTD::copy(__v_.begin(), __v_.end(), __dest);}
private:
// no copy functions
@@ -3443,7 +3448,7 @@ seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
if (__first != __last)
{
_STD::fill(__first, __last, 0x8b8b8b8b);
_VSTD::fill(__first, __last, 0x8b8b8b8b);
const size_t __n = static_cast<size_t>(__last - __first);
const size_t __s = __v_.size();
const size_t __t = (__n >= 623) ? 11
@@ -3453,7 +3458,7 @@ seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last)
: (__n - 1) / 2;
const size_t __p = (__n - __t) / 2;
const size_t __q = __p + __t;
const size_t __m = _STD::max(__s + 1, __n);
const size_t __m = _VSTD::max(__s + 1, __n);
// __k = 0;
{
result_type __r = 1664525 * _T(__first[0] ^ __first[__p]
@@ -3639,7 +3644,7 @@ typename uniform_real_distribution<_RealType>::result_type
uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
{
return (__p.b() - __p.a())
* _STD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
* _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
+ __p.a();
}
@@ -3871,9 +3876,9 @@ binomial_distribution<_IntType>::param_type::param_type(result_type __t, double
if (0 < __p_ && __p_ < 1)
{
__r0_ = static_cast<result_type>((__t_ + 1) * __p_);
__pr_ = _STD::exp(_STD::lgamma(__t_ + 1.) - _STD::lgamma(__r0_ + 1.) -
_STD::lgamma(__t_ - __r0_ + 1.) + __r0_ * _STD::log(__p_) +
(__t_ - __r0_) * _STD::log(1 - __p_));
__pr_ = _VSTD::exp(_VSTD::lgamma(__t_ + 1.) - _VSTD::lgamma(__r0_ + 1.) -
_VSTD::lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) +
(__t_ - __r0_) * _VSTD::log(1 - __p_));
__odds_ratio_ = __p_ / (1 - __p_);
}
}
@@ -4025,10 +4030,10 @@ template<class _URNG>
_RealType
exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
{
return -_STD::log
return -_VSTD::log
(
result_type(1) -
_STD::generate_canonical<result_type,
_VSTD::generate_canonical<result_type,
numeric_limits<result_type>::digits>(__g)
)
/ __p.lambda();
@@ -4180,7 +4185,7 @@ normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
__v = _Uni(__g);
__s = __u * __u + __v * __v;
} while (__s > 1 || __s == 0);
result_type _F = _STD::sqrt(-2 * _STD::log(__s) / __s);
result_type _F = _VSTD::sqrt(-2 * _VSTD::log(__s) / __s);
_V_ = __v * _F;
_V_hot_ = true;
_U = __u * _F;
@@ -4297,7 +4302,7 @@ public:
template<class _URNG>
_LIBCPP_INLINE_VISIBILITY
result_type operator()(_URNG& __g, const param_type& __p)
{return _STD::exp(const_cast<normal_distribution<result_type>&>(__p.__nd_)(__g));}
{return _VSTD::exp(const_cast<normal_distribution<result_type>&>(__p.__nd_)(__g));}
// property functions
_LIBCPP_INLINE_VISIBILITY
@@ -4446,7 +4451,7 @@ poisson_distribution<_IntType>::param_type::param_type(double __mean)
{
__s_ = 0;
__d_ = 0;
__l_ = _STD::exp(-__mean_);
__l_ = _VSTD::exp(-__mean_);
__omega_ = 0;
__c3_ = 0;
__c2_ = 0;
@@ -4456,7 +4461,7 @@ poisson_distribution<_IntType>::param_type::param_type(double __mean)
}
else
{
__s_ = _STD::sqrt(__mean_);
__s_ = _VSTD::sqrt(__mean_);
__d_ = 6 * __mean_ * __mean_;
__l_ = static_cast<result_type>(__mean_ - 1.1484);
__omega_ = .3989423 / __s_;
@@ -4523,20 +4528,20 @@ poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr
const result_type __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040,
40320, 362880};
__px = -__pr.__mean_;
__py = _STD::pow(__pr.__mean_, (double)__x) / __fac[__x];
__py = _VSTD::pow(__pr.__mean_, (double)__x) / __fac[__x];
}
else
{
double __del = .8333333E-1 / __x;
__del -= 4.8 * __del * __del * __del;
double __v = __difmuk / __x;
if (_STD::abs(__v) > 0.25)
__px = __x * _STD::log(1 + __v) - __difmuk - __del;
if (_VSTD::abs(__v) > 0.25)
__px = __x * _VSTD::log(1 + __v) - __difmuk - __del;
else
__px = __x * __v * __v * (((((((.1250060 * __v + -.1384794) *
__v + .1421878) * __v + -.1661269) * __v + .2000118) *
__v + -.2500068) * __v + .3333333) * __v + -.5) - __del;
__py = .3989423 / _STD::sqrt(__x);
__py = .3989423 / _VSTD::sqrt(__x);
}
double __r = (0.5 - __difmuk) / __pr.__s_;
double __r2 = __r * __r;
@@ -4545,13 +4550,13 @@ poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr
__r2 + __pr.__c1_) * __r2 + __pr.__c0_);
if (__using_exp_dist)
{
if (__pr.__c_ * _STD::abs(__u) <= __py * _STD::exp(__px + __e) -
__fy * _STD::exp(__fx + __e))
if (__pr.__c_ * _VSTD::abs(__u) <= __py * _VSTD::exp(__px + __e) -
__fy * _VSTD::exp(__fx + __e))
break;
}
else
{
if (__fy - __u * __fy <= __py * _STD::exp(__px - __fx))
if (__fy - __u * __fy <= __py * _VSTD::exp(__px - __fx))
break;
}
}
@@ -4642,7 +4647,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
result_type operator()(_URNG& __g, const param_type& __p)
{return __p.b() *
_STD::pow(exponential_distribution<result_type>()(__g), 1/__p.a());}
_VSTD::pow(exponential_distribution<result_type>()(__g), 1/__p.a());}
// property functions
_LIBCPP_INLINE_VISIBILITY
@@ -4786,7 +4791,7 @@ _RealType
extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
{
return __p.a() - __p.b() *
_STD::log(-_STD::log(1-uniform_real_distribution<result_type>()(__g)));
_VSTD::log(-_VSTD::log(1-uniform_real_distribution<result_type>()(__g)));
}
template <class _CharT, class _Traits, class _RT>
@@ -4923,7 +4928,7 @@ gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
const result_type __w = __u * (1 - __u);
if (__w != 0)
{
const result_type __y = _STD::sqrt(__c / __w) *
const result_type __y = _VSTD::sqrt(__c / __w) *
(__u - result_type(0.5));
__x = __b + __y;
if (__x >= 0)
@@ -4931,7 +4936,7 @@ gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
const result_type __z = 64 * __w * __w * __w * __v * __v;
if (__z <= 1 - 2 * __y * __y / __x)
break;
if (_STD::log(__z) <= 2 * (__b * _STD::log(__x / __b) - __y))
if (_VSTD::log(__z) <= 2 * (__b * _VSTD::log(__x / __b) - __y))
break;
}
}
@@ -4945,14 +4950,14 @@ gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
const result_type __es = __egen(__g);
if (__u <= 1 - __a)
{
__x = _STD::pow(__u, 1 / __a);
__x = _VSTD::pow(__u, 1 / __a);
if (__x <= __es)
break;
}
else
{
const result_type __e = -_STD::log((1-__u)/__a);
__x = _STD::pow(1 - __a + __a * __e, 1 / __a);
const result_type __e = -_VSTD::log((1-__u)/__a);
__x = _VSTD::pow(1 - __a + __a * __e, 1 / __a);
if (__x <= __e + __es)
break;
}
@@ -5424,7 +5429,7 @@ cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
{
uniform_real_distribution<result_type> __gen;
// purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite
return __p.a() + __p.b() * _STD::tan(3.1415926535897932384626433832795 * __gen(__g));
return __p.a() + __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g));
}
template <class _CharT, class _Traits, class _RT>
@@ -5662,7 +5667,7 @@ _RealType
student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
{
gamma_distribution<result_type> __gd(__p.n() * .5, 2);
return __nd_(__g) * _STD::sqrt(__p.n()/__gd(__g));
return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g));
}
template <class _CharT, class _Traits, class _RT>
@@ -5715,9 +5720,11 @@ public:
_LIBCPP_INLINE_VISIBILITY
param_type(_InputIterator __f, _InputIterator __l)
: __p_(__f, __l) {__init();}
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
_LIBCPP_INLINE_VISIBILITY
param_type(initializer_list<double> __wl)
: __p_(__wl.begin(), __wl.end()) {__init();}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _UnaryOperation>
param_type(size_t __nw, double __xmin, double __xmax,
_UnaryOperation __fw);
@@ -5760,9 +5767,11 @@ public:
_LIBCPP_INLINE_VISIBILITY
discrete_distribution(_InputIterator __f, _InputIterator __l)
: __p_(__f, __l) {}
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
_LIBCPP_INLINE_VISIBILITY
discrete_distribution(initializer_list<double> __wl)
: __p_(__wl) {}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _UnaryOperation>
_LIBCPP_INLINE_VISIBILITY
discrete_distribution(size_t __nw, double __xmin, double __xmax,
@@ -5843,12 +5852,12 @@ discrete_distribution<_IntType>::param_type::__init()
{
if (__p_.size() > 1)
{
double __s = _STD::accumulate(__p_.begin(), __p_.end(), 0.0);
for (_STD::vector<double>::iterator __i = __p_.begin(), __e = __p_.end();
double __s = _VSTD::accumulate(__p_.begin(), __p_.end(), 0.0);
for (_VSTD::vector<double>::iterator __i = __p_.begin(), __e = __p_.end();
__i < __e; ++__i)
*__i /= __s;
vector<double> __t(__p_.size() - 1);
_STD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin());
_VSTD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin());
swap(__p_, __t);
}
else
@@ -5864,8 +5873,8 @@ vector<double>
discrete_distribution<_IntType>::param_type::probabilities() const
{
size_t __n = __p_.size();
_STD::vector<double> __p(__n+1);
_STD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin());
_VSTD::vector<double> __p(__n+1);
_VSTD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin());
if (__n > 0)
__p[__n] = 1 - __p_[__n-1];
else
@@ -5880,7 +5889,7 @@ discrete_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
{
uniform_real_distribution<double> __gen;
return static_cast<_IntType>(
_STD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) -
_VSTD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) -
__p.__p_.begin());
}
@@ -5942,8 +5951,10 @@ public:
template<class _InputIteratorB, class _InputIteratorW>
param_type(_InputIteratorB __fB, _InputIteratorB __lB,
_InputIteratorW __fW);
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _UnaryOperation>
param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _UnaryOperation>
param_type(size_t __nw, result_type __xmin, result_type __xmax,
_UnaryOperation __fw);
@@ -5993,11 +6004,13 @@ public:
_InputIteratorW __fW)
: __p_(__fB, __lB, __fW) {}
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _UnaryOperation>
_LIBCPP_INLINE_VISIBILITY
piecewise_constant_distribution(initializer_list<result_type> __bl,
_UnaryOperation __fw)
: __p_(__bl, __fw) {}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _UnaryOperation>
_LIBCPP_INLINE_VISIBILITY
@@ -6079,14 +6092,14 @@ void
piecewise_constant_distribution<_RealType>::param_type::__init()
{
// __densities_ contains non-normalized areas
result_type __total_area = _STD::accumulate(__densities_.begin(),
result_type __total_area = _VSTD::accumulate(__densities_.begin(),
__densities_.end(),
result_type());
for (size_t __i = 0; __i < __densities_.size(); ++__i)
__densities_[__i] /= __total_area;
// __densities_ contains normalized areas
__areas_.assign(__densities_.size(), result_type());
_STD::partial_sum(__densities_.begin(), __densities_.end() - 1,
_VSTD::partial_sum(__densities_.begin(), __densities_.end() - 1,
__areas_.begin() + 1);
// __areas_ contains partial sums of normalized areas: [0, __densities_ - 1]
__densities_.back() = 1 - __areas_.back(); // correct round off error
@@ -6127,6 +6140,8 @@ piecewise_constant_distribution<_RealType>::param_type::param_type(
}
}
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _RealType>
template<class _UnaryOperation>
piecewise_constant_distribution<_RealType>::param_type::param_type(
@@ -6150,6 +6165,8 @@ piecewise_constant_distribution<_RealType>::param_type::param_type(
}
}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _RealType>
template<class _UnaryOperation>
piecewise_constant_distribution<_RealType>::param_type::param_type(
@@ -6175,7 +6192,7 @@ piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_t
{
typedef uniform_real_distribution<result_type> _Gen;
result_type __u = _Gen()(__g);
ptrdiff_t __k = _STD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
__u) - __p.__areas_.begin() - 1;
return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k];
}
@@ -6258,8 +6275,10 @@ public:
template<class _InputIteratorB, class _InputIteratorW>
param_type(_InputIteratorB __fB, _InputIteratorB __lB,
_InputIteratorW __fW);
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _UnaryOperation>
param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _UnaryOperation>
param_type(size_t __nw, result_type __xmin, result_type __xmax,
_UnaryOperation __fw);
@@ -6309,11 +6328,13 @@ public:
_InputIteratorW __fW)
: __p_(__fB, __lB, __fW) {}
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _UnaryOperation>
_LIBCPP_INLINE_VISIBILITY
piecewise_linear_distribution(initializer_list<result_type> __bl,
_UnaryOperation __fw)
: __p_(__bl, __fw) {}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _UnaryOperation>
_LIBCPP_INLINE_VISIBILITY
@@ -6447,6 +6468,8 @@ piecewise_linear_distribution<_RealType>::param_type::param_type(
}
}
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _RealType>
template<class _UnaryOperation>
piecewise_linear_distribution<_RealType>::param_type::param_type(
@@ -6470,6 +6493,8 @@ piecewise_linear_distribution<_RealType>::param_type::param_type(
}
}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template<class _RealType>
template<class _UnaryOperation>
piecewise_linear_distribution<_RealType>::param_type::param_type(
@@ -6496,7 +6521,7 @@ piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_typ
{
typedef uniform_real_distribution<result_type> _Gen;
result_type __u = _Gen()(__g);
ptrdiff_t __k = _STD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
__u) - __p.__areas_.begin() - 1;
__u -= __p.__areas_[__k];
const result_type __dk = __p.__densities_[__k];
@@ -6508,7 +6533,7 @@ piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_typ
const result_type __bk1 = __p.__b_[__k+1];
const result_type __deltab = __bk1 - __bk;
return (__bk * __dk1 - __bk1 * __dk +
_STD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) /
_VSTD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) /
__deltad;
}

View File

@@ -1280,7 +1280,7 @@ class __node
__node(const __node&);
__node& operator=(const __node&);
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
__node() {}
@@ -1300,7 +1300,7 @@ class __end_state
: public __node<_CharT>
{
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
__end_state() {}
@@ -1365,7 +1365,7 @@ class __empty_state
typedef __owns_one_state<_CharT> base;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
explicit __empty_state(__node<_CharT>* __s)
@@ -1391,7 +1391,7 @@ class __empty_non_own_state
typedef __has_one_state<_CharT> base;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
explicit __empty_non_own_state(__node<_CharT>* __s)
@@ -1417,7 +1417,7 @@ class __repeat_one_loop
typedef __has_one_state<_CharT> base;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
explicit __repeat_one_loop(__node<_CharT>* __s)
@@ -1479,7 +1479,7 @@ class __loop
bool __greedy_;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
explicit __loop(unsigned __loop_id,
@@ -1578,7 +1578,7 @@ class __alternate
typedef __owns_two_states<_CharT> base;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
explicit __alternate(__owns_one_state<_CharT>* __s1,
@@ -1617,7 +1617,7 @@ class __begin_marked_subexpression
unsigned __mexp_;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
explicit __begin_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
@@ -1645,7 +1645,7 @@ class __end_marked_subexpression
unsigned __mexp_;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
explicit __end_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
@@ -1674,7 +1674,7 @@ class __back_ref
unsigned __mexp_;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
explicit __back_ref(unsigned __mexp, __node<_CharT>* __s)
@@ -1692,7 +1692,7 @@ __back_ref<_CharT>::__exec(__state& __s) const
{
ptrdiff_t __len = __sm.second - __sm.first;
if (__s.__last_ - __s.__current_ >= __len &&
_STD::equal(__sm.first, __sm.second, __s.__current_))
_VSTD::equal(__sm.first, __sm.second, __s.__current_))
{
__s.__do_ = __state::__accept_but_not_consume;
__s.__current_ += __len;
@@ -1722,7 +1722,7 @@ class __back_ref_icase
_Traits __traits_;
unsigned __mexp_;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
explicit __back_ref_icase(const _Traits& __traits, unsigned __mexp,
@@ -1777,7 +1777,7 @@ class __back_ref_collate
_Traits __traits_;
unsigned __mexp_;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
explicit __back_ref_collate(const _Traits& __traits, unsigned __mexp,
@@ -1832,7 +1832,7 @@ class __word_boundary
_Traits __traits_;
bool __invert_;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
explicit __word_boundary(const _Traits& __traits, bool __invert,
@@ -1900,7 +1900,7 @@ class __l_anchor
typedef __owns_one_state<_CharT> base;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
__l_anchor(__node<_CharT>* __s)
@@ -1934,7 +1934,7 @@ class __r_anchor
typedef __owns_one_state<_CharT> base;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
__r_anchor(__node<_CharT>* __s)
@@ -1968,7 +1968,7 @@ class __match_any
typedef __owns_one_state<_CharT> base;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
__match_any(__node<_CharT>* __s)
@@ -2003,7 +2003,7 @@ class __match_any_but_newline
typedef __owns_one_state<_CharT> base;
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
__match_any_but_newline(__node<_CharT>* __s)
@@ -2025,7 +2025,7 @@ class __match_char
__match_char(const __match_char&);
__match_char& operator=(const __match_char&);
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
__match_char(_CharT __c, __node<_CharT>* __s)
@@ -2065,7 +2065,7 @@ class __match_char_icase
__match_char_icase(const __match_char_icase&);
__match_char_icase& operator=(const __match_char_icase&);
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
__match_char_icase(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
@@ -2106,7 +2106,7 @@ class __match_char_collate
__match_char_collate(const __match_char_collate&);
__match_char_collate& operator=(const __match_char_collate&);
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
__match_char_collate(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
@@ -2158,7 +2158,7 @@ class __bracket_expression
__bracket_expression(const __bracket_expression&);
__bracket_expression& operator=(const __bracket_expression&);
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
__bracket_expression(const _Traits& __traits, __node<_CharT>* __s,
@@ -2226,7 +2226,7 @@ public:
__b[0] = __traits_.translate_nocase(__b[0]);
__e[0] = __traits_.translate_nocase(__e[0]);
}
__ranges_.push_back(make_pair(_STD::move(__b), _STD::move(__e)));
__ranges_.push_back(make_pair(_VSTD::move(__b), _VSTD::move(__e)));
}
}
_LIBCPP_INLINE_VISIBILITY
@@ -2263,7 +2263,7 @@ __bracket_expression<_CharT, _Traits>::__exec(__state& __s) const
++__consumed;
if (__might_have_digraph_)
{
const _CharT* __next = _STD::next(__s.__current_);
const _CharT* __next = _VSTD::next(__s.__current_);
if (__next != __s.__last_)
{
pair<_CharT, _CharT> __ch2(*__s.__current_, *__next);
@@ -2410,7 +2410,7 @@ __exit:
}
}
template <class, class> class __lookahead;
template <class _CharT, class _Traits> class __lookahead;
template <class _CharT, class _Traits = regex_traits<_CharT> >
class _LIBCPP_VISIBLE basic_regex
@@ -2430,8 +2430,8 @@ private:
shared_ptr<__empty_state<_CharT> > __start_;
__owns_one_state<_CharT>* __end_;
typedef _STD::__state<_CharT> __state;
typedef _STD::__node<_CharT> __node;
typedef _VSTD::__state<_CharT> __state;
typedef _VSTD::__node<_CharT> __node;
public:
// constants:
@@ -2478,12 +2478,14 @@ 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,9 +2494,11 @@ 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)
@@ -2557,11 +2561,15 @@ public:
__parse(__first, __last);
}
#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_;}
@@ -2834,7 +2842,7 @@ template <class _CharT, class _Traits>
void
basic_regex<_CharT, _Traits>::swap(basic_regex& __r)
{
using _STD::swap;
using _VSTD::swap;
swap(__traits_, __r.__traits_);
swap(__flags_, __r.__flags_);
swap(__marked_count_, __r.__marked_count_);
@@ -2866,7 +2874,7 @@ class __lookahead
__lookahead(const __lookahead&);
__lookahead& operator=(const __lookahead&);
public:
typedef _STD::__state<_CharT> __state;
typedef _VSTD::__state<_CharT> __state;
_LIBCPP_INLINE_VISIBILITY
__lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s)
@@ -2953,7 +2961,7 @@ basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first,
__first = __parse_RE_expression(__first, __last);
if (__first != __last)
{
_ForwardIterator __temp = _STD::next(__first);
_ForwardIterator __temp = _VSTD::next(__first);
if (__temp == __last && *__first == '$')
{
__push_r_anchor();
@@ -3182,7 +3190,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first,
{
if (__first != __last)
{
_ForwardIterator __temp = _STD::next(__first);
_ForwardIterator __temp = _VSTD::next(__first);
if (__temp != __last)
{
if (*__first == '\\' && *__temp == '(')
@@ -3200,7 +3208,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first,
{
if (__first != __last)
{
_ForwardIterator __temp = _STD::next(__first);
_ForwardIterator __temp = _VSTD::next(__first);
if (__temp != __last)
{
if (*__first == '\\' && *__temp == ')')
@@ -3218,7 +3226,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first,
{
if (__first != __last)
{
_ForwardIterator __temp = _STD::next(__first);
_ForwardIterator __temp = _VSTD::next(__first);
if (__temp != __last)
{
if (*__first == '\\' && *__temp == '{')
@@ -3236,7 +3244,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first,
{
if (__first != __last)
{
_ForwardIterator __temp = _STD::next(__first);
_ForwardIterator __temp = _VSTD::next(__first);
if (__temp != __last)
{
if (*__first == '\\' && *__temp == '}')
@@ -3254,7 +3262,7 @@ basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first,
{
if (__first != __last)
{
_ForwardIterator __temp = _STD::next(__first);
_ForwardIterator __temp = _VSTD::next(__first);
if (__temp != __last)
{
if (*__first == '\\' && '1' <= *__temp && *__temp <= '9')
@@ -3275,7 +3283,7 @@ basic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first,
{
if (__first != __last)
{
_ForwardIterator __temp = _STD::next(__first);
_ForwardIterator __temp = _VSTD::next(__first);
if (__temp == __last && *__first == '$')
return __first;
// Not called inside a bracket
@@ -3333,7 +3341,7 @@ basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first,
{
if (__first != __last)
{
_ForwardIterator __temp = _STD::next(__first);
_ForwardIterator __temp = _VSTD::next(__first);
if (__temp != __last)
{
if (*__first == '\\')
@@ -3364,7 +3372,7 @@ basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first,
{
if (__first != __last)
{
_ForwardIterator __temp = _STD::next(__first);
_ForwardIterator __temp = _VSTD::next(__first);
if (__temp != __last)
{
if (*__first == '\\')
@@ -3674,7 +3682,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
{
if (__first != __last && *__first != ']')
{
_ForwardIterator __temp = _STD::next(__first);
_ForwardIterator __temp = _VSTD::next(__first);
basic_string<_CharT> __start_range;
if (__temp != __last && *__first == '[')
{
@@ -3703,7 +3711,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
}
if (__first != __last && *__first != ']')
{
__temp = _STD::next(__first);
__temp = _VSTD::next(__first);
if (__temp != __last && *__first == '-' && *__temp != ']')
{
// parse a range
@@ -3729,7 +3737,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
++__first;
}
}
__ml->__add_range(_STD::move(__start_range), _STD::move(__end_range));
__ml->__add_range(_VSTD::move(__start_range), _VSTD::move(__end_range));
}
else
{
@@ -3890,7 +3898,7 @@ basic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first
// Found [=
// This means =] must exist
value_type _Equal_close[2] = {'=', ']'};
_ForwardIterator __temp = _STD::search(__first, __last, _Equal_close,
_ForwardIterator __temp = _VSTD::search(__first, __last, _Equal_close,
_Equal_close+2);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__temp == __last)
@@ -3925,7 +3933,7 @@ basic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first
#endif // _LIBCPP_NO_EXCEPTIONS
}
}
__first = _STD::next(__temp, 2);
__first = _VSTD::next(__temp, 2);
return __first;
}
@@ -3939,7 +3947,7 @@ basic_regex<_CharT, _Traits>::__parse_character_class(_ForwardIterator __first,
// Found [:
// This means :] must exist
value_type _Colon_close[2] = {':', ']'};
_ForwardIterator __temp = _STD::search(__first, __last, _Colon_close,
_ForwardIterator __temp = _VSTD::search(__first, __last, _Colon_close,
_Colon_close+2);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__temp == __last)
@@ -3954,7 +3962,7 @@ basic_regex<_CharT, _Traits>::__parse_character_class(_ForwardIterator __first,
throw regex_error(regex_constants::error_brack);
#endif // _LIBCPP_NO_EXCEPTIONS
__ml->__add_class(__class_type);
__first = _STD::next(__temp, 2);
__first = _VSTD::next(__temp, 2);
return __first;
}
@@ -3968,7 +3976,7 @@ basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first,
// Found [.
// This means .] must exist
value_type _Dot_close[2] = {'.', ']'};
_ForwardIterator __temp = _STD::search(__first, __last, _Dot_close,
_ForwardIterator __temp = _VSTD::search(__first, __last, _Dot_close,
_Dot_close+2);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__temp == __last)
@@ -3987,7 +3995,7 @@ basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first,
throw regex_error(regex_constants::error_collate);
#endif // _LIBCPP_NO_EXCEPTIONS
}
__first = _STD::next(__temp, 2);
__first = _VSTD::next(__temp, 2);
return __first;
}
@@ -4091,7 +4099,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
break;
case '\\':
{
_ForwardIterator __temp = _STD::next(__first);
_ForwardIterator __temp = _VSTD::next(__first);
if (__temp != __last)
{
if (*__temp == 'b')
@@ -4109,7 +4117,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
break;
case '(':
{
_ForwardIterator __temp = _STD::next(__first);
_ForwardIterator __temp = _VSTD::next(__first);
if (__temp != __last && *__temp == '?')
{
if (++__temp != __last)
@@ -4121,7 +4129,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
basic_regex __exp;
__exp.__flags_ = __flags_;
__temp = __exp.__parse(++__temp, __last);
__push_lookahead(_STD::move(__exp), false);
__push_lookahead(_VSTD::move(__exp), false);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__temp == __last || *__temp != ')')
throw regex_error(regex_constants::error_paren);
@@ -4134,7 +4142,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
basic_regex __exp;
__exp.__flags_ = __flags_;
__temp = __exp.__parse(++__temp, __last);
__push_lookahead(_STD::move(__exp), true);
__push_lookahead(_VSTD::move(__exp), true);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__temp == __last || *__temp != ')')
throw regex_error(regex_constants::error_paren);
@@ -4179,7 +4187,7 @@ basic_regex<_CharT, _Traits>::__parse_atom(_ForwardIterator __first,
if (__first == __last)
throw regex_error(regex_constants::error_paren);
#endif // _LIBCPP_NO_EXCEPTIONS
_ForwardIterator __temp = _STD::next(__first);
_ForwardIterator __temp = _VSTD::next(__first);
if (__temp != __last && *__first == '?' && *__temp == ':')
{
++__open_count_;
@@ -4223,7 +4231,7 @@ basic_regex<_CharT, _Traits>::__parse_atom_escape(_ForwardIterator __first,
{
if (__first != __last && *__first == '\\')
{
_ForwardIterator __t1 = _STD::next(__first);
_ForwardIterator __t1 = _VSTD::next(__first);
_ForwardIterator __t2 = __parse_decimal_escape(__t1, __last);
if (__t2 != __t1)
__first = __t2;
@@ -4369,7 +4377,7 @@ basic_regex<_CharT, _Traits>::__parse_character_escape(_ForwardIterator __first,
++__first;
break;
case 'c':
if ((__t = _STD::next(__first)) != __last)
if ((__t = _VSTD::next(__first)) != __last)
{
if ('A' <= *__t <= 'Z' || 'a' <= *__t <= 'z')
{
@@ -4494,7 +4502,7 @@ basic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first,
_ForwardIterator __last)
{
__owns_one_state<_CharT>* __sa = __end_;
_ForwardIterator __t1 = _STD::find(__first, __last, _CharT('\n'));
_ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
if (__t1 != __first)
__parse_basic_reg_exp(__first, __t1);
else
@@ -4504,7 +4512,7 @@ basic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first,
++__first;
while (__first != __last)
{
__t1 = _STD::find(__first, __last, _CharT('\n'));
__t1 = _VSTD::find(__first, __last, _CharT('\n'));
__owns_one_state<_CharT>* __sb = __end_;
if (__t1 != __first)
__parse_basic_reg_exp(__first, __t1);
@@ -4525,7 +4533,7 @@ basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first,
_ForwardIterator __last)
{
__owns_one_state<_CharT>* __sa = __end_;
_ForwardIterator __t1 = _STD::find(__first, __last, _CharT('\n'));
_ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
if (__t1 != __first)
__parse_extended_reg_exp(__first, __t1);
else
@@ -4535,7 +4543,7 @@ basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first,
++__first;
while (__first != __last)
{
__t1 = _STD::find(__first, __last, _CharT('\n'));
__t1 = _VSTD::find(__first, __last, _CharT('\n'));
__owns_one_state<_CharT>* __sb = __end_;
if (__t1 != __first)
__parse_extended_reg_exp(__first, __t1);
@@ -4732,7 +4740,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
difference_type length() const
{return matched ? _STD::distance(this->first, this->second) : 0;}
{return matched ? _VSTD::distance(this->first, this->second) : 0;}
_LIBCPP_INLINE_VISIBILITY
string_type str() const
{return matched ? string_type(this->first, this->second) : string_type();}
@@ -5188,7 +5196,7 @@ public:
{return (*this)[__sub].length();}
_LIBCPP_INLINE_VISIBILITY
difference_type position(size_type __sub = 0) const
{return _STD::distance(__position_start_, (*this)[__sub].first);}
{return _VSTD::distance(__position_start_, (*this)[__sub].first);}
_LIBCPP_INLINE_VISIBILITY
string_type str(size_type __sub = 0) const
{return (*this)[__sub].str();}
@@ -5202,11 +5210,11 @@ public:
const_reference suffix() const {return __suffix_;}
_LIBCPP_INLINE_VISIBILITY
const_iterator begin() const {return empty() ? __matches_.end() : __matches_.begin() + 1;}
const_iterator begin() const {return empty() ? __matches_.end() : __matches_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator end() const {return __matches_.end();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cbegin() const {return empty() ? __matches_.end() : __matches_.begin() + 1;}
const_iterator cbegin() const {return empty() ? __matches_.end() : __matches_.begin();}
_LIBCPP_INLINE_VISIBILITY
const_iterator cend() const {return __matches_.end();}
@@ -5260,18 +5268,18 @@ public:
__matches_.resize(__m.size());
for (size_type __i = 0; __i < __matches_.size(); ++__i)
{
__matches_[__i].first = _STD::next(__f, _STD::distance(__mf, __m[__i].first));
__matches_[__i].second = _STD::next(__f, _STD::distance(__mf, __m[__i].second));
__matches_[__i].first = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].first));
__matches_[__i].second = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].second));
__matches_[__i].matched = __m[__i].matched;
}
__unmatched_.first = __l;
__unmatched_.second = __l;
__unmatched_.matched = false;
__prefix_.first = _STD::next(__f, _STD::distance(__mf, __m.prefix().first));
__prefix_.second = _STD::next(__f, _STD::distance(__mf, __m.prefix().second));
__prefix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().first));
__prefix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().second));
__prefix_.matched = __m.prefix().matched;
__suffix_.first = _STD::next(__f, _STD::distance(__mf, __m.suffix().first));
__suffix_.second = _STD::next(__f, _STD::distance(__mf, __m.suffix().second));
__suffix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().first));
__suffix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().second));
__suffix_.matched = __m.suffix().matched;
if (!__no_update_pos)
__position_start_ = __prefix_.first;
@@ -5342,7 +5350,7 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out,
for (; __fmt_first != __fmt_last; ++__fmt_first)
{
if (*__fmt_first == '&')
__out = _STD::copy(__matches_[0].first, __matches_[0].second,
__out = _VSTD::copy(__matches_[0].first, __matches_[0].second,
__out);
else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last)
{
@@ -5350,7 +5358,7 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out,
if ('0' <= *__fmt_first && *__fmt_first <= '9')
{
size_t __i = *__fmt_first - '0';
__out = _STD::copy(__matches_[__i].first,
__out = _VSTD::copy(__matches_[__i].first,
__matches_[__i].second, __out);
}
else
@@ -5380,16 +5388,16 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out,
break;
case '&':
++__fmt_first;
__out = _STD::copy(__matches_[0].first, __matches_[0].second,
__out = _VSTD::copy(__matches_[0].first, __matches_[0].second,
__out);
break;
case '`':
++__fmt_first;
__out = _STD::copy(__prefix_.first, __prefix_.second, __out);
__out = _VSTD::copy(__prefix_.first, __prefix_.second, __out);
break;
case '\'':
++__fmt_first;
__out = _STD::copy(__suffix_.first, __suffix_.second, __out);
__out = _VSTD::copy(__suffix_.first, __suffix_.second, __out);
break;
default:
if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9')
@@ -5402,7 +5410,7 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out,
++__fmt_first;
__i = 10 * __i + *__fmt_first - '0';
}
__out = _STD::copy(__matches_[__i].first,
__out = _VSTD::copy(__matches_[__i].first,
__matches_[__i].second, __out);
}
else
@@ -5427,7 +5435,7 @@ template <class _BidirectionalIterator, class _Allocator>
void
match_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m)
{
using _STD::swap;
using _VSTD::swap;
swap(__matches_, __m.__matches_);
swap(__unmatched_, __m.__unmatched_);
swap(__prefix_, __m.__prefix_);
@@ -5485,7 +5493,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_ecma(
{
vector<__state> __states;
ptrdiff_t __j = 0;
ptrdiff_t _N = _STD::distance(__first, __last);
ptrdiff_t _N = _VSTD::distance(__first, __last);
__node* __st = __start_.get();
if (__st)
{
@@ -5509,7 +5517,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_ecma(
{
case __state::__end_state:
__m.__matches_[0].first = __first;
__m.__matches_[0].second = _STD::next(__first, __s.__current_ - __first);
__m.__matches_[0].second = _VSTD::next(__first, __s.__current_ - __first);
__m.__matches_[0].matched = true;
for (unsigned __i = 0; __i < __s.__sub_matches_.size(); ++__i)
__m.__matches_[__i+1] = __s.__sub_matches_[__i];
@@ -5523,7 +5531,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_ecma(
__state __snext = __s;
__s.__node_->__exec_split(true, __s);
__snext.__node_->__exec_split(false, __snext);
__states.push_back(_STD::move(__snext));
__states.push_back(_VSTD::move(__snext));
}
break;
case __state::__reject:
@@ -5551,7 +5559,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
{
deque<__state> __states;
ptrdiff_t __highest_j = 0;
ptrdiff_t _N = _STD::distance(__first, __last);
ptrdiff_t _N = _VSTD::distance(__first, __last);
__node* __st = __start_.get();
if (__st)
{
@@ -5584,7 +5592,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
case __state::__consume_input:
break;
case __state::__accept_and_consume:
__states.push_front(_STD::move(__s));
__states.push_front(_VSTD::move(__s));
__states.pop_back();
break;
case __state::__repeat:
@@ -5595,7 +5603,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
__state __snext = __s;
__s.__node_->__exec_split(true, __s);
__snext.__node_->__exec_split(false, __snext);
__states.push_back(_STD::move(__snext));
__states.push_back(_VSTD::move(__snext));
}
break;
case __state::__reject:
@@ -5611,7 +5619,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
if (__matched)
{
__m.__matches_[0].first = __first;
__m.__matches_[0].second = _STD::next(__first, __highest_j);
__m.__matches_[0].second = _VSTD::next(__first, __highest_j);
__m.__matches_[0].matched = true;
return true;
}
@@ -5631,7 +5639,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
__state __best_state;
ptrdiff_t __j = 0;
ptrdiff_t __highest_j = 0;
ptrdiff_t _N = _STD::distance(__first, __last);
ptrdiff_t _N = _VSTD::distance(__first, __last);
__node* __st = __start_.get();
if (__st)
{
@@ -5678,7 +5686,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
__state __snext = __s;
__s.__node_->__exec_split(true, __s);
__snext.__node_->__exec_split(false, __snext);
__states.push_back(_STD::move(__snext));
__states.push_back(_VSTD::move(__snext));
}
break;
case __state::__reject:
@@ -5694,7 +5702,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
if (__matched)
{
__m.__matches_[0].first = __first;
__m.__matches_[0].second = _STD::next(__first, __highest_j);
__m.__matches_[0].second = _VSTD::next(__first, __highest_j);
__m.__matches_[0].matched = true;
for (unsigned __i = 0; __i < __best_state.__sub_matches_.size(); ++__i)
__m.__matches_[__i+1] = __best_state.__sub_matches_[__i];
@@ -5824,7 +5832,7 @@ regex_search(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
match_results<const _CharT*> __m;
return _STD::regex_search(__str, __m, __e, __flags);
return _VSTD::regex_search(__str, __m, __e, __flags);
}
template <class _ST, class _SA, class _CharT, class _Traits>
@@ -5861,7 +5869,7 @@ regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
bool __r = _STD::regex_search(__first, __last, __m, __e,
bool __r = _VSTD::regex_search(__first, __last, __m, __e,
__flags | regex_constants::match_continuous);
if (__r)
{
@@ -5880,7 +5888,7 @@ regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
match_results<_BidirectionalIterator> __m;
return _STD::regex_match(__first, __last, __m, __e, __flags);
return _VSTD::regex_match(__first, __last, __m, __e, __flags);
}
template <class _CharT, class _Allocator, class _Traits>
@@ -5890,7 +5898,7 @@ regex_match(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
return _STD::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags);
return _VSTD::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags);
}
template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
@@ -5901,7 +5909,7 @@ regex_match(const basic_string<_CharT, _ST, _SA>& __s,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
return _STD::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
return _VSTD::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
}
template <class _CharT, class _Traits>
@@ -5910,7 +5918,7 @@ bool
regex_match(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
return _STD::regex_match(__str, __str + _Traits::length(__str), __e, __flags);
return _VSTD::regex_match(__str, __str + _Traits::length(__str), __e, __flags);
}
template <class _ST, class _SA, class _CharT, class _Traits>
@@ -5920,7 +5928,7 @@ regex_match(const basic_string<_CharT, _ST, _SA>& __s,
const basic_regex<_CharT, _Traits>& __e,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
return _STD::regex_match(__s.begin(), __s.end(), __e, __flags);
return _VSTD::regex_match(__s.begin(), __s.end(), __e, __flags);
}
// regex_iterator
@@ -5985,7 +5993,7 @@ regex_iterator<_BidirectionalIterator, _CharT, _Traits>::
__pregex_(&__re),
__flags_(__m)
{
_STD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
_VSTD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
}
template <class _BidirectionalIterator, class _CharT, class _Traits>
@@ -6017,7 +6025,7 @@ regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
__match_ = value_type();
return *this;
}
else if (_STD::regex_search(__start, __end_, __match_, *__pregex_,
else if (_VSTD::regex_search(__start, __end_, __match_, *__pregex_,
__flags_ | regex_constants::match_not_null |
regex_constants::match_continuous))
return *this;
@@ -6025,7 +6033,7 @@ regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
++__start;
}
__flags_ |= regex_constants::match_prev_avail;
if (!_STD::regex_search(__start, __end_, __match_, *__pregex_, __flags_))
if (!_VSTD::regex_search(__start, __end_, __match_, *__pregex_, __flags_))
__match_ = value_type();
return *this;
}
@@ -6069,11 +6077,13 @@ 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 _N>
regex_token_iterator(_BidirectionalIterator __a,
_BidirectionalIterator __b,
@@ -6162,6 +6172,8 @@ 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,
@@ -6175,6 +6187,8 @@ 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 _N>
regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
@@ -6267,7 +6281,7 @@ regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
}
else
{
if (_STD::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end()
if (_VSTD::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end()
&& __prev->suffix().length() != 0)
{
__suffix_.matched = true;
@@ -6303,7 +6317,7 @@ regex_replace(_OutputIterator __out,
if (__i == __eof)
{
if (!(__flags & regex_constants::format_no_copy))
__out = _STD::copy(__first, __last, __out);
__out = _VSTD::copy(__first, __last, __out);
}
else
{
@@ -6311,14 +6325,14 @@ regex_replace(_OutputIterator __out,
for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i)
{
if (!(__flags & regex_constants::format_no_copy))
__out = _STD::copy(__i->prefix().first, __i->prefix().second, __out);
__out = _VSTD::copy(__i->prefix().first, __i->prefix().second, __out);
__out = __i->format(__out, __fmt, __fmt + __len, __flags);
__lm = __i->suffix();
if (__flags & regex_constants::format_first_only)
break;
}
if (!(__flags & regex_constants::format_no_copy))
__out = _STD::copy(__lm.first, __lm.second, __out);
__out = _VSTD::copy(__lm.first, __lm.second, __out);
}
return __out;
}
@@ -6333,7 +6347,7 @@ regex_replace(_OutputIterator __out,
const basic_string<_CharT, _ST, _SA>& __fmt,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
return _STD::regex_replace(__out, __first, __last, __e, __fmt.c_str(), __flags);
return _VSTD::regex_replace(__out, __first, __last, __e, __fmt.c_str(), __flags);
}
template <class _Traits, class _CharT, class _ST, class _SA, class _FST,
@@ -6346,7 +6360,7 @@ regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
basic_string<_CharT, _ST, _SA> __r;
_STD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
_VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
__fmt.c_str(), __flags);
return __r;
}
@@ -6359,7 +6373,7 @@ regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
basic_string<_CharT, _ST, _SA> __r;
_STD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
_VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
__fmt, __flags);
return __r;
}
@@ -6373,7 +6387,7 @@ regex_replace(const _CharT* __s,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
basic_string<_CharT> __r;
_STD::regex_replace(back_inserter(__r), __s,
_VSTD::regex_replace(back_inserter(__r), __s,
__s + char_traits<_CharT>::length(__s), __e,
__fmt.c_str(), __flags);
return __r;
@@ -6388,7 +6402,7 @@ regex_replace(const _CharT* __s,
regex_constants::match_flag_type __flags = regex_constants::match_default)
{
basic_string<_CharT> __r;
_STD::regex_replace(back_inserter(__r), __s,
_VSTD::regex_replace(back_inserter(__r), __s,
__s + char_traits<_CharT>::length(__s), __e,
__fmt, __flags);
return __r;

View File

@@ -194,7 +194,7 @@ protected:
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage(_OuterA2&& __outerAlloc,
const _InnerAllocs& ...__innerAllocs) _NOEXCEPT
: outer_allocator_type(_STD::forward<_OuterA2>(__outerAlloc)),
: outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)),
__inner_(__innerAllocs...) {}
template <class _OuterA2,
@@ -214,8 +214,8 @@ protected:
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage(
__scoped_allocator_storage<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT
: outer_allocator_type(_STD::move(__other.outer_allocator())),
__inner_(_STD::move(__other.inner_allocator())) {}
: outer_allocator_type(_VSTD::move(__other.outer_allocator())),
__inner_(_VSTD::move(__other.inner_allocator())) {}
template <class _OuterA2,
class = typename enable_if<
@@ -224,7 +224,7 @@ protected:
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage(_OuterA2&& __o,
const inner_allocator_type& __i) _NOEXCEPT
: outer_allocator_type(_STD::forward<_OuterA2>(__o)),
: outer_allocator_type(_VSTD::forward<_OuterA2>(__o)),
__inner_(__i)
{
}
@@ -274,7 +274,7 @@ protected:
>::type>
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage(_OuterA2&& __outerAlloc) _NOEXCEPT
: outer_allocator_type(_STD::forward<_OuterA2>(__outerAlloc)) {}
: outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)) {}
template <class _OuterA2,
class = typename enable_if<
@@ -292,7 +292,7 @@ protected:
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage(
__scoped_allocator_storage<_OuterA2>&& __other) _NOEXCEPT
: outer_allocator_type(_STD::move(__other.outer_allocator())) {}
: outer_allocator_type(_VSTD::move(__other.outer_allocator())) {}
_LIBCPP_INLINE_VISIBILITY
inner_allocator_type& inner_allocator() _NOEXCEPT
@@ -354,7 +354,7 @@ struct __outermost<_Alloc, true>
{
typedef typename remove_reference
<
decltype(_STD::declval<_Alloc>().outer_allocator())
decltype(_VSTD::declval<_Alloc>().outer_allocator())
>::type _OuterAlloc;
typedef typename __outermost<_OuterAlloc>::type type;
_LIBCPP_INLINE_VISIBILITY
@@ -414,7 +414,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
scoped_allocator_adaptor(_OuterA2&& __outerAlloc,
const _InnerAllocs& ...__innerAllocs) _NOEXCEPT
: base(_STD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {}
: base(_VSTD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {}
// scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default;
template <class _OuterA2,
class = typename enable_if<
@@ -431,7 +431,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
scoped_allocator_adaptor(
scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT
: base(_STD::move(__other)) {}
: base(_VSTD::move(__other)) {}
// ~scoped_allocator_adaptor() = default;
@@ -471,7 +471,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
void construct(_Tp* __p, _Args&& ...__args)
{__construct(__uses_alloc_ctor<_Tp, inner_allocator_type, _Args...>(),
__p, _STD::forward<_Args>(__args)...);}
__p, _VSTD::forward<_Args>(__args)...);}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
void destroy(_Tp* __p)
@@ -494,7 +494,7 @@ private:
_LIBCPP_INLINE_VISIBILITY
scoped_allocator_adaptor(_OuterA2&& __o,
const inner_allocator_type& __i) _NOEXCEPT
: base(_STD::forward<_OuterA2>(__o), __i) {}
: base(_VSTD::forward<_OuterA2>(__o), __i) {}
template <class _Tp, class... _Args>
_LIBCPP_INLINE_VISIBILITY
@@ -505,7 +505,7 @@ private:
(
_OM()(outer_allocator()),
__p,
_STD::forward<_Args>(__args)...
_VSTD::forward<_Args>(__args)...
);
}
@@ -520,7 +520,7 @@ private:
__p,
allocator_arg,
inner_allocator(),
_STD::forward<_Args>(__args)...
_VSTD::forward<_Args>(__args)...
);
}
@@ -533,7 +533,7 @@ private:
(
_OM()(outer_allocator()),
__p,
_STD::forward<_Args>(__args)...,
_VSTD::forward<_Args>(__args)...,
inner_allocator()
);
}

View File

@@ -370,8 +370,8 @@ public:
typedef typename __base::difference_type difference_type;
typedef typename __base::const_iterator iterator;
typedef typename __base::const_iterator const_iterator;
typedef _STD::reverse_iterator<iterator> reverse_iterator;
typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
_LIBCPP_INLINE_VISIBILITY
explicit set(const value_compare& __comp = value_compare())
@@ -408,11 +408,18 @@ public:
insert(__s.begin(), __s.end());
}
_LIBCPP_INLINE_VISIBILITY
set& operator=(const set& __s)
{
__tree_ = __s.__tree_;
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
set(set&& __s)
_NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
: __tree_(_STD::move(__s.__tree_)) {}
: __tree_(_VSTD::move(__s.__tree_)) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
@@ -430,6 +437,7 @@ 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)
@@ -451,13 +459,14 @@ 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
set& operator=(set&& __s)
_NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
{
__tree_ = _STD::move(__s.__tree_);
__tree_ = _VSTD::move(__s.__tree_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -505,11 +514,11 @@ public:
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> emplace(_Args&&... __args)
{return __tree_.__emplace_unique(_STD::forward<_Args>(__args)...);}
{return __tree_.__emplace_unique(_VSTD::forward<_Args>(__args)...);}
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator __p, _Args&&... __args)
{return __tree_.__emplace_hint_unique(__p, _STD::forward<_Args>(__args)...);}
{return __tree_.__emplace_hint_unique(__p, _VSTD::forward<_Args>(__args)...);}
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY
pair<iterator,bool> insert(const value_type& __v)
@@ -517,7 +526,7 @@ public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
pair<iterator,bool> insert(value_type&& __v)
{return __tree_.__insert_unique(_STD::move(__v));}
{return __tree_.__insert_unique(_VSTD::move(__v));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __p, const value_type& __v)
@@ -525,7 +534,7 @@ public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __p, value_type&& __v)
{return __tree_.__insert_unique(__p, _STD::move(__v));}
{return __tree_.__insert_unique(__p, _VSTD::move(__v));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY
@@ -535,9 +544,11 @@ 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);}
@@ -593,13 +604,13 @@ public:
template <class _Key, class _Compare, class _Allocator>
set<_Key, _Compare, _Allocator>::set(set&& __s, const allocator_type& __a)
: __tree_(_STD::move(__s.__tree_), __a)
: __tree_(_VSTD::move(__s.__tree_), __a)
{
if (__a != __s.get_allocator())
{
const_iterator __e = cend();
while (!__s.empty())
insert(__e, _STD::move(__s.__tree_.remove(__s.begin())->__value_));
insert(__e, _VSTD::move(__s.__tree_.remove(__s.begin())->__value_));
}
}
@@ -611,7 +622,7 @@ bool
operator==(const set<_Key, _Compare, _Allocator>& __x,
const set<_Key, _Compare, _Allocator>& __y)
{
return __x.size() == __y.size() && _STD::equal(__x.begin(), __x.end(), __y.begin());
return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
}
template <class _Key, class _Compare, class _Allocator>
@@ -620,7 +631,7 @@ bool
operator< (const set<_Key, _Compare, _Allocator>& __x,
const set<_Key, _Compare, _Allocator>& __y)
{
return _STD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
}
template <class _Key, class _Compare, class _Allocator>
@@ -698,8 +709,8 @@ public:
typedef typename __base::difference_type difference_type;
typedef typename __base::const_iterator iterator;
typedef typename __base::const_iterator const_iterator;
typedef _STD::reverse_iterator<iterator> reverse_iterator;
typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
// construct/copy/destroy:
_LIBCPP_INLINE_VISIBILITY
@@ -738,11 +749,18 @@ public:
insert(__s.begin(), __s.end());
}
_LIBCPP_INLINE_VISIBILITY
multiset& operator=(const multiset& __s)
{
__tree_ = __s.__tree_;
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
multiset(multiset&& __s)
_NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
: __tree_(_STD::move(__s.__tree_)) {}
: __tree_(_VSTD::move(__s.__tree_)) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
explicit multiset(const allocator_type& __a)
@@ -757,6 +775,7 @@ 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)
@@ -778,13 +797,14 @@ 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
multiset& operator=(multiset&& __s)
_NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
{
__tree_ = _STD::move(__s.__tree_);
__tree_ = _VSTD::move(__s.__tree_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -832,11 +852,11 @@ public:
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
iterator emplace(_Args&&... __args)
{return __tree_.__emplace_multi(_STD::forward<_Args>(__args)...);}
{return __tree_.__emplace_multi(_VSTD::forward<_Args>(__args)...);}
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator __p, _Args&&... __args)
{return __tree_.__emplace_hint_multi(__p, _STD::forward<_Args>(__args)...);}
{return __tree_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);}
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY
iterator insert(const value_type& __v)
@@ -844,7 +864,7 @@ public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
iterator insert(value_type&& __v)
{return __tree_.__insert_multi(_STD::move(__v));}
{return __tree_.__insert_multi(_VSTD::move(__v));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __p, const value_type& __v)
@@ -852,7 +872,7 @@ public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __p, value_type&& __v)
{return __tree_.__insert_multi(_STD::move(__v));}
{return __tree_.__insert_multi(_VSTD::move(__v));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _InputIterator>
_LIBCPP_INLINE_VISIBILITY
@@ -862,9 +882,11 @@ 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);}
@@ -920,13 +942,13 @@ public:
template <class _Key, class _Compare, class _Allocator>
multiset<_Key, _Compare, _Allocator>::multiset(multiset&& __s, const allocator_type& __a)
: __tree_(_STD::move(__s.__tree_), __a)
: __tree_(_VSTD::move(__s.__tree_), __a)
{
if (__a != __s.get_allocator())
{
const_iterator __e = cend();
while (!__s.empty())
insert(__e, _STD::move(__s.__tree_.remove(__s.begin())->__value_));
insert(__e, _VSTD::move(__s.__tree_.remove(__s.begin())->__value_));
}
}
@@ -938,7 +960,7 @@ bool
operator==(const multiset<_Key, _Compare, _Allocator>& __x,
const multiset<_Key, _Compare, _Allocator>& __y)
{
return __x.size() == __y.size() && _STD::equal(__x.begin(), __x.end(), __y.begin());
return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
}
template <class _Key, class _Compare, class _Allocator>
@@ -947,7 +969,7 @@ bool
operator< (const multiset<_Key, _Compare, _Allocator>& __x,
const multiset<_Key, _Compare, _Allocator>& __y)
{
return _STD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
}
template <class _Key, class _Compare, class _Allocator>

View File

@@ -261,7 +261,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(basic_stringbuf&&
ptrdiff_t __nout = __rhs.pptr() - __rhs.pbase();
ptrdiff_t __eout = __rhs.epptr() - __rhs.pbase();
ptrdiff_t __hm = __rhs.__hm_ - __rhs.pbase();
__str_ = _STD::move(__rhs.__str_);
__str_ = _VSTD::move(__rhs.__str_);
char_type* __p = const_cast<char_type*>(__str_.data());
this->setg(__p, __p + __ninp, __p + __einp);
this->setp(__p, __p + __eout);
@@ -284,7 +284,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::operator=(basic_stringbuf&& __rhs)
ptrdiff_t __eout = __rhs.epptr() - __rhs.pbase();
ptrdiff_t __hm = __rhs.__hm_ - __rhs.pbase();
__mode_ = __rhs.__mode_;
__str_ = _STD::move(__rhs.__str_);
__str_ = _VSTD::move(__rhs.__str_);
char_type* __p = const_cast<char_type*>(__str_.data());
this->setg(__p, __p + __ninp, __p + __einp);
this->setp(__p, __p + __eout);
@@ -314,7 +314,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::swap(basic_stringbuf& __rhs)
ptrdiff_t __lnout = this->pptr() - this->pbase();
ptrdiff_t __leout = this->epptr() - this->pbase();
ptrdiff_t __lhm = this->__hm_ - this->pbase();
_STD::swap(__mode_, __rhs.__mode_);
_VSTD::swap(__mode_, __rhs.__mode_);
__str_.swap(__rhs.__str_);
char_type* __p = const_cast<char_type*>(__str_.data());
this->setg(__p, __p + __rninp, __p + __reinp);
@@ -451,7 +451,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c)
}
#endif // _LIBCPP_NO_EXCEPTIONS
}
__hm_ = _STD::max(this->pptr() + 1, __hm_);
__hm_ = _VSTD::max(this->pptr() + 1, __hm_);
if (__mode_ & ios_base::in)
{
char_type* __p = const_cast<char_type*>(__str_.data());
@@ -582,8 +582,8 @@ basic_istringstream<_CharT, _Traits, _Allocator>::basic_istringstream(const stri
template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_istringstream<_CharT, _Traits, _Allocator>::basic_istringstream(basic_istringstream&& __rhs)
: basic_istream<_CharT, _Traits>(_STD::move(__rhs)),
__sb_(_STD::move(__rhs.__sb_))
: basic_istream<_CharT, _Traits>(_VSTD::move(__rhs)),
__sb_(_VSTD::move(__rhs.__sb_))
{
basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_);
}
@@ -592,8 +592,8 @@ template <class _CharT, class _Traits, class _Allocator>
basic_istringstream<_CharT, _Traits, _Allocator>&
basic_istringstream<_CharT, _Traits, _Allocator>::operator=(basic_istringstream&& __rhs)
{
basic_istream<char_type, traits_type>::operator=(_STD::move(__rhs));
__sb_ = _STD::move(__rhs.__sb_);
basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
__sb_ = _VSTD::move(__rhs.__sb_);
return *this;
}
@@ -701,8 +701,8 @@ basic_ostringstream<_CharT, _Traits, _Allocator>::basic_ostringstream(const stri
template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_ostringstream<_CharT, _Traits, _Allocator>::basic_ostringstream(basic_ostringstream&& __rhs)
: basic_ostream<_CharT, _Traits>(_STD::move(__rhs)),
__sb_(_STD::move(__rhs.__sb_))
: basic_ostream<_CharT, _Traits>(_VSTD::move(__rhs)),
__sb_(_VSTD::move(__rhs.__sb_))
{
basic_ostream<_CharT, _Traits>::set_rdbuf(&__sb_);
}
@@ -711,8 +711,8 @@ template <class _CharT, class _Traits, class _Allocator>
basic_ostringstream<_CharT, _Traits, _Allocator>&
basic_ostringstream<_CharT, _Traits, _Allocator>::operator=(basic_ostringstream&& __rhs)
{
basic_ostream<char_type, traits_type>::operator=(_STD::move(__rhs));
__sb_ = _STD::move(__rhs.__sb_);
basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
__sb_ = _VSTD::move(__rhs.__sb_);
return *this;
}
@@ -820,8 +820,8 @@ basic_stringstream<_CharT, _Traits, _Allocator>::basic_stringstream(const string
template <class _CharT, class _Traits, class _Allocator>
inline _LIBCPP_INLINE_VISIBILITY
basic_stringstream<_CharT, _Traits, _Allocator>::basic_stringstream(basic_stringstream&& __rhs)
: basic_iostream<_CharT, _Traits>(_STD::move(__rhs)),
__sb_(_STD::move(__rhs.__sb_))
: basic_iostream<_CharT, _Traits>(_VSTD::move(__rhs)),
__sb_(_VSTD::move(__rhs.__sb_))
{
basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_);
}
@@ -830,8 +830,8 @@ template <class _CharT, class _Traits, class _Allocator>
basic_stringstream<_CharT, _Traits, _Allocator>&
basic_stringstream<_CharT, _Traits, _Allocator>::operator=(basic_stringstream&& __rhs)
{
basic_iostream<char_type, traits_type>::operator=(_STD::move(__rhs));
__sb_ = _STD::move(__rhs.__sb_);
basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
__sb_ = _VSTD::move(__rhs.__sb_);
return *this;
}

View File

@@ -125,7 +125,7 @@ public:
_LIBCPP_INLINE_VISIBILITY
stack(stack&& __q)
_NOEXCEPT_(is_nothrow_move_constructible<container_type>::value)
: c(_STD::move(__q.c)) {}
: c(_VSTD::move(__q.c)) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
@@ -135,14 +135,14 @@ public:
_LIBCPP_INLINE_VISIBILITY
stack& operator=(stack&& __q)
_NOEXCEPT_(is_nothrow_move_assignable<container_type>::value)
{c = _STD::move(__q.c); return *this;}
{c = _VSTD::move(__q.c); return *this;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
explicit stack(const container_type& __c) : c(__c) {}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
explicit stack(container_type&& __c) : c(_STD::move(__c)) {}
explicit stack(container_type&& __c) : c(_VSTD::move(__c)) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
@@ -168,13 +168,13 @@ public:
stack(container_type&& __c, const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0)
: c(_STD::move(__c), __a) {}
: c(_VSTD::move(__c), __a) {}
template <class _Alloc>
_LIBCPP_INLINE_VISIBILITY
stack(stack&& __s, const _Alloc& __a,
typename enable_if<uses_allocator<container_type,
_Alloc>::value>::type* = 0)
: c(_STD::move(__s.c), __a) {}
: c(_VSTD::move(__s.c), __a) {}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
@@ -190,12 +190,12 @@ public:
void push(const value_type& __v) {c.push_back(__v);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
void push(value_type&& __v) {c.push_back(_STD::move(__v));}
void push(value_type&& __v) {c.push_back(_VSTD::move(__v));}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
void emplace(_Args&&... __args)
{c.emplace_back(_STD::forward<_Args>(__args)...);}
{c.emplace_back(_VSTD::forward<_Args>(__args)...);}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
@@ -205,7 +205,7 @@ public:
void swap(stack& __s)
_NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
{
using _STD::swap;
using _VSTD::swap;
swap(c, __s.c);
}

View File

@@ -399,13 +399,13 @@ template <class _CharT, class _Traits>
void
basic_streambuf<_CharT, _Traits>::swap(basic_streambuf& __sb)
{
_STD::swap(__loc_, __sb.__loc_);
_STD::swap(__binp_, __sb.__binp_);
_STD::swap(__ninp_, __sb.__ninp_);
_STD::swap(__einp_, __sb.__einp_);
_STD::swap(__bout_, __sb.__bout_);
_STD::swap(__nout_, __sb.__nout_);
_STD::swap(__eout_, __sb.__eout_);
_VSTD::swap(__loc_, __sb.__loc_);
_VSTD::swap(__binp_, __sb.__binp_);
_VSTD::swap(__ninp_, __sb.__ninp_);
_VSTD::swap(__einp_, __sb.__einp_);
_VSTD::swap(__bout_, __sb.__bout_);
_VSTD::swap(__nout_, __sb.__nout_);
_VSTD::swap(__eout_, __sb.__eout_);
}
template <class _CharT, class _Traits>

View File

@@ -972,23 +972,24 @@ char_traits<char32_t>::assign(char_type* __s, size_t __n, char_type __a)
template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>&, const basic_string<_CharT, _Traits, _Allocator>&);
operator+(const basic_string<_CharT, _Traits, _Allocator>& __x,
const basic_string<_CharT, _Traits, _Allocator>& __y);
template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
operator+(const _CharT*, const basic_string<_CharT,_Traits,_Allocator>&);
operator+(const _CharT* __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
operator+(_CharT, const basic_string<_CharT,_Traits,_Allocator>&);
operator+(_CharT __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>&, const _CharT*);
operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const _CharT* __y);
template<class _CharT, class _Traits, class _Allocator>
basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>&, _CharT);
operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y);
template <bool>
class __basic_string_common
@@ -1051,8 +1052,8 @@ public:
typedef __wrap_iter<pointer> iterator;
typedef __wrap_iter<const_pointer> const_iterator;
#endif // defined(_LIBCPP_RAW_ITERATORS)
typedef _STD::reverse_iterator<iterator> reverse_iterator;
typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef _VSTD::reverse_iterator<iterator> reverse_iterator;
typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
private:
struct __long
@@ -1149,10 +1150,12 @@ 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();
@@ -1165,8 +1168,10 @@ 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
@@ -1239,7 +1244,9 @@ 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);
@@ -1262,8 +1269,10 @@ 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
@@ -1278,7 +1287,7 @@ public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
basic_string& assign(basic_string&& str)
{*this = _STD::move(str); return *this;}
{*this = _VSTD::move(str); return *this;}
#endif
basic_string& assign(const basic_string& __str, size_type __pos, size_type __n);
basic_string& assign(const_pointer __s, size_type __n);
@@ -1299,8 +1308,10 @@ 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);
@@ -1326,9 +1337,11 @@ 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
@@ -1357,9 +1370,11 @@ 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
@@ -1576,6 +1591,27 @@ 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& __c, false_type)
_NOEXCEPT
{}
_LIBCPP_INLINE_VISIBILITY
static void __swap_alloc(allocator_type& __x, allocator_type& __y)
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
@@ -1587,7 +1623,7 @@ private:
static void __swap_alloc(allocator_type& __x, allocator_type& __y, true_type)
_NOEXCEPT_(__is_nothrow_swappable<allocator_type>::value)
{
using _STD::swap;
using _VSTD::swap;
swap(__x, __y);
}
_LIBCPP_INLINE_VISIBILITY
@@ -1789,7 +1825,7 @@ template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_INLINE_VISIBILITY inline
basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)
_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
: __r_(_STD::move(__str.__r_))
: __r_(_VSTD::move(__str.__r_))
{
__str.__zero();
#ifdef _LIBCPP_DEBUG
@@ -1861,7 +1897,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __st
size_type __str_sz = __str.size();
if (__pos > __str_sz)
this->__throw_out_of_range();
__init(__str.data() + __pos, _STD::min(__n, __str_sz - __pos));
__init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos));
}
template <class _CharT, class _Traits, class _Allocator>
@@ -1901,7 +1937,7 @@ typename enable_if
>::type
basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
{
size_type __sz = static_cast<size_type>(_STD::distance(__first, __last));
size_type __sz = static_cast<size_type>(_VSTD::distance(__first, __last));
if (__sz > max_size())
this->__throw_length_error();
pointer __p;
@@ -1941,6 +1977,8 @@ 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)
@@ -1956,6 +1994,8 @@ 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()
{
@@ -1975,7 +2015,7 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
this->__throw_length_error();
pointer __old_p = __get_pointer();
size_type __cap = __old_cap < __ms / 2 - __alignment ?
__recommend(_STD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
__recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
__ms - 1;
pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
__invalidate_all_iterators();
@@ -2005,7 +2045,7 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_t
this->__throw_length_error();
pointer __old_p = __get_pointer();
size_type __cap = __old_cap < __ms / 2 - __alignment ?
__recommend(_STD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
__recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
__ms - 1;
pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
__invalidate_all_iterators();
@@ -2119,7 +2159,8 @@ basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, tr
{
clear();
shrink_to_fit();
__r_ = _STD::move(__str.__r_);
__r_.first() = __str.__r_.first();
__move_assign_alloc(__str);
__str.__zero();
}
@@ -2161,7 +2202,7 @@ typename enable_if
>::type
basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
{
size_type __n = static_cast<size_type>(_STD::distance(__first, __last));
size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
size_type __cap = capacity();
if (__cap < __n)
{
@@ -2193,7 +2234,7 @@ basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, siz
size_type __sz = __str.size();
if (__pos > __sz)
this->__throw_out_of_range();
return assign(__str.data() + __pos, _STD::min(__n, __sz - __pos));
return assign(__str.data() + __pos, _VSTD::min(__n, __sz - __pos));
}
template <class _CharT, class _Traits, class _Allocator>
@@ -2292,7 +2333,7 @@ basic_string<_CharT, _Traits, _Allocator>::append(_ForwardIterator __first, _For
{
size_type __sz = size();
size_type __cap = capacity();
size_type __n = static_cast<size_type>(_STD::distance(__first, __last));
size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
if (__n)
{
if (__cap - __sz < __n)
@@ -2321,7 +2362,7 @@ basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, siz
size_type __sz = __str.size();
if (__pos > __sz)
this->__throw_out_of_range();
return append(__str.data() + __pos, _STD::min(__n, __sz - __pos));
return append(__str.data() + __pos, _VSTD::min(__n, __sz - __pos));
}
template <class _CharT, class _Traits, class _Allocator>
@@ -2416,7 +2457,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIt
for (; __first != __last; ++__first)
push_back(*__first);
pointer __p = __get_pointer();
_STD::rotate(__p + __ip, __p + __old_sz, __p + size());
_VSTD::rotate(__p + __ip, __p + __old_sz, __p + size());
return iterator(__p + __ip);
}
@@ -2432,7 +2473,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _Forward
size_type __ip = static_cast<size_type>(__pos - begin());
size_type __sz = size();
size_type __cap = capacity();
size_type __n = static_cast<size_type>(_STD::distance(__first, __last));
size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
if (__n)
{
pointer __p;
@@ -2473,7 +2514,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_
size_type __str_sz = __str.size();
if (__pos2 > __str_sz)
this->__throw_out_of_range();
return insert(__pos1, __str.data() + __pos2, _STD::min(__n, __str_sz - __pos2));
return insert(__pos1, __str.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2));
}
template <class _CharT, class _Traits, class _Allocator>
@@ -2534,7 +2575,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __
size_type __sz = size();
if (__pos > __sz)
this->__throw_out_of_range();
__n1 = _STD::min(__n1, __sz - __pos);
__n1 = _VSTD::min(__n1, __sz - __pos);
size_type __cap = capacity();
if (__cap - __sz + __n1 >= __n2)
{
@@ -2585,7 +2626,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __
size_type __sz = size();
if (__pos > __sz)
this->__throw_out_of_range();
__n1 = _STD::min(__n1, __sz - __pos);
__n1 = _VSTD::min(__n1, __sz - __pos);
size_type __cap = capacity();
pointer __p;
if (__cap - __sz + __n1 >= __n2)
@@ -2655,7 +2696,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type _
size_type __str_sz = __str.size();
if (__pos2 > __str_sz)
this->__throw_out_of_range();
return replace(__pos1, __n1, __str.data() + __pos2, _STD::min(__n2, __str_sz - __pos2));
return replace(__pos1, __n1, __str.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2));
}
template <class _CharT, class _Traits, class _Allocator>
@@ -2713,7 +2754,7 @@ basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos, size_type __n)
if (__n)
{
pointer __p = __get_pointer();
__n = _STD::min(__n, __sz - __pos);
__n = _VSTD::min(__n, __sz - __pos);
size_type __n_move = __sz - __pos - __n;
if (__n_move != 0)
traits_type::move(__p + __pos, __p + __pos + __n, __n_move);
@@ -2839,7 +2880,7 @@ basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __res_arg)
this->__throw_length_error();
size_type __cap = capacity();
size_type __sz = size();
__res_arg = _STD::max(__res_arg, __sz);
__res_arg = _VSTD::max(__res_arg, __sz);
__res_arg = __recommend(__res_arg);
if (__res_arg != __cap)
{
@@ -2984,7 +3025,7 @@ basic_string<_CharT, _Traits, _Allocator>::copy(pointer __s, size_type __n, size
size_type __sz = size();
if (__pos > __sz)
this->__throw_out_of_range();
size_type __rlen = _STD::min(__n, __sz - __pos);
size_type __rlen = _VSTD::min(__n, __sz - __pos);
traits_type::copy(__s, data() + __pos, __rlen);
return __rlen;
}
@@ -3004,7 +3045,7 @@ basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
__is_nothrow_swappable<allocator_type>::value)
{
_STD::swap(__r_.first(), __str.__r_.first());
_VSTD::swap(__r_.first(), __str.__r_.first());
__swap_alloc(__alloc(), __str.__alloc());
#ifdef _LIBCPP_DEBUG
__invalidate_all_iterators();
@@ -3038,7 +3079,7 @@ basic_string<_CharT, _Traits, _Allocator>::find(const_pointer __s,
if (__n == 0)
return __pos;
const_pointer __p = data();
const_pointer __r = _STD::search(__p + __pos, __p + __sz, __s, __s + __n,
const_pointer __r = _VSTD::search(__p + __pos, __p + __sz, __s, __s + __n,
__traits_eq<traits_type>());
if (__r == __p + __sz)
return npos;
@@ -3093,13 +3134,13 @@ basic_string<_CharT, _Traits, _Allocator>::rfind(const_pointer __s,
assert(__s != 0);
#endif
size_type __sz = size();
__pos = _STD::min(__pos, __sz);
__pos = _VSTD::min(__pos, __sz);
if (__n < __sz - __pos)
__pos += __n;
else
__pos = __sz;
const_pointer __p = data();
const_pointer __r = _STD::find_end(__p, __p + __pos, __s, __s + __n,
const_pointer __r = _VSTD::find_end(__p, __p + __pos, __s, __s + __n,
__traits_eq<traits_type>());
if (__n > 0 && __r == __p + __pos)
return npos;
@@ -3164,7 +3205,7 @@ basic_string<_CharT, _Traits, _Allocator>::find_first_of(const_pointer __s,
if (__pos >= __sz || __n == 0)
return npos;
const_pointer __p = data();
const_pointer __r = _STD::find_first_of(__p + __pos, __p + __sz, __s,
const_pointer __r = _VSTD::find_first_of(__p + __pos, __p + __sz, __s,
__s + __n, __traits_eq<traits_type>());
if (__r == __p + __sz)
return npos;
@@ -3391,7 +3432,17 @@ _LIBCPP_INLINE_VISIBILITY inline
int
basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPT
{
return compare(0, npos, __str.data(), __str.size());
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;
}
template <class _CharT, class _Traits, class _Allocator>
@@ -3415,7 +3466,7 @@ basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
size_type __sz = __str.size();
if (__pos2 > __sz)
this->__throw_out_of_range();
return compare(__pos1, __n1, __str.data() + __pos2, _STD::min(__n2,
return compare(__pos1, __n1, __str.data() + __pos2, _VSTD::min(__n2,
__sz - __pos2));
}
@@ -3454,8 +3505,8 @@ basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
size_type __sz = size();
if (__pos1 > __sz || __n2 == npos)
this->__throw_out_of_range();
size_type __rlen = _STD::min(__n1, __sz - __pos1);
int __r = traits_type::compare(data() + __pos1, __s, _STD::min(__rlen, __n2));
size_type __rlen = _VSTD::min(__n1, __sz - __pos1);
int __r = traits_type::compare(data() + __pos1, __s, _VSTD::min(__rlen, __n2));
if (__r == 0)
{
if (__rlen < __n2)
@@ -3506,24 +3557,6 @@ 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
@@ -3533,24 +3566,6 @@ 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>
@@ -3588,25 +3603,7 @@ bool
operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
{
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;
return __lhs.compare(__rhs) < 0;
}
template<class _CharT, class _Traits, class _Allocator>
@@ -3615,25 +3612,7 @@ bool
operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
const _CharT* __rhs) _NOEXCEPT
{
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;
return __lhs.compare(__rhs) < 0;
}
template<class _CharT, class _Traits, class _Allocator>
@@ -3645,24 +3624,6 @@ 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>
@@ -3818,7 +3779,7 @@ _LIBCPP_INLINE_VISIBILITY inline
basic_string<_CharT, _Traits, _Allocator>
operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs)
{
return _STD::move(__lhs.append(__rhs));
return _VSTD::move(__lhs.append(__rhs));
}
template<class _CharT, class _Traits, class _Allocator>
@@ -3826,7 +3787,7 @@ _LIBCPP_INLINE_VISIBILITY inline
basic_string<_CharT, _Traits, _Allocator>
operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
{
return _STD::move(__rhs.insert(0, __lhs));
return _VSTD::move(__rhs.insert(0, __lhs));
}
template<class _CharT, class _Traits, class _Allocator>
@@ -3834,7 +3795,7 @@ _LIBCPP_INLINE_VISIBILITY inline
basic_string<_CharT, _Traits, _Allocator>
operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
{
return _STD::move(__lhs.append(__rhs));
return _VSTD::move(__lhs.append(__rhs));
}
template<class _CharT, class _Traits, class _Allocator>
@@ -3842,7 +3803,7 @@ _LIBCPP_INLINE_VISIBILITY inline
basic_string<_CharT, _Traits, _Allocator>
operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs)
{
return _STD::move(__rhs.insert(0, __lhs));
return _VSTD::move(__rhs.insert(0, __lhs));
}
template<class _CharT, class _Traits, class _Allocator>
@@ -3851,7 +3812,7 @@ basic_string<_CharT, _Traits, _Allocator>
operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs)
{
__rhs.insert(__rhs.begin(), __lhs);
return _STD::move(__rhs);
return _VSTD::move(__rhs);
}
template<class _CharT, class _Traits, class _Allocator>
@@ -3859,7 +3820,7 @@ _LIBCPP_INLINE_VISIBILITY inline
basic_string<_CharT, _Traits, _Allocator>
operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs)
{
return _STD::move(__lhs.append(__rhs));
return _VSTD::move(__lhs.append(__rhs));
}
template<class _CharT, class _Traits, class _Allocator>
@@ -3868,7 +3829,7 @@ basic_string<_CharT, _Traits, _Allocator>
operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs)
{
__lhs.push_back(__rhs);
return _STD::move(__lhs);
return _VSTD::move(__lhs);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -3936,6 +3897,21 @@ 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)
{
size_t __r = 0;
const size_t __sr = __CHAR_BIT__ * sizeof(size_t) - 8;
const size_t __m = size_t(0xF) << (__sr + 4);
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>
struct _LIBCPP_VISIBLE hash<basic_string<_CharT, _Traits, _Allocator> >
: public unary_function<basic_string<_CharT, _Traits, _Allocator>, size_t>
@@ -3949,73 +3925,49 @@ size_t
hash<basic_string<_CharT, _Traits, _Allocator> >::operator()(
const basic_string<_CharT, _Traits, _Allocator>& __val) const _NOEXCEPT
{
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;
return __do_string_hash(__val.data(), __val.data() + __val.size());
}
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
extern template class basic_string<char>;
extern template class basic_string<wchar_t>;
extern template
enable_if<__is_forward_iterator<char const*>::value, void>::type
basic_string<char, char_traits<char>, allocator<char> >::
__init<char const*>(char const*, char const*);
extern template
enable_if<__is_forward_iterator<wchar_t const*>::value, void>::type
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >::
__init<wchar_t const*>(wchar_t const*, wchar_t const*);
extern template
enable_if<__is_forward_iterator<char*>::value,
basic_string<char, char_traits<char>, allocator<char> >&>::type
basic_string<char, char_traits<char>, allocator<char> >::
append<char*>(char*, char*);
extern template
enable_if<__is_forward_iterator<wchar_t*>::value,
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&>::type
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >::
append<wchar_t*>(wchar_t*, wchar_t*);
extern template
enable_if<__is_forward_iterator<char const*>::value,
string::iterator>::type
string::
insert<char const*>(string::const_iterator, char const*, char const*);
extern template
enable_if<__is_forward_iterator<wchar_t const*>::value,
wstring::iterator>::type
wstring::
insert<wchar_t const*>(wstring::const_iterator, wchar_t const*, wchar_t const*);
extern template
enable_if<__is_input_iterator<char const*>::value, string&>::type
string::
replace<char const*>(string::const_iterator, string::const_iterator, char const*, char const*);
extern template
enable_if<__is_input_iterator<wchar_t const*>::value, wstring&>::type
wstring::
replace<wchar_t const*>(wstring::const_iterator, wstring::const_iterator, wchar_t const*, wchar_t const*);
extern template
enable_if<__is_forward_iterator<wchar_t*>::value, wstring&>::type
wstring::assign<wchar_t*>(wchar_t*, wchar_t*);
extern template
string
operator+<char, char_traits<char>, allocator<char> >(char const*, string const&);

View File

@@ -150,7 +150,9 @@ public:
strstreambuf(const unsigned char* __gnext, streamsize __n);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
strstreambuf(strstreambuf&& __rhs);
_LIBCPP_INLINE_VISIBILITY
strstreambuf& operator=(strstreambuf&& __rhs);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -187,6 +189,43 @@ private:
void __init(char* __gnext, streamsize __n, char* __pbeg);
};
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
inline _LIBCPP_INLINE_VISIBILITY
strstreambuf::strstreambuf(strstreambuf&& __rhs)
: streambuf(__rhs),
__strmode_(__rhs.__strmode_),
__alsize_(__rhs.__alsize_),
__palloc_(__rhs.__palloc_),
__pfree_(__rhs.__pfree_)
{
__rhs.setg(nullptr, nullptr, nullptr);
__rhs.setp(nullptr, nullptr);
}
inline _LIBCPP_INLINE_VISIBILITY
strstreambuf&
strstreambuf::operator=(strstreambuf&& __rhs)
{
if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0)
{
if (__pfree_)
__pfree_(eback());
else
delete [] eback();
}
streambuf::operator=(__rhs);
__strmode_ = __rhs.__strmode_;
__alsize_ = __rhs.__alsize_;
__palloc_ = __rhs.__palloc_;
__pfree_ = __rhs.__pfree_;
__rhs.setg(nullptr, nullptr, nullptr);
__rhs.setp(nullptr, nullptr);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
class _LIBCPP_VISIBLE istrstream
: public istream
{
@@ -207,8 +246,8 @@ public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
istrstream(istrstream&& __rhs)
: istream(_STD::move(__rhs)),
__sb_(_STD::move(__rhs.__sb_))
: istream(_VSTD::move(__rhs)),
__sb_(_VSTD::move(__rhs.__sb_))
{
istream::set_rdbuf(&__sb_);
}
@@ -216,8 +255,8 @@ public:
_LIBCPP_INLINE_VISIBILITY
istrstream& operator=(istrstream&& __rhs)
{
istream::operator=(_STD::move(__rhs));
__sb_ = _STD::move(__rhs.__sb_);
istream::operator=(_VSTD::move(__rhs));
__sb_ = _VSTD::move(__rhs.__sb_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -256,8 +295,8 @@ public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
ostrstream(ostrstream&& __rhs)
: ostream(_STD::move(__rhs)),
__sb_(_STD::move(__rhs.__sb_))
: ostream(_VSTD::move(__rhs)),
__sb_(_VSTD::move(__rhs.__sb_))
{
ostream::set_rdbuf(&__sb_);
}
@@ -265,8 +304,8 @@ public:
_LIBCPP_INLINE_VISIBILITY
ostrstream& operator=(ostrstream&& __rhs)
{
ostream::operator=(_STD::move(__rhs));
__sb_ = _STD::move(__rhs.__sb_);
ostream::operator=(_VSTD::move(__rhs));
__sb_ = _VSTD::move(__rhs.__sb_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -316,8 +355,8 @@ public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
strstream(strstream&& __rhs)
: iostream(_STD::move(__rhs)),
__sb_(_STD::move(__rhs.__sb_))
: iostream(_VSTD::move(__rhs)),
__sb_(_VSTD::move(__rhs.__sb_))
{
iostream::set_rdbuf(&__sb_);
}
@@ -325,8 +364,8 @@ public:
_LIBCPP_INLINE_VISIBILITY
strstream& operator=(strstream&& __rhs)
{
iostream::operator=(_STD::move(__rhs));
__sb_ = _STD::move(__rhs.__sb_);
iostream::operator=(_VSTD::move(__rhs));
__sb_ = _VSTD::move(__rhs.__sb_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

View File

@@ -0,0 +1,110 @@
// -*- 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' );
}
#endif // _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H

View File

@@ -0,0 +1,31 @@
// -*- 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 <wchar.h> // mbstate_t
#include <stdio.h> // _snwprintf
#define swprintf _snwprintf
#define vswprintf _vsnwprintf
int vasprintf( char **sptr, const char *__restrict__ fmt , va_list ap );
int asprintf(char **sptr, const char *__restrict__ fmt, ...);
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 );
#endif // _LIBCPP_SUPPORT_WIN32_SUPPORT_H

View File

@@ -284,7 +284,7 @@ public:
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
void swap(thread& __t) {_STD::swap(__t_, __t.__t_);}
void swap(thread& __t) {_VSTD::swap(__t_, __t.__t_);}
_LIBCPP_INLINE_VISIBILITY
bool joinable() const {return __t_ != 0;}
@@ -325,7 +325,7 @@ inline _LIBCPP_INLINE_VISIBILITY
void
__threaad_execute(tuple<_F, _Args...>& __t, __tuple_indices<_Indices...>)
{
__invoke(_STD::move(_STD::get<0>(__t)), _STD::move(_STD::get<_Indices>(__t))...);
__invoke(_VSTD::move(_VSTD::get<0>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...);
}
template <class _F>
@@ -345,8 +345,8 @@ template <class _F, class ..._Args,
thread::thread(_F&& __f, _Args&&... __args)
{
typedef tuple<typename decay<_F>::type, typename decay<_Args>::type...> _G;
_STD::unique_ptr<_G> __p(new _G(__decay_copy(_STD::forward<_F>(__f)),
__decay_copy(_STD::forward<_Args>(__args))...));
_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<_G>, __p.get());
if (__ec == 0)
__p.release();

View File

@@ -191,7 +191,7 @@ public:
class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
_LIBCPP_INLINE_VISIBILITY
explicit __tuple_leaf(_Tp&& __t)
: value(_STD::forward<_Tp>(__t))
: value(_VSTD::forward<_Tp>(__t))
{static_assert(!is_reference<_Hp>::value ||
is_lvalue_reference<_Hp>::value &&
(is_lvalue_reference<_Tp>::value ||
@@ -207,7 +207,7 @@ public:
template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY
explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
: value(_STD::forward<_Tp>(__t))
: value(_VSTD::forward<_Tp>(__t))
{static_assert(!is_lvalue_reference<_Hp>::value ||
is_lvalue_reference<_Hp>::value &&
(is_lvalue_reference<_Tp>::value ||
@@ -221,7 +221,7 @@ public:
template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY
explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
: value(allocator_arg_t(), __a, _STD::forward<_Tp>(__t))
: value(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
{static_assert(!is_lvalue_reference<_Hp>::value ||
is_lvalue_reference<_Hp>::value &&
(is_lvalue_reference<_Tp>::value ||
@@ -235,7 +235,7 @@ public:
template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY
explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
: value(_STD::forward<_Tp>(__t), __a)
: value(_VSTD::forward<_Tp>(__t), __a)
{static_assert(!is_lvalue_reference<_Hp>::value ||
is_lvalue_reference<_Hp>::value &&
(is_lvalue_reference<_Tp>::value ||
@@ -260,14 +260,14 @@ public:
__tuple_leaf&
operator=(_Tp&& __t)
{
value = _STD::forward<_Tp>(__t);
value = _VSTD::forward<_Tp>(__t);
return *this;
}
_LIBCPP_INLINE_VISIBILITY
int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
{
_STD::swap(*this, __t);
_VSTD::swap(*this, __t);
return 0;
}
@@ -302,22 +302,22 @@ public:
class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
_LIBCPP_INLINE_VISIBILITY
explicit __tuple_leaf(_Tp&& __t)
: _Hp(_STD::forward<_Tp>(__t)) {}
: _Hp(_VSTD::forward<_Tp>(__t)) {}
template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY
explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
: _Hp(_STD::forward<_Tp>(__t)) {}
: _Hp(_VSTD::forward<_Tp>(__t)) {}
template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY
explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
: _Hp(allocator_arg_t(), __a, _STD::forward<_Tp>(__t)) {}
: _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
template <class _Tp, class _Alloc>
_LIBCPP_INLINE_VISIBILITY
explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
: _Hp(_STD::forward<_Tp>(__t), __a) {}
: _Hp(_VSTD::forward<_Tp>(__t), __a) {}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
@@ -329,7 +329,7 @@ public:
__tuple_leaf&
operator=(_Tp&& __t)
{
_Hp::operator=(_STD::forward<_Tp>(__t));
_Hp::operator=(_VSTD::forward<_Tp>(__t));
return *this;
}
@@ -337,7 +337,7 @@ public:
int
swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
{
_STD::swap(*this, __t);
_VSTD::swap(*this, __t);
return 0;
}
@@ -378,7 +378,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
__tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
__tuple_indices<_Ul...>, __tuple_types<_Tl...>,
_Up&&... __u) :
__tuple_leaf<_Uf, _Tf>(_STD::forward<_Up>(__u))...,
__tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
__tuple_leaf<_Ul, _Tl>()...
{}
@@ -391,7 +391,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
__tuple_indices<_Ul...>, __tuple_types<_Tl...>,
_Up&&... __u) :
__tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
_STD::forward<_Up>(__u))...,
_VSTD::forward<_Up>(__u))...,
__tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
{}
@@ -403,8 +403,8 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
>
_LIBCPP_INLINE_VISIBILITY
__tuple_impl(_Tuple&& __t)
: __tuple_leaf<_Indx, _Tp>(_STD::forward<typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...
: __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
{}
template <class _Alloc, class _Tuple,
@@ -417,8 +417,8 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
__tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
: __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(), __a,
_STD::forward<typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...
_VSTD::forward<typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
{}
template <class _Tuple>
@@ -430,8 +430,8 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
>::type
operator=(_Tuple&& __t)
{
__swallow(__tuple_leaf<_Indx, _Tp>::operator=(_STD::forward<typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...);
__swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<typename tuple_element<_Indx,
typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...);
return *this;
}
@@ -499,7 +499,7 @@ public:
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_STD::forward<_Up>(__u)...) {}
_VSTD::forward<_Up>(__u)...) {}
template <class _Alloc, class ..._Up,
class = typename enable_if
@@ -522,7 +522,7 @@ public:
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_STD::forward<_Up>(__u)...) {}
_VSTD::forward<_Up>(__u)...) {}
template <class _Tuple,
class = typename enable_if
@@ -532,7 +532,7 @@ public:
>
_LIBCPP_INLINE_VISIBILITY
tuple(_Tuple&& __t)
: base_(_STD::forward<_Tuple>(__t)) {}
: base_(_VSTD::forward<_Tuple>(__t)) {}
template <class _Alloc, class _Tuple,
class = typename enable_if
@@ -542,7 +542,7 @@ public:
>
_LIBCPP_INLINE_VISIBILITY
tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
: base_(allocator_arg_t(), __a, _STD::forward<_Tuple>(__t)) {}
: base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
template <class _Tuple,
class = typename enable_if
@@ -554,7 +554,7 @@ public:
tuple&
operator=(_Tuple&& __t)
{
base_.operator=(_STD::forward<_Tuple>(__t));
base_.operator=(_VSTD::forward<_Tuple>(__t));
return *this;
}
@@ -639,11 +639,6 @@ tie(_Tp&... __t)
template <class _Up>
struct __ignore_t
{
_LIBCPP_INLINE_VISIBILITY
__ignore_t() {}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
__ignore_t(_Tp&&) {}
template <class _Tp>
_LIBCPP_INLINE_VISIBILITY
const __ignore_t& operator=(_Tp&&) const {return *this;}
@@ -676,7 +671,7 @@ inline _LIBCPP_INLINE_VISIBILITY
tuple<typename __make_tuple_return<_Tp>::type...>
make_tuple(_Tp&&... __t)
{
return tuple<typename __make_tuple_return<_Tp>::type...>(_STD::forward<_Tp>(__t)...);
return tuple<typename __make_tuple_return<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
}
template <class... _Tp>
@@ -684,7 +679,7 @@ inline _LIBCPP_INLINE_VISIBILITY
tuple<_Tp&&...>
forward_as_tuple(_Tp&&... __t)
{
return tuple<_Tp&&...>(_STD::forward<_Tp>(__t)...);
return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
}
template <size_t _I>
@@ -882,8 +877,8 @@ struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J
typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
operator()(tuple<_Types...> __t, _Tuple0&& __t0)
{
return _STD::forward_as_tuple(_STD::forward<_Types>(get<_I0>(__t))...,
get<_J0>(_STD::forward<_Tuple0>(__t0))...);
return _VSTD::forward_as_tuple(_VSTD::forward<_Types>(get<_I0>(__t))...,
get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
}
template <class _Tuple0, class _Tuple1, class ..._Tuples>
@@ -897,12 +892,12 @@ struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J
tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
(_STD::forward_as_tuple(
_STD::forward<_Types>(get<_I0>(__t))...,
get<_J0>(_STD::forward<_Tuple0>(__t0))...
(_VSTD::forward_as_tuple(
_VSTD::forward<_Types>(get<_I0>(__t))...,
get<_J0>(_VSTD::forward<_Tuple0>(__t0))...
),
_STD::forward<_Tuple1>(__t1),
_STD::forward<_Tuples>(__tpls)...);
_VSTD::forward<_Tuple1>(__t1),
_VSTD::forward<_Tuples>(__tpls)...);
}
};
@@ -914,8 +909,8 @@ tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
typedef typename remove_reference<_Tuple0>::type _T0;
return __tuple_cat<tuple<>, __tuple_indices<>,
typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
(tuple<>(), _STD::forward<_Tuple0>(__t0),
_STD::forward<_Tuples>(__tpls)...);
(tuple<>(), _VSTD::forward<_Tuple0>(__t0),
_VSTD::forward<_Tuples>(__tpls)...);
}
template <class ..._Tp, class _Alloc>
@@ -928,8 +923,8 @@ inline _LIBCPP_INLINE_VISIBILITY
pair<_T1, _T2>::pair(piecewise_construct_t,
tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
__tuple_indices<_I1...>, __tuple_indices<_I2...>)
: first(_STD::forward<_Args1>(get<_I1>( __first_args))...),
second(_STD::forward<_Args2>(get<_I2>(__second_args))...)
: first(_VSTD::forward<_Args1>(get<_I1>( __first_args))...),
second(_VSTD::forward<_Args2>(get<_I2>(__second_args))...)
{
}

View File

@@ -725,7 +725,7 @@ template <class _T1, class _T2> struct _LIBCPP_VISIBLE is_convertible
// is_base_of
#if __has_feature(is_base_of)
#ifdef _LIBCP_HAS_IS_BASE_OF
template <class _Bp, class _Dp>
struct _LIBCPP_VISIBLE is_base_of
@@ -733,51 +733,7 @@ struct _LIBCPP_VISIBLE is_base_of
#else // __has_feature(is_base_of)
// (C) Copyright Rani Sharoni 2003.
// Use, modification and distribution are subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt).
//
// See http://www.boost.org/libs/type_traits for most recent version including documentation.
template <class _Bp, class _Dp>
struct __is_base_of_tests
{
template <class _Tp>
static char __test(const volatile _Dp*, _Tp);
static __two __test(const volatile _Bp*, int);
};
template <class _Bp, class _Dp>
struct __is_base_of_imp
{
struct __host
{
operator const volatile _Bp*() const;
operator const volatile _Dp*();
};
static const size_t __complete_check = sizeof(_Dp);
static const bool value = sizeof(__is_base_of_tests<_Bp, _Dp>::__test(__host(), 0)) == 1;
};
template <class _Bp, class _Dp, bool = is_class<_Bp>::value,
bool = is_class<_Dp>::value,
bool = is_same<_Bp, _Dp>::value>
struct __libcpp_base_of : public false_type {};
template <class _Bp, class _Dp>
struct __libcpp_base_of<_Bp, _Dp, true, true, true> : public true_type {};
template <class _Bp, class _Dp>
struct __libcpp_base_of<_Bp, _Dp, true, true, false>
: public integral_constant<bool, __is_base_of_imp<_Bp, _Dp>::value> {};
template <class _Bp, class _Dp>
struct _LIBCPP_VISIBLE is_base_of
: public __libcpp_base_of<typename remove_cv<_Bp>::type, typename remove_cv<_Dp>::type>
{
};
#error is_base_of not implemented.
#endif // __has_feature(is_base_of)
@@ -818,7 +774,7 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_polymorphic
// has_virtual_destructor
#ifdef __has_feature(has_virtual_destructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
#if __has_feature(has_virtual_destructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
template <class _Tp> struct _LIBCPP_VISIBLE has_virtual_destructor
: public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
@@ -1208,7 +1164,7 @@ struct _LIBCPP_VISIBLE common_type<_Tp, _Up, _Vp...>
// is_assignable
template <class _Tp, class _Arg>
decltype((_STD::declval<_Tp>() = _STD::declval<_Arg>(), true_type()))
decltype((_VSTD::declval<_Tp>() = _VSTD::declval<_Arg>(), true_type()))
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
__is_assignable_test(_Tp&&, _Arg&&);
#else
@@ -1265,7 +1221,7 @@ struct __destructible_test
};
template <class _Tp>
decltype((_STD::declval<__destructible_test<_Tp> >().~__destructible_test<_Tp>(), true_type()))
decltype((_VSTD::declval<__destructible_test<_Tp> >().~__destructible_test<_Tp>(), true_type()))
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
__is_destructible_test(_Tp&&);
#else
@@ -1428,14 +1384,28 @@ public:
>::type type;
};
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
typename decay<_Tp>::type
__decay_copy(_Tp&& __t)
{
return _STD::forward<_Tp>(__t);
return _VSTD::forward<_Tp>(__t);
}
#else
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
typename decay<_Tp>::type
__decay_copy(const _Tp& __t)
{
return _VSTD::forward<_Tp>(__t);
}
#endif
template <class _MP, bool _IsMemberFuctionPtr, bool _IsMemberObjectPtr>
struct __member_pointer_traits_imp
{
@@ -1666,7 +1636,7 @@ struct __member_pointer_traits
// result_of
template <class> class result_of;
template <class _Callable> class result_of;
template <class _Fn, bool, bool>
class __result_of
@@ -1701,7 +1671,7 @@ struct __result_of_mdp;
template <class _R, class _Class, class _Tp>
struct __result_of_mdp<_R _Class::*, _Tp, false>
{
typedef typename __apply_cv<decltype(*_STD::declval<_Tp>()), _R>::type&& type;
typedef typename __apply_cv<decltype(*_VSTD::declval<_Tp>()), _R>::type&& type;
};
template <class _R, class _Class, class _Tp>
@@ -1786,7 +1756,7 @@ struct __result_of_mdp;
template <class _R, class _Class, class _Tp>
struct __result_of_mdp<_R _Class::*, _Tp, false>
{
typedef typename __apply_cv<decltype(*_STD::declval<_Tp>()), _R>::type& type;
typedef typename __apply_cv<decltype(*_VSTD::declval<_Tp>()), _R>::type& type;
};
template <class _R, class _Class, class _Tp>
@@ -1887,7 +1857,7 @@ class _LIBCPP_VISIBLE result_of<_Fn(_A0, _A1, _A2)>
// main is_constructible test
template <class _Tp, class ..._Args>
decltype(_STD::move(_Tp(_STD::declval<_Args>()...)), true_type())
decltype(_VSTD::move(_Tp(_VSTD::declval<_Args>()...)), true_type())
__is_constructible_test(_Tp&&, _Args&& ...);
template <class ..._Args>
@@ -2014,7 +1984,7 @@ false_type
__is_constructible0_test(__any);
template <class _Tp, class _A0>
decltype((_Tp(_STD::declval<_A0>()), true_type()))
decltype((_Tp(_VSTD::declval<_A0>()), true_type()))
__is_constructible1_test(_Tp&, _A0&);
template <class _A0>
@@ -2022,7 +1992,7 @@ false_type
__is_constructible1_test(__any, _A0&);
template <class _Tp, class _A0, class _A1>
decltype((_Tp(_STD::declval<_A0>(), _STD::declval<_A1>()), true_type()))
decltype((_Tp(_VSTD::declval<_A0>(), _VSTD::declval<_A1>()), true_type()))
__is_constructible2_test(_Tp&, _A0&, _A1&);
template <class _A0, class _A1>
@@ -2594,7 +2564,7 @@ struct __is_nothrow_assignable<false, _Tp, _Arg>
template <class _Tp, class _Arg>
struct __is_nothrow_assignable<true, _Tp, _Arg>
: public integral_constant<bool, noexcept(_STD::declval<_Tp>() = _STD::declval<_Arg>()) >
: public integral_constant<bool, noexcept(_VSTD::declval<_Tp>() = _VSTD::declval<_Arg>()) >
{
};
@@ -2680,7 +2650,7 @@ struct __is_nothrow_destructible<false, _Tp>
template <class _Tp>
struct __is_nothrow_destructible<true, _Tp>
: public integral_constant<bool, noexcept(_STD::declval<_Tp>().~_Tp()) >
: public integral_constant<bool, noexcept(_VSTD::declval<_Tp>().~_Tp()) >
{
};
@@ -2932,31 +2902,31 @@ __invoke(__any, _Args&& ...__args)
template <class _F, class _A0, class ..._Args>
auto
__invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
-> decltype((_STD::forward<_A0>(__a0).*__f)(_STD::forward<_Args>(__args)...));
-> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...));
template <class _F, class _A0, class ..._Args>
auto
__invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
-> decltype(((*_STD::forward<_A0>(__a0)).*__f)(_STD::forward<_Args>(__args)...));
-> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...));
// bullets 3 and 4
template <class _F, class _A0>
auto
__invoke(_F&& __f, _A0&& __a0)
-> decltype(_STD::forward<_A0>(__a0).*__f);
-> decltype(_VSTD::forward<_A0>(__a0).*__f);
template <class _F, class _A0>
auto
__invoke(_F&& __f, _A0&& __a0)
-> decltype((*_STD::forward<_A0>(__a0)).*__f);
-> decltype((*_VSTD::forward<_A0>(__a0)).*__f);
// bullet 5
template <class _F, class ..._Args>
auto
__invoke(_F&& __f, _Args&& ...__args)
-> decltype(_STD::forward<_F>(__f)(_STD::forward<_Args>(__args)...));
-> decltype(_VSTD::forward<_F>(__f)(_VSTD::forward<_Args>(__args)...));
// __invokable
@@ -2965,7 +2935,7 @@ struct __invokable_imp
: private __check_complete<_F, _Args...>
{
typedef decltype(
__invoke(_STD::declval<_F>(), _STD::declval<_Args>()...)
__invoke(_VSTD::declval<_F>(), _VSTD::declval<_Args>()...)
) type;
static const bool value = !is_same<type, __nat>::value;
};
@@ -3000,17 +2970,21 @@ struct __invoke_of
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
typename enable_if
<
is_move_constructible<_Tp>::value &&
is_move_assignable<_Tp>::value
>::type
#else
void
#endif
swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value &&
is_nothrow_move_assignable<_Tp>::value)
{
_Tp __t(_STD::move(__x));
__x = _STD::move(__y);
__y = _STD::move(__t);
_Tp __t(_VSTD::move(__x));
__x = _VSTD::move(__y);
__y = _VSTD::move(__t);
}
template <class _ForwardIterator1, class _ForwardIterator2>
@@ -3018,8 +2992,8 @@ inline _LIBCPP_INLINE_VISIBILITY
void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
// _NOEXCEPT_(_NOEXCEPT_(swap(*__a, *__b)))
_NOEXCEPT_(_NOEXCEPT_(swap(*_STD::declval<_ForwardIterator1>(),
*_STD::declval<_ForwardIterator2>())))
_NOEXCEPT_(_NOEXCEPT_(swap(*_VSTD::declval<_ForwardIterator1>(),
*_VSTD::declval<_ForwardIterator2>())))
{
swap(*__a, *__b);
}
@@ -3029,13 +3003,13 @@ iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
namespace __detail
{
using _STD::swap;
using _VSTD::swap;
__nat swap(__any, __any);
template <class _Tp>
struct __swappable
{
typedef decltype(swap(_STD::declval<_Tp&>(), _STD::declval<_Tp&>())) type;
typedef decltype(swap(_VSTD::declval<_Tp&>(), _VSTD::declval<_Tp&>())) type;
static const bool value = !is_same<type, __nat>::value;
};
@@ -3051,8 +3025,8 @@ struct __is_swappable
template <bool, class _Tp>
struct __is_nothrow_swappable_imp
: public integral_constant<bool, noexcept(swap(_STD::declval<_Tp&>(),
_STD::declval<_Tp&>()))>
: public integral_constant<bool, noexcept(swap(_VSTD::declval<_Tp&>(),
_VSTD::declval<_Tp&>()))>
{
};
@@ -3078,6 +3052,26 @@ struct __is_nothrow_swappable
#endif // __has_feature(cxx_noexcept)
#ifdef _LIBCXX_UNDERLYING_TYPE
template <class _Tp>
struct underlying_type
{
typedef _LIBCXX_UNDERLYING_TYPE(_Tp) type;
};
#else // _LIBCXX_UNDERLYING_TYPE
template <class _Tp, bool _Support = false>
struct underlying_type
{
static_assert(_Support, "The underyling_type trait requires compiler "
"support. Either no such support exists or "
"libc++ does not know how to use it.");
};
#endif // _LIBCXX_UNDERLYING_TYPE
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_TYPE_TRAITS

View File

@@ -481,9 +481,9 @@ public:
void operator()(pointer __p) _NOEXCEPT
{
if (__second_constructed)
__alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.second));
__alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.second));
if (__first_constructed)
__alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.first));
__alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.first));
if (__p)
__alloc_traits::deallocate(__na_, __p, 1);
}
@@ -560,9 +560,9 @@ public:
typedef const value_type& reference;
typedef typename __pointer_traits::template
#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
rebind<value_type>
rebind<const value_type>
#else
rebind<value_type>::other
rebind<const value_type>::other
#endif
pointer;
@@ -684,19 +684,28 @@ public:
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
unordered_map(unordered_map&& __u, const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
unordered_map(initializer_list<value_type> __il);
unordered_map(initializer_list<value_type> __il, size_type __n,
const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
unordered_map(initializer_list<value_type> __il, size_type __n,
const hasher& __hf, const key_equal& __eql,
const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
// ~unordered_map() = default;
// unordered_map& operator=(const unordered_map& __u) = default;
_LIBCPP_INLINE_VISIBILITY
unordered_map& operator=(const unordered_map& __u)
{
__table_ = __u.__table_;
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
unordered_map& operator=(unordered_map&& __u)
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
#endif
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
unordered_map& operator=(initializer_list<value_type> __il);
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const _NOEXCEPT
@@ -728,15 +737,15 @@ public:
{return __table_.__emplace_unique();}
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
_LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> emplace(_A0&& __a0)
{return __table_.__emplace_unique(_STD::forward<_A0>(__a0));}
{return __table_.__emplace_unique(_VSTD::forward<_A0>(__a0));}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _A0, class... _Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
pair<iterator, bool> emplace(_A0&& __a0, _Args&&... __args);
#endif // _LIBCPP_HAS_NO_VARIADICS
@@ -746,19 +755,19 @@ public:
{return __table_.__emplace_unique().first;}
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator, _A0&& __a0)
{return __table_.__emplace_unique(_STD::forward<_A0>(__a0)).first;}
{return __table_.__emplace_unique(_VSTD::forward<_A0>(__a0)).first;}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _A0, class... _Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator, _A0&& __a0, _Args&&... __args)
{return emplace(_STD::forward<_A0>(__a0),
_STD::forward<_Args>(__args)...).first;}
{return emplace(_VSTD::forward<_A0>(__a0),
_VSTD::forward<_Args>(__args)...).first;}
#endif // _LIBCPP_HAS_NO_VARIADICS
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
@@ -766,26 +775,28 @@ public:
{return __table_.__insert_unique(__x);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _P,
class = typename enable_if<is_convertible<_P, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _P>::value>::type>
_LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> insert(_P&& __x)
{return __table_.__insert_unique(_STD::forward<_P>(__x));}
{return __table_.__insert_unique(_VSTD::forward<_P>(__x));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator, const value_type& __x)
{return insert(__x).first;}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _P,
class = typename enable_if<is_convertible<_P, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _P>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator, _P&& __x)
{return insert(_STD::forward<_P>(__x)).first;}
{return insert(_VSTD::forward<_P>(__x)).first;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last);
#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 __table_.erase(__p.__i_);}
@@ -869,11 +880,11 @@ private:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _A0, class... _Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
__node_holder __construct_node(_A0&& __a0, _Args&&... __args);
#endif // _LIBCPP_HAS_NO_VARIADICS
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
__node_holder __construct_node(_A0&& __a0);
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
__node_holder __construct_node(const key_type& __k);
@@ -960,27 +971,29 @@ inline _LIBCPP_INLINE_VISIBILITY
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
unordered_map&& __u)
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
: __table_(_STD::move(__u.__table_))
: __table_(_VSTD::move(__u.__table_))
{
}
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
unordered_map&& __u, const allocator_type& __a)
: __table_(_STD::move(__u.__table_), __a)
: __table_(_VSTD::move(__u.__table_), __a)
{
if (__a != __u.get_allocator())
{
iterator __i = __u.begin();
while (__u.size() != 0)
__table_.__insert_unique(
_STD::move(__u.__table_.remove((__i++).__i_)->__value_)
_VSTD::move(__u.__table_.remove((__i++).__i_)->__value_)
);
}
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
initializer_list<value_type> __il)
@@ -1008,6 +1021,8 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
insert(__il.begin(), __il.end());
}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
@@ -1016,12 +1031,14 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_map&& __u)
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
{
__table_ = _STD::move(__u.__table_);
__table_ = _VSTD::move(__u.__table_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
@@ -1032,12 +1049,14 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
return *this;
}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _A0, class... _Args,
class // = typename enable_if<is_convertible<_A0, key_type>::value>::type
class // = typename enable_if<is_constructible<key_type, _A0>::value>::type
>
typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0,
@@ -1045,11 +1064,11 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0,
{
__node_allocator& __na = __table_.__node_alloc();
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_.first),
_STD::forward<_A0>(__a0));
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first),
_VSTD::forward<_A0>(__a0));
__h.get_deleter().__first_constructed = true;
__node_traits::construct(__na, _STD::addressof(__h->__value_.second),
_STD::forward<_Args>(__args)...);
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second),
_VSTD::forward<_Args>(__args)...);
__h.get_deleter().__second_constructed = true;
return __h;
}
@@ -1058,15 +1077,15 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0,
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _A0,
class // = typename enable_if<is_convertible<_A0, value_type>::value>::type
class // = typename enable_if<is_constructible<value_type, _A0>::value>::type
>
typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0)
{
__node_allocator& __na = __table_.__node_alloc();
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_),
_STD::forward<_A0>(__a0));
__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;
@@ -1076,13 +1095,13 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0)
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _A0, class... _Args,
class // = typename enable_if<is_convertible<_A0, key_type>::value>::type
class // = typename enable_if<is_constructible<key_type, _A0>::value>::type
>
pair<typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator, bool>
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace(_A0&& __a0, _Args&&... __args)
{
__node_holder __h = __construct_node(_STD::forward<_A0>(__a0),
_STD::forward<_Args>(__args)...);
__node_holder __h = __construct_node(_VSTD::forward<_A0>(__a0),
_VSTD::forward<_Args>(__args)...);
pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
if (__r.second)
__h.release();
@@ -1098,11 +1117,11 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type&
{
__node_allocator& __na = __table_.__node_alloc();
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_.first), __k);
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), __k);
__h.get_deleter().__first_constructed = true;
__node_traits::construct(__na, _STD::addressof(__h->__value_.second));
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
__h.get_deleter().__second_constructed = true;
return _STD::move(__h);
return _VSTD::move(__h);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1140,7 +1159,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](key_type&& __k)
iterator __i = find(__k);
if (__i != end())
return __i->second;
__node_holder __h = __construct_node(_STD::move(__k));
__node_holder __h = __construct_node(_VSTD::move(__k));
pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
__h.release();
return __r.first->second;
@@ -1287,6 +1306,7 @@ public:
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
unordered_multimap(unordered_multimap&& __u, const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
unordered_multimap(initializer_list<value_type> __il);
unordered_multimap(initializer_list<value_type> __il, size_type __n,
const hasher& __hf = hasher(),
@@ -1294,13 +1314,21 @@ public:
unordered_multimap(initializer_list<value_type> __il, size_type __n,
const hasher& __hf, const key_equal& __eql,
const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
// ~unordered_multimap() = default;
// unordered_multimap& operator=(const unordered_multimap& __u) = default;
_LIBCPP_INLINE_VISIBILITY
unordered_multimap& operator=(const unordered_multimap& __u)
{
__table_ = __u.__table_;
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
unordered_multimap& operator=(unordered_multimap&& __u)
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
#endif
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
unordered_multimap& operator=(initializer_list<value_type> __il);
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const _NOEXCEPT
@@ -1332,15 +1360,15 @@ public:
{return __table_.__emplace_multi();}
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator emplace(_A0&& __a0)
{return __table_.__emplace_multi(_STD::forward<_A0>(__a0));}
{return __table_.__emplace_multi(_VSTD::forward<_A0>(__a0));}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _A0, class... _Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
iterator emplace(_A0&& __a0, _Args&&... __args);
#endif // _LIBCPP_HAS_NO_VARIADICS
@@ -1350,15 +1378,15 @@ public:
{return __table_.__emplace_hint_multi(__p.__i_);}
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator __p, _A0&& __a0)
{return __table_.__emplace_hint_multi(__p.__i_, _STD::forward<_A0>(__a0));}
{return __table_.__emplace_hint_multi(__p.__i_, _VSTD::forward<_A0>(__a0));}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _A0, class... _Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
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
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1366,26 +1394,28 @@ public:
iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _P,
class = typename enable_if<is_convertible<_P, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _P>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator insert(_P&& __x)
{return __table_.__insert_multi(_STD::forward<_P>(__x));}
{return __table_.__insert_multi(_VSTD::forward<_P>(__x));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __p, const value_type& __x)
{return __table_.__insert_multi(__p.__i_, __x);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _P,
class = typename enable_if<is_convertible<_P, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _P>::value>::type>
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __p, _P&& __x)
{return __table_.__insert_multi(__p.__i_, _STD::forward<_P>(__x));}
{return __table_.__insert_multi(__p.__i_, _VSTD::forward<_P>(__x));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last);
#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 __table_.erase(__p.__i_);}
@@ -1461,10 +1491,10 @@ public:
private:
#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
template <class _A0, class... _Args,
class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
__node_holder __construct_node(_A0&& __a0, _Args&&... __args);
template <class _A0,
class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
__node_holder __construct_node(_A0&& __a0);
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
};
@@ -1549,14 +1579,14 @@ inline _LIBCPP_INLINE_VISIBILITY
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
unordered_multimap&& __u)
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
: __table_(_STD::move(__u.__table_))
: __table_(_VSTD::move(__u.__table_))
{
}
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
unordered_multimap&& __u, const allocator_type& __a)
: __table_(_STD::move(__u.__table_), __a)
: __table_(_VSTD::move(__u.__table_), __a)
{
if (__a != __u.get_allocator())
{
@@ -1564,7 +1594,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
while (__u.size() != 0)
{
__table_.__insert_multi(
_STD::move(__u.__table_.remove((__i++).__i_)->__value_)
_VSTD::move(__u.__table_.remove((__i++).__i_)->__value_)
);
}
}
@@ -1572,6 +1602,8 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
initializer_list<value_type> __il)
@@ -1599,6 +1631,8 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
insert(__il.begin(), __il.end());
}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
@@ -1607,12 +1641,14 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_multimap&& __u)
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
{
__table_ = _STD::move(__u.__table_);
__table_ = _VSTD::move(__u.__table_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
@@ -1623,12 +1659,14 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
return *this;
}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_VARIADICS
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _A0, class... _Args,
class // = typename enable_if<is_convertible<_A0, key_type>::value>::type
class // = typename enable_if<is_constructible<key_type, _A0>::value>::type
>
typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(
@@ -1636,11 +1674,11 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(
{
__node_allocator& __na = __table_.__node_alloc();
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_.first),
_STD::forward<_A0>(__a0));
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.first),
_VSTD::forward<_A0>(__a0));
__h.get_deleter().__first_constructed = true;
__node_traits::construct(__na, _STD::addressof(__h->__value_.second),
_STD::forward<_Args>(__args)...);
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.second),
_VSTD::forward<_Args>(__args)...);
__h.get_deleter().__second_constructed = true;
return __h;
}
@@ -1649,15 +1687,15 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _A0,
class // = typename enable_if<is_convertible<_A0, value_type>::value>::type
class // = typename enable_if<is_constructible<value_type, _A0>::value>::type
>
typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0)
{
__node_allocator& __na = __table_.__node_alloc();
__node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
__node_traits::construct(__na, _STD::addressof(__h->__value_),
_STD::forward<_A0>(__a0));
__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;
@@ -1667,13 +1705,13 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _A0, class... _Args,
class // = typename enable_if<is_convertible<_A0, key_type>::value>::type
class // = typename enable_if<is_constructible<key_type, _A0>::value>::type
>
typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace(_A0&& __a0, _Args&&... __args)
{
__node_holder __h = __construct_node(_STD::forward<_A0>(__a0),
_STD::forward<_Args>(__args)...);
__node_holder __h = __construct_node(_VSTD::forward<_A0>(__a0),
_VSTD::forward<_Args>(__args)...);
iterator __r = __table_.__node_insert_multi(__h.get());
__h.release();
return __r;
@@ -1681,14 +1719,14 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace(_A0&& __a0, _Args&&
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
template <class _A0, class... _Args,
class // = typename enable_if<is_convertible<_A0, key_type>::value>::type
class // = typename enable_if<is_constructible<key_type, _A0>::value>::type
>
typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace_hint(
const_iterator __p, _A0&& __a0, _Args&&... __args)
{
__node_holder __h = __construct_node(_STD::forward<_A0>(__a0),
_STD::forward<_Args>(__args)...);
__node_holder __h = __construct_node(_VSTD::forward<_A0>(__a0),
_VSTD::forward<_Args>(__args)...);
iterator __r = __table_.__node_insert_multi(__p.__i_, __h.get());
__h.release();
return __r;
@@ -1732,9 +1770,9 @@ operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
{
_EqRng __xeq = __x.equal_range(__i->first);
_EqRng __yeq = __y.equal_range(__i->first);
if (_STD::distance(__xeq.first, __xeq.second) !=
_STD::distance(__yeq.first, __yeq.second) ||
!_STD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
if (_VSTD::distance(__xeq.first, __xeq.second) !=
_VSTD::distance(__yeq.first, __yeq.second) ||
!_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
return false;
__i = __xeq.second;
}

View File

@@ -365,6 +365,7 @@ public:
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
unordered_set(unordered_set&& __u, const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
unordered_set(initializer_list<value_type> __il);
unordered_set(initializer_list<value_type> __il, size_type __n,
const hasher& __hf = hasher(),
@@ -372,13 +373,21 @@ public:
unordered_set(initializer_list<value_type> __il, size_type __n,
const hasher& __hf, const key_equal& __eql,
const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
// ~unordered_set() = default;
// unordered_set& operator=(const unordered_set& __u) = default;
_LIBCPP_INLINE_VISIBILITY
unordered_set& operator=(const unordered_set& __u)
{
__table_ = __u.__table_;
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
unordered_set& operator=(unordered_set&& __u)
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
#endif
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
unordered_set& operator=(initializer_list<value_type> __il);
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const _NOEXCEPT
@@ -408,11 +417,11 @@ public:
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> emplace(_Args&&... __args)
{return __table_.__emplace_unique(_STD::forward<_Args>(__args)...);}
{return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...);}
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator, _Args&&... __args)
{return __table_.__emplace_unique(_STD::forward<_Args>(__args)...).first;}
{return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first;}
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> insert(const value_type& __x)
@@ -420,7 +429,7 @@ public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
pair<iterator, bool> insert(value_type&& __x)
{return __table_.__insert_unique(_STD::move(__x));}
{return __table_.__insert_unique(_VSTD::move(__x));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator, const value_type& __x)
@@ -428,13 +437,15 @@ public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator, value_type&& __x)
{return insert(_STD::move(__x)).first;}
{return insert(_VSTD::move(__x)).first;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last);
#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 __table_.erase(__p);}
@@ -583,25 +594,27 @@ inline _LIBCPP_INLINE_VISIBILITY
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
unordered_set&& __u)
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
: __table_(_STD::move(__u.__table_))
: __table_(_VSTD::move(__u.__table_))
{
}
template <class _Value, class _Hash, class _Pred, class _Alloc>
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
unordered_set&& __u, const allocator_type& __a)
: __table_(_STD::move(__u.__table_), __a)
: __table_(_VSTD::move(__u.__table_), __a)
{
if (__a != __u.get_allocator())
{
iterator __i = __u.begin();
while (__u.size() != 0)
__table_.__insert_unique(_STD::move(__u.__table_.remove(__i++)->__value_));
__table_.__insert_unique(_VSTD::move(__u.__table_.remove(__i++)->__value_));
}
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template <class _Value, class _Hash, class _Pred, class _Alloc>
unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
initializer_list<value_type> __il)
@@ -629,6 +642,8 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
insert(__il.begin(), __il.end());
}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Value, class _Hash, class _Pred, class _Alloc>
@@ -637,12 +652,14 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>&
unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u)
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
{
__table_ = _STD::move(__u.__table_);
__table_ = _VSTD::move(__u.__table_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline _LIBCPP_INLINE_VISIBILITY
unordered_set<_Value, _Hash, _Pred, _Alloc>&
@@ -653,6 +670,8 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(
return *this;
}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template <class _Value, class _Hash, class _Pred, class _Alloc>
template <class _InputIterator>
inline _LIBCPP_INLINE_VISIBILITY
@@ -758,6 +777,7 @@ public:
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
unordered_multiset(unordered_multiset&& __u, const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
unordered_multiset(initializer_list<value_type> __il);
unordered_multiset(initializer_list<value_type> __il, size_type __n,
const hasher& __hf = hasher(),
@@ -765,13 +785,21 @@ public:
unordered_multiset(initializer_list<value_type> __il, size_type __n,
const hasher& __hf, const key_equal& __eql,
const allocator_type& __a);
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
// ~unordered_multiset() = default;
// unordered_multiset& operator=(const unordered_multiset& __u) = default;
_LIBCPP_INLINE_VISIBILITY
unordered_multiset& operator=(const unordered_multiset& __u)
{
__table_ = __u.__table_;
return *this;
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
unordered_multiset& operator=(unordered_multiset&& __u)
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
#endif
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
unordered_multiset& operator=(initializer_list<value_type> __il);
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
_LIBCPP_INLINE_VISIBILITY
allocator_type get_allocator() const _NOEXCEPT
@@ -801,17 +829,17 @@ public:
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
iterator emplace(_Args&&... __args)
{return __table_.__emplace_multi(_STD::forward<_Args>(__args)...);}
{return __table_.__emplace_multi(_VSTD::forward<_Args>(__args)...);}
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY
iterator emplace_hint(const_iterator __p, _Args&&... __args)
{return __table_.__emplace_hint_multi(__p, _STD::forward<_Args>(__args)...);}
{return __table_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);}
#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
_LIBCPP_INLINE_VISIBILITY
iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
iterator insert(value_type&& __x) {return __table_.__insert_multi(_STD::move(__x));}
iterator insert(value_type&& __x) {return __table_.__insert_multi(_VSTD::move(__x));}
#endif
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __p, const value_type& __x)
@@ -819,13 +847,15 @@ public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
_LIBCPP_INLINE_VISIBILITY
iterator insert(const_iterator __p, value_type&& __x)
{return __table_.__insert_multi(__p, _STD::move(__x));}
{return __table_.__insert_multi(__p, _VSTD::move(__x));}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _InputIterator>
void insert(_InputIterator __first, _InputIterator __last);
#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 __table_.erase(__p);}
@@ -975,25 +1005,27 @@ inline _LIBCPP_INLINE_VISIBILITY
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
unordered_multiset&& __u)
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
: __table_(_STD::move(__u.__table_))
: __table_(_VSTD::move(__u.__table_))
{
}
template <class _Value, class _Hash, class _Pred, class _Alloc>
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
unordered_multiset&& __u, const allocator_type& __a)
: __table_(_STD::move(__u.__table_), __a)
: __table_(_VSTD::move(__u.__table_), __a)
{
if (__a != __u.get_allocator())
{
iterator __i = __u.begin();
while (__u.size() != 0)
__table_.__insert_multi(_STD::move(__u.__table_.remove(__i++)->__value_));
__table_.__insert_multi(_VSTD::move(__u.__table_.remove(__i++)->__value_));
}
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template <class _Value, class _Hash, class _Pred, class _Alloc>
unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
initializer_list<value_type> __il)
@@ -1021,6 +1053,8 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
insert(__il.begin(), __il.end());
}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _Value, class _Hash, class _Pred, class _Alloc>
@@ -1030,12 +1064,14 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
unordered_multiset&& __u)
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
{
__table_ = _STD::move(__u.__table_);
__table_ = _VSTD::move(__u.__table_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template <class _Value, class _Hash, class _Pred, class _Alloc>
inline
unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
@@ -1046,6 +1082,8 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
return *this;
}
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template <class _Value, class _Hash, class _Pred, class _Alloc>
template <class _InputIterator>
inline _LIBCPP_INLINE_VISIBILITY
@@ -1081,9 +1119,9 @@ operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
{
_EqRng __xeq = __x.equal_range(*__i);
_EqRng __yeq = __y.equal_range(*__i);
if (_STD::distance(__xeq.first, __xeq.second) !=
_STD::distance(__yeq.first, __yeq.second) ||
!_STD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
if (_VSTD::distance(__xeq.first, __xeq.second) !=
_VSTD::distance(__yeq.first, __yeq.second) ||
!_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
return false;
__i = __xeq.second;
}

View File

@@ -183,7 +183,7 @@ inline _LIBCPP_INLINE_VISIBILITY
void
swap(_Tp (&__a)[_N], _Tp (&__b)[_N]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
{
_STD::swap_ranges(__a, __a + _N, __b);
_VSTD::swap_ranges(__a, __a + _N, __b);
}
template <class _Tp>
@@ -200,7 +200,7 @@ const _Tp&
#endif
move_if_noexcept(_Tp& __x) _NOEXCEPT
{
return _STD::move(__x);
return _VSTD::move(__x);
}
struct _LIBCPP_VISIBLE piecewise_construct_t { };
@@ -226,13 +226,27 @@ struct _LIBCPP_VISIBLE pair
template<class _U1, class _U2>
_LIBCPP_INLINE_VISIBILITY
pair(const pair<_U1, _U2>& __p,
typename enable_if<is_convertible<_U1, _T1>::value &&
is_convertible<_U2, _T2>::value>::type* = 0)
pair(const pair<_U1, _U2>& __p
#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
,typename enable_if<is_constructible<_T1, _U1>::value &&
is_constructible<_T2, _U2>::value>::type* = 0
#endif
)
: first(__p.first), second(__p.second) {}
_LIBCPP_INLINE_VISIBILITY
pair(const pair& __p)
_NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
is_nothrow_copy_constructible<second_type>::value)
: first(__p.first),
second(__p.second)
{
}
_LIBCPP_INLINE_VISIBILITY
pair& operator=(const pair& __p)
_NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
is_nothrow_copy_assignable<second_type>::value)
{
first = __p.first;
second = __p.second;
@@ -242,29 +256,37 @@ struct _LIBCPP_VISIBLE pair
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
template <class _U1, class _U2,
class = typename enable_if<is_convertible<_U1, first_type >::value &&
is_convertible<_U2, second_type>::value>::type>
class = typename enable_if<is_constructible<first_type, _U1 >::value &&
is_constructible<second_type, _U2>::value>::type>
_LIBCPP_INLINE_VISIBILITY
pair(_U1&& __u1, _U2&& __u2)
: first(_STD::forward<_U1>(__u1)),
second(_STD::forward<_U2>(__u2))
: first(_VSTD::forward<_U1>(__u1)),
second(_VSTD::forward<_U2>(__u2))
{}
template<class _U1, class _U2>
_LIBCPP_INLINE_VISIBILITY
pair(pair<_U1, _U2>&& __p,
typename enable_if<is_convertible<_U1, _T1>::value &&
is_convertible<_U2, _T2>::value>::type* = 0)
: first(_STD::forward<_U1>(__p.first)),
second(_STD::forward<_U2>(__p.second)) {}
typename enable_if<is_constructible<_T1, _U1>::value &&
is_constructible<_T2, _U2>::value>::type* = 0)
: first(_VSTD::forward<_U1>(__p.first)),
second(_VSTD::forward<_U2>(__p.second)) {}
_LIBCPP_INLINE_VISIBILITY
pair(pair&& __p) _NOEXCEPT_(is_nothrow_move_constructible<first_type>::value &&
is_nothrow_move_constructible<second_type>::value)
: first(_VSTD::forward<first_type>(__p.first)),
second(_VSTD::forward<second_type>(__p.second))
{
}
_LIBCPP_INLINE_VISIBILITY
pair&
operator=(pair&& __p) _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
is_nothrow_move_assignable<second_type>::value)
{
first = _STD::forward<first_type>(__p.first);
second = _STD::forward<second_type>(__p.second);
first = _VSTD::forward<first_type>(__p.first);
second = _VSTD::forward<second_type>(__p.second);
return *this;
}
@@ -274,9 +296,9 @@ struct _LIBCPP_VISIBLE pair
class = typename enable_if<__tuple_convertible<_Tuple, pair>::value>::type>
_LIBCPP_INLINE_VISIBILITY
pair(_Tuple&& __p)
: first(_STD::forward<typename tuple_element<0,
: first(_VSTD::forward<typename tuple_element<0,
typename __make_tuple_types<_Tuple>::type>::type>(get<0>(__p))),
second(_STD::forward<typename tuple_element<1,
second(_VSTD::forward<typename tuple_element<1,
typename __make_tuple_types<_Tuple>::type>::type>(get<1>(__p)))
{}
@@ -300,8 +322,8 @@ struct _LIBCPP_VISIBLE pair
typedef typename __make_tuple_types<_Tuple>::type _TupleRef;
typedef typename tuple_element<0, _TupleRef>::type _U0;
typedef typename tuple_element<1, _TupleRef>::type _U1;
first = _STD::forward<_U0>(_STD::get<0>(__p));
second = _STD::forward<_U1>(_STD::get<1>(__p));
first = _VSTD::forward<_U0>(_VSTD::get<0>(__p));
second = _VSTD::forward<_U1>(_VSTD::get<1>(__p));
return *this;
}
@@ -313,8 +335,8 @@ struct _LIBCPP_VISIBLE pair
swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
__is_nothrow_swappable<second_type>::value)
{
_STD::iter_swap(&first, &__p.first);
_STD::iter_swap(&second, &__p.second);
_VSTD::iter_swap(&first, &__p.first);
_VSTD::iter_swap(&second, &__p.second);
}
private:
@@ -418,7 +440,7 @@ pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::t
make_pair(_T1&& __t1, _T2&& __t2)
{
return pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
(_STD::forward<_T1>(__t1), _STD::forward<_T2>(__t2));
(_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
}
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -494,7 +516,7 @@ struct __get_pair<0>
static
_LIBCPP_INLINE_VISIBILITY
_T1&&
get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _STD::forward<_T1>(__p.first);}
get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
};
@@ -520,7 +542,7 @@ struct __get_pair<1>
static
_LIBCPP_INLINE_VISIBILITY
_T2&&
get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _STD::forward<_T2>(__p.second);}
get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
};
@@ -548,7 +570,7 @@ _LIBCPP_INLINE_VISIBILITY inline
typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
get(pair<_T1, _T2>&& __p) _NOEXCEPT
{
return __get_pair<_Ip>::get(_STD::move(__p));
return __get_pair<_Ip>::get(_VSTD::move(__p));
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

View File

@@ -798,8 +798,10 @@ public:
valarray(const valarray& __v);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
valarray(valarray&& __v);
valarray(initializer_list<value_type> __il);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
valarray(initializer_list<value_type> __il);
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
valarray(const slice_array<value_type>& __sa);
valarray(const gslice_array<value_type>& __ga);
valarray(const mask_array<value_type>& __ma);
@@ -810,13 +812,17 @@ public:
valarray& operator=(const valarray& __v);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
valarray& operator=(valarray&& __v);
valarray& operator=(initializer_list<value_type>);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
valarray& operator=(initializer_list<value_type>);
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
valarray& operator=(const value_type& __x);
valarray& operator=(const slice_array<value_type>& __sa);
valarray& operator=(const gslice_array<value_type>& __ga);
valarray& operator=(const mask_array<value_type>& __ma);
valarray& operator=(const indirect_array<value_type>& __ia);
template <class _ValExpr>
valarray& operator=(const __val_expr<_ValExpr>& __v);
// element access:
_LIBCPP_INLINE_VISIBILITY
@@ -2706,6 +2712,10 @@ valarray<_Tp>::valarray(valarray&& __v)
__v.__begin_ = __v.__end_ = nullptr;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template <class _Tp>
valarray<_Tp>::valarray(initializer_list<value_type> __il)
: __begin_(0),
@@ -2732,7 +2742,7 @@ valarray<_Tp>::valarray(initializer_list<value_type> __il)
}
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template <class _Tp>
valarray<_Tp>::valarray(const slice_array<value_type>& __sa)
@@ -2862,7 +2872,7 @@ valarray<_Tp>::operator=(const valarray& __v)
{
if (size() != __v.size())
resize(__v.size());
_STD::copy(__v.__begin_, __v.__end_, __begin_);
_VSTD::copy(__v.__begin_, __v.__end_, __begin_);
}
return *this;
}
@@ -2882,6 +2892,10 @@ valarray<_Tp>::operator=(valarray&& __v)
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
valarray<_Tp>&
@@ -2889,18 +2903,18 @@ valarray<_Tp>::operator=(initializer_list<value_type> __il)
{
if (size() != __il.size())
resize(__il.size());
_STD::copy(__il.begin(), __il.end(), __begin_);
_VSTD::copy(__il.begin(), __il.end(), __begin_);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
valarray<_Tp>&
valarray<_Tp>::operator=(const value_type& __x)
{
_STD::fill(__begin_, __end_, __x);
_VSTD::fill(__begin_, __end_, __x);
return *this;
}
@@ -2958,6 +2972,21 @@ valarray<_Tp>::operator=(const indirect_array<value_type>& __ia)
return *this;
}
template <class _Tp>
template <class _ValExpr>
inline _LIBCPP_INLINE_VISIBILITY
valarray<_Tp>&
valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v)
{
size_t __n = __v.size();
if (size() != __n)
resize(__n);
value_type* __t = __begin_;
for (size_t __i = 0; __i != __n; ++__t, ++__i)
*__t = result_type(__v[__i]);
return *this;
}
template <class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
__val_expr<__slice_expr<const valarray<_Tp>&> >
@@ -3415,8 +3444,8 @@ inline _LIBCPP_INLINE_VISIBILITY
void
valarray<_Tp>::swap(valarray& __v)
{
_STD::swap(__begin_, __v.__begin_);
_STD::swap(__end_, __v.__end_);
_VSTD::swap(__begin_, __v.__begin_);
_VSTD::swap(__end_, __v.__end_);
}
template <class _Tp>
@@ -3440,7 +3469,7 @@ valarray<_Tp>::min() const
{
if (__begin_ == __end_)
return value_type();
return *_STD::min_element(__begin_, __end_);
return *_VSTD::min_element(__begin_, __end_);
}
template <class _Tp>
@@ -3450,7 +3479,7 @@ valarray<_Tp>::max() const
{
if (__begin_ == __end_)
return value_type();
return *_STD::max_element(__begin_, __end_);
return *_VSTD::max_element(__begin_, __end_);
}
template <class _Tp>
@@ -3469,14 +3498,14 @@ valarray<_Tp>::shift(int __i) const
value_type* __te;
if (__i >= 0)
{
__i = _STD::min(__i, static_cast<int>(__n));
__i = _VSTD::min(__i, static_cast<int>(__n));
__sb = __begin_ + __i;
__tb = __r.__begin_;
__te = __r.__begin_ + (__n - __i);
}
else
{
__i = _STD::min(-__i, static_cast<int>(__n));
__i = _VSTD::min(-__i, static_cast<int>(__n));
__sb = __begin_;
__tb = __r.__begin_ + __i;
__te = __r.__begin_ + __n;

File diff suppressed because it is too large Load Diff

View File

@@ -1,9 +1,17 @@
# Get sources
file(GLOB_RECURSE sources ../src/*.cpp)
file(GLOB sources ../src/*.cpp)
if(WIN32)
file(GLOB win32_sources ../src/support/win32/*.cpp)
list(APPEND sources ${win32_sources})
endif()
# Add all the headers to the project for IDEs.
if (MSVC_IDE OR XCODE)
file(GLOB_RECURSE headers ../include/*)
if(WIN32)
file( GLOB win32_headers ../include/support/win32/*.h)
list(APPEND headers ${win32_headers})
endif()
# Force them all into the headers dir on MSVC, otherwise they end up at
# project scope because they don't have extensions.
if (MSVC_IDE)

View File

@@ -26,7 +26,7 @@ if [ -z $MACOSX_DEPLOYMENT_TARGET ]
then
if [ -z $IPHONEOS_DEPLOYMENT_TARGET ]
then
MACOSX_DEPLOYMENT_TARGET=10.6
MACOSX_DEPLOYMENT_TARGET=10.7
fi
fi
@@ -35,7 +35,7 @@ then
RC_ProjectSourceVersion=1
fi
EXTRA_FLAGS="-std=c++0x "
EXTRA_FLAGS="-std=c++0x"
case $TRIPLE in
*-apple-*)
@@ -70,14 +70,23 @@ case $TRIPLE in
fi
LDSHARED_FLAGS="-o libc++.1.dylib \
-dynamiclib -nodefaultlibs \
-current_version ${RC_ProjectSourceVersion} -compatibility_version 1 \
-current_version ${RC_ProjectSourceVersion} \
-compatibility_version 1 \
-install_name /usr/lib/libc++.1.dylib \
-lSystem \
-Wl,-unexported_symbols_list,libc++unexp.exp \
${RE_EXPORT_LINE} \
-Wl,-force_symbols_not_weak_list,notweak.exp "
-Wl,-force_symbols_not_weak_list,notweak.exp \
-Wl,-force_symbols_weak_list,weak.exp"
fi
;;
*-*-mingw*)
# FIXME: removing libgcc and libsupc++ dependencies means porting libcxxrt and LLVM/compiler-rt
SOEXT=dll
LDSHARED_FLAGS="-o libc++.dll \
-shared -nodefaultlibs -Wl,--export-all-symbols -Wl,--allow-multiple-definition -Wl,--out-implib,libc++.dll.a \
-lsupc++ -lpthread -lmingw32 -lgcc_s -lgcc -lmoldname -lmingwex -lmsvcr100 -ladvapi32 -lshell32 -luser32 -lkernel32 -lmingw32 -lgcc_s -lgcc -lmoldname -lmingwex -lmsvcrt"
;;
*)
RC_CFLAGS="-fPIC"
SOEXT=so
@@ -97,8 +106,13 @@ set -x
for FILE in ../src/*.cpp; do
$CXX -c -g -Os $RC_CFLAGS $EXTRA_FLAGS -nostdinc++ -I../include $FILE
done
case $TRIPLE in
*-*-mingw*)
for FILE in ../src/support/win32/*.cpp; do
$CXX -c -g -Os $RC_CFLAGS $EXTRA_FLAGS -nostdinc++ -I../include $FILE
done
;;
esac
$CC *.o $RC_CFLAGS $LDSHARED_FLAGS $EXTRA_FLAGS
#libtool -static -o libc++.a *.o

16
lib/weak.exp Normal file
View File

@@ -0,0 +1,16 @@
__ZTISt10bad_typeid
__ZTISt11logic_error
__ZTISt11range_error
__ZTISt12domain_error
__ZTISt12length_error
__ZTISt12out_of_range
__ZTISt13bad_exception
__ZTISt13runtime_error
__ZTISt14overflow_error
__ZTISt15underflow_error
__ZTISt16invalid_argument
__ZTISt16nested_exception
__ZTISt20bad_array_new_length
__ZTISt8bad_cast
__ZTISt9bad_alloc
__ZTISt9exception

484
src/debug.cpp Normal file
View File

@@ -0,0 +1,484 @@
//===-------------------------- debug.cpp ---------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#define _LIBCPP_DEBUG2 1
#include "__config"
#include "__debug"
#include "functional"
#include "algorithm"
#include "__hash_table"
#include "mutex"
_LIBCPP_BEGIN_NAMESPACE_STD
_LIBCPP_VISIBLE
__libcpp_db*
__get_db()
{
static __libcpp_db db;
return &db;
};
_LIBCPP_VISIBLE
const __libcpp_db*
__get_const_db()
{
return __get_db();
}
namespace
{
typedef mutex mutex_type;
typedef lock_guard<mutex_type> WLock;
typedef lock_guard<mutex_type> RLock;
mutex_type&
mut()
{
static mutex_type m;
return m;
}
} // unnamed namespace
__i_node::~__i_node()
{
if (__next_)
{
__next_->~__i_node();
free(__next_);
}
}
__c_node::~__c_node()
{
free(beg_);
if (__next_)
{
__next_->~__c_node();
free(__next_);
}
}
__libcpp_db::__libcpp_db()
: __cbeg_(nullptr),
__cend_(nullptr),
__csz_(0),
__ibeg_(nullptr),
__iend_(nullptr),
__isz_(0)
{
}
__libcpp_db::~__libcpp_db()
{
if (__cbeg_)
{
for (__c_node** p = __cbeg_; p != __cend_; ++p)
{
if (*p != nullptr)
{
(*p)->~__c_node();
free(*p);
}
}
free(__cbeg_);
}
if (__ibeg_)
{
for (__i_node** p = __ibeg_; p != __iend_; ++p)
{
if (*p != nullptr)
{
(*p)->~__i_node();
free(*p);
}
}
free(__ibeg_);
}
}
void*
__libcpp_db::__find_c_from_i(void* __i) const
{
RLock _(mut());
__i_node* i = __find_iterator(__i);
_LIBCPP_ASSERT(i != nullptr, "iterator constructed in translation unit with debug mode not enabled."
" #define _LIBCPP_DEBUG2 1 for that translation unit.");
return i->__c_ != nullptr ? i->__c_->__c_ : nullptr;
}
void
__libcpp_db::__insert_ic(void* __i, const void* __c)
{
WLock _(mut());
__i_node* i = __insert_iterator(__i);
const char* errmsg =
"Container constructed in a translation unit with debug mode disabled."
" But it is being used in a translation unit with debug mode enabled."
" Enable it in the other translation unit with #define _LIBCPP_DEBUG2 1";
_LIBCPP_ASSERT(__cbeg_ != __cend_, errmsg);
size_t hc = hash<const void*>()(__c) % (__cend_ - __cbeg_);
__c_node* c = __cbeg_[hc];
_LIBCPP_ASSERT(c != nullptr, errmsg);
while (c->__c_ != __c)
{
c = c->__next_;
_LIBCPP_ASSERT(c != nullptr, errmsg);
}
c->__add(i);
i->__c_ = c;
}
__c_node*
__libcpp_db::__insert_c(void* __c)
{
WLock _(mut());
if (__csz_ + 1 > __cend_ - __cbeg_)
{
size_t nc = __next_prime(2*(__cend_ - __cbeg_) + 1);
__c_node** cbeg = (__c_node**)calloc(nc, sizeof(void*));
if (cbeg == nullptr)
throw bad_alloc();
for (__c_node** p = __cbeg_; p != __cend_; ++p)
{
__c_node* q = *p;
while (q != nullptr)
{
size_t h = hash<void*>()(q->__c_) % nc;
__c_node* r = q->__next_;
q->__next_ = cbeg[h];
cbeg[h] = q;
q = r;
}
}
free(__cbeg_);
__cbeg_ = cbeg;
__cend_ = __cbeg_ + nc;
}
size_t hc = hash<void*>()(__c) % (__cend_ - __cbeg_);
__c_node* p = __cbeg_[hc];
__c_node* r = __cbeg_[hc] = (__c_node*)malloc(sizeof(__c_node));
if (__cbeg_[hc] == nullptr)
throw bad_alloc();
r->__c_ = __c;
r->__next_ = p;
++__csz_;
return r;
}
void
__libcpp_db::__erase_i(void* __i)
{
WLock _(mut());
if (__ibeg_ != __iend_)
{
size_t hi = hash<void*>()(__i) % (__iend_ - __ibeg_);
__i_node* p = __ibeg_[hi];
if (p != nullptr)
{
__i_node* q = nullptr;
while (p->__i_ != __i)
{
q = p;
p = p->__next_;
if (p == nullptr)
return;
}
if (q == nullptr)
__ibeg_[hi] = p->__next_;
else
q->__next_ = p->__next_;
__c_node* c = p->__c_;
free(p);
--__isz_;
if (c != nullptr)
c->__remove(p);
}
}
}
void
__libcpp_db::__invalidate_all(void* __c)
{
WLock _(mut());
size_t hc = hash<void*>()(__c) % (__cend_ - __cbeg_);
__c_node* p = __cbeg_[hc];
_LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __invalidate_all A");
while (p->__c_ != __c)
{
p = p->__next_;
_LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __invalidate_all B");
}
while (p->end_ != p->beg_)
{
--p->end_;
(*p->end_)->__c_ = nullptr;
}
}
__c_node*
__libcpp_db::__find_c_and_lock(void* __c) const
{
mut().lock();
size_t hc = hash<void*>()(__c) % (__cend_ - __cbeg_);
__c_node* p = __cbeg_[hc];
_LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c_and_lock A");
while (p->__c_ != __c)
{
p = p->__next_;
_LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c_and_lock B");
}
return p;
}
__c_node*
__libcpp_db::__find_c(void* __c) const
{
size_t hc = hash<void*>()(__c) % (__cend_ - __cbeg_);
__c_node* p = __cbeg_[hc];
_LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c A");
while (p->__c_ != __c)
{
p = p->__next_;
_LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c B");
}
return p;
}
void
__libcpp_db::unlock() const
{
mut().unlock();
}
void
__libcpp_db::__erase_c(void* __c)
{
WLock _(mut());
size_t hc = hash<void*>()(__c) % (__cend_ - __cbeg_);
__c_node* p = __cbeg_[hc];
__c_node* q = nullptr;
_LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __erase_c A");
while (p->__c_ != __c)
{
q = p;
p = p->__next_;
_LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __erase_c B");
}
if (q == nullptr)
__cbeg_[hc] = p->__next_;
else
q->__next_ = p->__next_;
while (p->end_ != p->beg_)
{
--p->end_;
(*p->end_)->__c_ = nullptr;
}
free(p->beg_);
free(p);
--__csz_;
}
void
__libcpp_db::__iterator_copy(void* __i, const void* __i0)
{
WLock _(mut());
__i_node* i = __find_iterator(__i);
__i_node* i0 = __find_iterator(__i0);
__c_node* c0 = i0 != nullptr ? i0->__c_ : nullptr;
if (i == nullptr && c0 != nullptr)
i = __insert_iterator(__i);
__c_node* c = i != nullptr ? i->__c_ : nullptr;
if (c != c0)
{
if (c != nullptr)
c->__remove(i);
if (i != nullptr)
{
i->__c_ = nullptr;
if (c0 != nullptr)
{
i->__c_ = c0;
i->__c_->__add(i);
}
}
}
}
bool
__libcpp_db::__dereferenceable(const void* __i) const
{
RLock _(mut());
__i_node* i = __find_iterator(__i);
return i != nullptr && i->__c_ != nullptr && i->__c_->__dereferenceable(__i);
}
bool
__libcpp_db::__decrementable(const void* __i) const
{
RLock _(mut());
__i_node* i = __find_iterator(__i);
return i != nullptr && i->__c_ != nullptr && i->__c_->__decrementable(__i);
}
bool
__libcpp_db::__addable(const void* __i, ptrdiff_t __n) const
{
RLock _(mut());
__i_node* i = __find_iterator(__i);
return i != nullptr && i->__c_ != nullptr && i->__c_->__addable(__i, __n);
}
bool
__libcpp_db::__subscriptable(const void* __i, ptrdiff_t __n) const
{
RLock _(mut());
__i_node* i = __find_iterator(__i);
return i != nullptr && i->__c_ != nullptr && i->__c_->__subscriptable(__i, __n);
}
bool
__libcpp_db::__comparable(const void* __i, const void* __j) const
{
RLock _(mut());
__i_node* i = __find_iterator(__i);
__i_node* j = __find_iterator(__j);
__c_node* ci = i != nullptr ? i->__c_ : nullptr;
__c_node* cj = j != nullptr ? j->__c_ : nullptr;
return ci != nullptr && ci == cj;
}
void
__libcpp_db::swap(void* c1, void* c2)
{
WLock _(mut());
size_t hc = hash<void*>()(c1) % (__cend_ - __cbeg_);
__c_node* p1 = __cbeg_[hc];
_LIBCPP_ASSERT(p1 != nullptr, "debug mode internal logic error swap A");
while (p1->__c_ != c1)
{
p1 = p1->__next_;
_LIBCPP_ASSERT(p1 != nullptr, "debug mode internal logic error swap B");
}
hc = hash<void*>()(c2) % (__cend_ - __cbeg_);
__c_node* p2 = __cbeg_[hc];
_LIBCPP_ASSERT(p2 != nullptr, "debug mode internal logic error swap C");
while (p2->__c_ != c2)
{
p2 = p2->__next_;
_LIBCPP_ASSERT(p2 != nullptr, "debug mode internal logic error swap D");
}
std::swap(p1->beg_, p2->beg_);
std::swap(p1->end_, p2->end_);
std::swap(p1->cap_, p2->cap_);
for (__i_node** p = p1->beg_; p != p1->end_; ++p)
(*p)->__c_ = p1;
for (__i_node** p = p2->beg_; p != p2->end_; ++p)
(*p)->__c_ = p2;
}
void
__libcpp_db::__insert_i(void* __i)
{
WLock _(mut());
__insert_iterator(__i);
}
void
__c_node::__add(__i_node* i)
{
if (end_ == cap_)
{
size_t nc = 2*(cap_ - beg_);
if (nc == 0)
nc = 1;
__i_node** beg = (__i_node**)malloc(nc * sizeof(__i_node*));
if (beg == nullptr)
throw bad_alloc();
if (nc > 1)
memcpy(beg, beg_, nc/2*sizeof(__i_node*));
free(beg_);
beg_ = beg;
end_ = beg_ + nc/2;
cap_ = beg_ + nc;
}
*end_++ = i;
}
// private api
_LIBCPP_HIDDEN
__i_node*
__libcpp_db::__insert_iterator(void* __i)
{
if (__isz_ + 1 > __iend_ - __ibeg_)
{
size_t nc = __next_prime(2*(__iend_ - __ibeg_) + 1);
__i_node** ibeg = (__i_node**)calloc(nc, sizeof(void*));
if (ibeg == nullptr)
throw bad_alloc();
for (__i_node** p = __ibeg_; p != __iend_; ++p)
{
__i_node* q = *p;
while (q != nullptr)
{
size_t h = hash<void*>()(q->__i_) % nc;
__i_node* r = q->__next_;
q->__next_ = ibeg[h];
ibeg[h] = q;
q = r;
}
}
free(__ibeg_);
__ibeg_ = ibeg;
__iend_ = __ibeg_ + nc;
}
size_t hi = hash<void*>()(__i) % (__iend_ - __ibeg_);
__i_node* p = __ibeg_[hi];
__i_node* r = __ibeg_[hi] = (__i_node*)malloc(sizeof(__i_node));
if (r == nullptr)
throw bad_alloc();
::new(r) __i_node(__i, p, nullptr);
++__isz_;
return r;
}
_LIBCPP_HIDDEN
__i_node*
__libcpp_db::__find_iterator(const void* __i) const
{
__i_node* r = nullptr;
if (__ibeg_ != __iend_)
{
size_t h = hash<const void*>()(__i) % (__iend_ - __ibeg_);
for (__i_node* nd = __ibeg_[h]; nd != nullptr; nd = nd->__next_)
{
if (nd->__i_ == __i)
{
r = nd;
break;
}
}
}
return r;
}
_LIBCPP_HIDDEN
void
__c_node::__remove(__i_node* p)
{
__i_node** r = find(beg_, end_, p);
_LIBCPP_ASSERT(r != end_, "debug mode internal logic error __c_node::__remove");
if (--end_ != r)
memmove(r, r+1, (end_ - r)*sizeof(__i_node*));
}
_LIBCPP_END_NAMESPACE_STD

View File

@@ -13,16 +13,24 @@
#if __APPLE__
#include <cxxabi.h>
using namespace __cxxabiv1;
using namespace __cxxabiapple;
// On Darwin, there are two STL shared libraries and a lower level ABI
// shared libray. The globals holding the current terminate handler and
// current unexpected handler are in the ABI library.
#define __terminate_handler __cxxabiapple::__cxa_terminate_handler
#define __unexpected_handler __cxxabiapple::__cxa_unexpected_handler
#define HAVE_DEPENDENT_EH_ABI 1
#elif defined(LIBCXXRT)
#include <cxxabi.h>
using namespace __cxxabiv1;
#define HAVE_DEPENDENT_EH_ABI 1
#else // __APPLE__
static std::terminate_handler __terminate_handler;
static std::unexpected_handler __unexpected_handler;
#endif // __APPLE__
#ifndef LIBCXXRT
// libcxxrt provides implementations of these functions itself.
std::unexpected_handler
std::set_unexpected(std::unexpected_handler func) _NOEXCEPT
{
@@ -56,6 +64,7 @@ std::get_terminate() _NOEXCEPT
return __sync_fetch_and_add(&__terminate_handler, (std::terminate_handler)0);
}
_ATTRIBUTE(noreturn)
void
std::terminate() _NOEXCEPT
{
@@ -75,18 +84,19 @@ std::terminate() _NOEXCEPT
}
#endif // _LIBCPP_NO_EXCEPTIONS
}
#endif // LIBCXXRT
bool std::uncaught_exception() _NOEXCEPT
{
#if __APPLE__
// on Darwin, there is a helper function so __cxa_get_globals is private
return __cxxabiapple::__cxa_uncaught_exception();
#elif LIBCXXRT
__cxa_eh_globals * globals = __cxa_get_globals();
return (globals->uncaughtExceptions != 0);
#else // __APPLE__
#warning uncaught_exception not yet implemented
::abort();
// Not provided by Ubuntu gcc-4.2.4's cxxabi.h.
// __cxa_eh_globals * globals = __cxa_get_globals();
// return (globals->uncaughtExceptions != 0);
#endif // __APPLE__
}
@@ -113,8 +123,8 @@ const char* bad_exception::what() const _NOEXCEPT
exception_ptr::~exception_ptr() _NOEXCEPT
{
#if __APPLE__
__cxxabiapple::__cxa_decrement_exception_refcount(__ptr_);
#if HAVE_DEPENDENT_EH_ABI
__cxa_decrement_exception_refcount(__ptr_);
#else
#warning exception_ptr not yet implemented
::abort();
@@ -124,8 +134,8 @@ exception_ptr::~exception_ptr() _NOEXCEPT
exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
: __ptr_(other.__ptr_)
{
#if __APPLE__
__cxxabiapple::__cxa_increment_exception_refcount(__ptr_);
#if HAVE_DEPENDENT_EH_ABI
__cxa_increment_exception_refcount(__ptr_);
#else
#warning exception_ptr not yet implemented
::abort();
@@ -134,11 +144,11 @@ exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
{
#if __APPLE__
#if HAVE_DEPENDENT_EH_ABI
if (__ptr_ != other.__ptr_)
{
__cxxabiapple::__cxa_increment_exception_refcount(other.__ptr_);
__cxxabiapple::__cxa_decrement_exception_refcount(__ptr_);
__cxa_increment_exception_refcount(other.__ptr_);
__cxa_decrement_exception_refcount(__ptr_);
__ptr_ = other.__ptr_;
}
return *this;
@@ -170,12 +180,12 @@ nested_exception::rethrow_nested() const
std::exception_ptr std::current_exception() _NOEXCEPT
{
#if __APPLE__
#if HAVE_DEPENDENT_EH_ABI
// be nicer if there was a constructor that took a ptr, then
// this whole function would be just:
// return exception_ptr(__cxa_current_primary_exception());
std::exception_ptr ptr;
ptr.__ptr_ = __cxxabiapple::__cxa_current_primary_exception();
ptr.__ptr_ = __cxa_current_primary_exception();
return ptr;
#else // __APPLE__
#warning exception_ptr not yet implemented
@@ -185,8 +195,8 @@ std::exception_ptr std::current_exception() _NOEXCEPT
void std::rethrow_exception(exception_ptr p)
{
#if __APPLE__
__cxxabiapple::__cxa_rethrow_primary_exception(p.__ptr_);
#if HAVE_DEPENDENT_EH_ABI
__cxa_rethrow_primary_exception(p.__ptr_);
// if p.__ptr_ is NULL, above returns so we terminate
terminate();
#else // __APPLE__

View File

@@ -59,6 +59,10 @@ future_error::future_error(error_code __ec)
{
}
future_error::~future_error() _NOEXCEPT
{
}
void
__assoc_sub_state::__on_zero_shared() _NOEXCEPT
{
@@ -69,8 +73,10 @@ void
__assoc_sub_state::set_value()
{
unique_lock<mutex> __lk(__mut_);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__has_value())
throw future_error(make_error_code(future_errc::promise_already_satisfied));
#endif
__state_ |= __constructed | ready;
__lk.unlock();
__cv_.notify_all();
@@ -80,8 +86,10 @@ void
__assoc_sub_state::set_value_at_thread_exit()
{
unique_lock<mutex> __lk(__mut_);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__has_value())
throw future_error(make_error_code(future_errc::promise_already_satisfied));
#endif
__state_ |= __constructed;
__thread_local_data()->__make_ready_at_thread_exit(this);
__lk.unlock();
@@ -91,8 +99,10 @@ void
__assoc_sub_state::set_exception(exception_ptr __p)
{
unique_lock<mutex> __lk(__mut_);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__has_value())
throw future_error(make_error_code(future_errc::promise_already_satisfied));
#endif
__exception_ = __p;
__state_ |= ready;
__lk.unlock();
@@ -103,8 +113,10 @@ void
__assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p)
{
unique_lock<mutex> __lk(__mut_);
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__has_value())
throw future_error(make_error_code(future_errc::promise_already_satisfied));
#endif
__exception_ = __p;
__thread_local_data()->__make_ready_at_thread_exit(this);
__lk.unlock();
@@ -155,14 +167,18 @@ __assoc_sub_state::__sub_wait(unique_lock<mutex>& __lk)
void
__assoc_sub_state::__execute()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
throw future_error(make_error_code(future_errc::no_state));
#endif
}
future<void>::future(__assoc_sub_state* __state)
: __state_(__state)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_->__has_future_attached())
throw future_error(make_error_code(future_errc::future_already_retrieved));
#endif
__state_->__add_shared();
__state_->__set_future_attached();
}
@@ -202,40 +218,50 @@ promise<void>::~promise()
future<void>
promise<void>::get_future()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
return future<void>(__state_);
}
void
promise<void>::set_value()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
__state_->set_value();
}
void
promise<void>::set_exception(exception_ptr __p)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
__state_->set_exception(__p);
}
void
promise<void>::set_value_at_thread_exit()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
__state_->set_value_at_thread_exit();
}
void
promise<void>::set_exception_at_thread_exit(exception_ptr __p)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
if (__state_ == nullptr)
throw future_error(make_error_code(future_errc::no_state));
#endif
__state_->set_exception_at_thread_exit(__p);
}

View File

@@ -165,7 +165,7 @@ ios_base::iword(int index)
size_t newcap;
const size_t mx = std::numeric_limits<size_t>::max();
if (req_size < mx/2)
newcap = _STD::max(2 * __iarray_cap_, req_size);
newcap = _VSTD::max(2 * __iarray_cap_, req_size);
else
newcap = mx;
long* iarray = (long*)realloc(__iarray_, newcap * sizeof(long));
@@ -193,7 +193,7 @@ ios_base::pword(int index)
size_t newcap;
const size_t mx = std::numeric_limits<size_t>::max();
if (req_size < mx/2)
newcap = _STD::max(2 * __parray_cap_, req_size);
newcap = _VSTD::max(2 * __parray_cap_, req_size);
else
newcap = mx;
void** parray = (void**)realloc(__parray_, newcap * sizeof(void*));
@@ -223,7 +223,7 @@ ios_base::register_callback(event_callback fn, int index)
size_t newcap;
const size_t mx = std::numeric_limits<size_t>::max();
if (req_size < mx/2)
newcap = _STD::max(2 * __event_cap_, req_size);
newcap = _VSTD::max(2 * __event_cap_, req_size);
else
newcap = mx;
event_callback* fns = (event_callback*)realloc(__fn_, newcap * sizeof(event_callback));
@@ -403,24 +403,24 @@ ios_base::move(ios_base& rhs)
void
ios_base::swap(ios_base& rhs)
{
_STD::swap(__fmtflags_, rhs.__fmtflags_);
_STD::swap(__precision_, rhs.__precision_);
_STD::swap(__width_, rhs.__width_);
_STD::swap(__rdstate_, rhs.__rdstate_);
_STD::swap(__exceptions_, rhs.__exceptions_);
_VSTD::swap(__fmtflags_, rhs.__fmtflags_);
_VSTD::swap(__precision_, rhs.__precision_);
_VSTD::swap(__width_, rhs.__width_);
_VSTD::swap(__rdstate_, rhs.__rdstate_);
_VSTD::swap(__exceptions_, rhs.__exceptions_);
locale& lhs_loc = *(locale*)&__loc_;
locale& rhs_loc = *(locale*)&rhs.__loc_;
_STD::swap(lhs_loc, rhs_loc);
_STD::swap(__fn_, rhs.__fn_);
_STD::swap(__index_, rhs.__index_);
_STD::swap(__event_size_, rhs.__event_size_);
_STD::swap(__event_cap_, rhs.__event_cap_);
_STD::swap(__iarray_, rhs.__iarray_);
_STD::swap(__iarray_size_, rhs.__iarray_size_);
_STD::swap(__iarray_cap_, rhs.__iarray_cap_);
_STD::swap(__parray_, rhs.__parray_);
_STD::swap(__parray_size_, rhs.__parray_size_);
_STD::swap(__parray_cap_, rhs.__parray_cap_);
_VSTD::swap(lhs_loc, rhs_loc);
_VSTD::swap(__fn_, rhs.__fn_);
_VSTD::swap(__index_, rhs.__index_);
_VSTD::swap(__event_size_, rhs.__event_size_);
_VSTD::swap(__event_cap_, rhs.__event_cap_);
_VSTD::swap(__iarray_, rhs.__iarray_);
_VSTD::swap(__iarray_size_, rhs.__iarray_size_);
_VSTD::swap(__iarray_cap_, rhs.__iarray_cap_);
_VSTD::swap(__parray_, rhs.__parray_);
_VSTD::swap(__parray_size_, rhs.__parray_size_);
_VSTD::swap(__parray_cap_, rhs.__parray_cap_);
}
void

View File

@@ -33,11 +33,11 @@ ios_base::Init __start_std_streams;
ios_base::Init::Init()
{
cin.tie(&cout);
_STD::unitbuf(cerr);
_VSTD::unitbuf(cerr);
cerr.tie(&cout);
wcin.tie(&wcout);
_STD::unitbuf(wcerr);
_VSTD::unitbuf(wcerr);
wcerr.tie(&wcout);
}

File diff suppressed because it is too large Load Diff

View File

@@ -28,6 +28,9 @@
__attribute__((__weak__, __visibility__("default")))
void *
operator new(std::size_t size)
#if !__has_feature(cxx_noexcept)
throw(std::bad_alloc)
#endif
{
if (size == 0)
size = 1;
@@ -71,6 +74,9 @@ operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
__attribute__((__weak__, __visibility__("default")))
void*
operator new[](size_t size)
#if !__has_feature(cxx_noexcept)
throw(std::bad_alloc)
#endif
{
return ::operator new(size);
}

View File

@@ -229,7 +229,7 @@ string
__get_collation_name(const char* s)
{
const collationnames* i =
_STD::lower_bound(begin(collatenames), end(collatenames), s, use_strcmp());
_VSTD::lower_bound(begin(collatenames), end(collatenames), s, use_strcmp());
string r;
if (i != end(collatenames) && strcmp(s, i->elem_) == 0)
r = char(i->char_);
@@ -240,7 +240,7 @@ ctype_base::mask
__get_classname(const char* s, bool __icase)
{
const classnames* i =
_STD::lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp());
_VSTD::lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp());
ctype_base::mask r = 0;
if (i != end(ClassNames) && strcmp(s, i->elem_) == 0)
{

View File

@@ -11,6 +11,9 @@
#include "cstdlib"
#include "cwchar"
#include "cerrno"
#if _WIN32
#include "support/win32/support.h"
#endif // _WIN32
_LIBCPP_BEGIN_NAMESPACE_STD
@@ -19,52 +22,6 @@ template class __basic_string_common<true>;
template class basic_string<char>;
template class basic_string<wchar_t>;
template enable_if<__is_forward_iterator<char const*>::value, void>::type
basic_string<char, char_traits<char>, allocator<char> >
::__init<char const*>(char const*, char const*);
template enable_if<__is_forward_iterator<wchar_t const*>::value, void>::type
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >
::__init<wchar_t const*>(wchar_t const*, wchar_t const*);
template
enable_if<__is_forward_iterator<char*>::value,
basic_string<char, char_traits<char>, allocator<char> >&>::type
basic_string<char, char_traits<char>, allocator<char> >::
append<char*>(char*, char*);
template
enable_if<__is_forward_iterator<wchar_t*>::value,
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&>::type
basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >::
append<wchar_t*>(wchar_t*, wchar_t*);
template
enable_if<__is_forward_iterator<char const*>::value,
string::iterator>::type
string::
insert<char const*>(string::const_iterator, char const*, char const*);
template
enable_if<__is_forward_iterator<wchar_t const*>::value,
wstring::iterator>::type
wstring::
insert<wchar_t const*>(wstring::const_iterator, wchar_t const*, wchar_t const*);
template
enable_if<__is_input_iterator<char const*>::value, string&>::type
string::
replace<char const*>(string::const_iterator, string::const_iterator, char const*, char const*);
template
enable_if<__is_input_iterator<wchar_t const*>::value, wstring&>::type
wstring::
replace<wchar_t const*>(wstring::const_iterator, wstring::const_iterator, wchar_t const*, wchar_t const*);
template
enable_if<__is_forward_iterator<wchar_t*>::value, wstring&>::type
wstring::assign<wchar_t*>(wchar_t*, wchar_t*);
template
string
operator+<char, char_traits<char>, allocator<char> >(char const*, string const&);

View File

@@ -100,41 +100,6 @@ strstreambuf::strstreambuf(const unsigned char* __gnext, streamsize __n)
__init((char*)__gnext, __n, nullptr);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
strstreambuf::strstreambuf(strstreambuf&& __rhs)
: streambuf(__rhs),
__strmode_(__rhs.__strmode_),
__alsize_(__rhs.__alsize_),
__palloc_(__rhs.__palloc_),
__pfree_(__rhs.__pfree_)
{
__rhs.setg(nullptr, nullptr, nullptr);
__rhs.setp(nullptr, nullptr);
}
strstreambuf&
strstreambuf::operator=(strstreambuf&& __rhs)
{
if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0)
{
if (__pfree_)
__pfree_(eback());
else
delete [] eback();
}
streambuf::operator=(__rhs);
__strmode_ = __rhs.__strmode_;
__alsize_ = __rhs.__alsize_;
__palloc_ = __rhs.__palloc_;
__pfree_ = __rhs.__pfree_;
__rhs.setg(nullptr, nullptr, nullptr);
__rhs.setp(nullptr, nullptr);
return *this;
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
strstreambuf::~strstreambuf()
{
if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0)
@@ -150,10 +115,10 @@ void
strstreambuf::swap(strstreambuf& __rhs)
{
streambuf::swap(__rhs);
_STD::swap(__strmode_, __rhs.__strmode_);
_STD::swap(__alsize_, __rhs.__alsize_);
_STD::swap(__palloc_, __rhs.__palloc_);
_STD::swap(__pfree_, __rhs.__pfree_);
_VSTD::swap(__strmode_, __rhs.__strmode_);
_VSTD::swap(__alsize_, __rhs.__alsize_);
_VSTD::swap(__palloc_, __rhs.__palloc_);
_VSTD::swap(__pfree_, __rhs.__pfree_);
}
void
@@ -302,7 +267,7 @@ strstreambuf::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmod
{
char* newpos = eback() + newoff;
if (pos_in)
setg(eback(), newpos, _STD::max(newpos, egptr()));
setg(eback(), newpos, _VSTD::max(newpos, egptr()));
if (pos_out)
{
// min(pbase, newpos), newpos, epptr()
@@ -332,7 +297,7 @@ strstreambuf::seekpos(pos_type __sp, ios_base::openmode __which)
{
char* newpos = eback() + newoff;
if (pos_in)
setg(eback(), newpos, _STD::max(newpos, egptr()));
setg(eback(), newpos, _VSTD::max(newpos, egptr()));
if (pos_out)
{
// min(pbase, newpos), newpos, epptr()

View File

@@ -0,0 +1,94 @@
// -*- C++ -*-
//===-------------------- support/win32/locale_win32.cpp ------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
#include "support/win32/locale_win32.h"
#include <stdarg.h> // va_start, va_end
// FIXME: base currently unused. Needs manual work to construct the new locale
locale_t newlocale( int mask, const char * locale, locale_t /*base*/ )
{
return _create_locale( mask, locale );
}
locale_t uselocale( locale_t newloc )
{
locale_t old_locale = _get_current_locale();
// uselocale sets the thread's locale by definition, so unconditionally use thread-local locale
_configthreadlocale( _ENABLE_PER_THREAD_LOCALE );
// uselocale sets all categories
setlocale( LC_ALL, newloc->locinfo->lc_category[LC_ALL].locale );
// uselocale returns the old locale_t
return old_locale;
}
lconv *localeconv_l( locale_t loc )
{
__locale_raii __current( uselocale(loc), uselocale );
return localeconv();
}
size_t mbrlen_l( const char *__restrict__ s, size_t n,
mbstate_t *__restrict__ ps, locale_t loc )
{
__locale_raii __current( uselocale(loc), uselocale );
return mbrlen( s, n, ps );
}
size_t mbsrtowcs_l( wchar_t *__restrict__ dst, const char **__restrict__ src,
size_t len, mbstate_t *__restrict__ ps, locale_t loc )
{
__locale_raii __current( uselocale(loc), uselocale );
return mbsrtowcs( dst, src, len, ps );
}
size_t wcrtomb_l( char *__restrict__ s, wchar_t wc, mbstate_t *__restrict__ ps,
locale_t loc )
{
__locale_raii __current( uselocale(loc), uselocale );
return wcrtomb( s, wc, ps );
}
size_t mbrtowc_l( wchar_t *__restrict__ pwc, const char *__restrict__ s,
size_t n, mbstate_t *__restrict__ ps, locale_t loc )
{
__locale_raii __current( uselocale(loc), uselocale );
return mbrtowc( pwc, s, n, ps );
}
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 )
{
__locale_raii __current( uselocale(loc), uselocale );
return mbsnrtowcs( dst, src, nms, len, ps );
}
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_raii __current( uselocale(loc), uselocale );
return wcsnrtombs( dst, src, nwc, len, ps );
}
wint_t btowc_l( int c, locale_t loc )
{
__locale_raii __current( uselocale(loc), uselocale );
return btowc( c );
}
int wctob_l( wint_t c, locale_t loc )
{
__locale_raii __current( uselocale(loc), uselocale );
return wctob( c );
}
int asprintf_l( char **ret, locale_t loc, const char *format, ... )
{
va_list ap;
va_start( ap, format );
int result = vasprintf_l( ret, loc, format, ap );
va_end(ap);
return result;
}
int vasprintf_l( char **ret, locale_t loc, const char *format, va_list ap )
{
__locale_raii __current( uselocale(loc), uselocale );
return vasprintf( ret, format, ap );
}

View File

@@ -0,0 +1,70 @@
// -*- 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.
//
//===----------------------------------------------------------------------===//
#include <support/win32/support.h>
#include <stdarg.h> // va_start, va_end
#include <stddef.h> // size_t
#include <stdlib.h> // malloc
#include <stdio.h> // vsprintf, vsnprintf
#include <string.h> // strcpy, wcsncpy
int asprintf(char **sptr, const char *__restrict__ fmt, ...)
{
va_list ap;
va_start(ap, fmt);
int result = vasprintf(sptr, fmt, ap);
va_end(ap);
return result;
}
int vasprintf( char **sptr, const char *__restrict__ fmt, va_list ap )
{
*sptr = NULL;
int count = vsnprintf( *sptr, 0, fmt, ap );
if( (count >= 0) && ((*sptr = (char*)malloc(count+1)) != NULL) )
{
vsprintf( *sptr, fmt, ap );
sptr[count] = '\0';
}
return count;
}
// FIXME: use wcrtomb and avoid copy
// use mbsrtowcs which is available, first copy first nwc elements of src
size_t mbsnrtowcs( wchar_t *__restrict__ dst, const char **__restrict__ src,
size_t nmc, size_t len, mbstate_t *__restrict__ ps )
{
char* local_src = new char[nmc+1];
char* nmcsrc = local_src;
strncpy( nmcsrc, *src, nmc );
nmcsrc[nmc] = '\0';
const size_t result = mbsrtowcs( dst, const_cast<const char **>(&nmcsrc), len, ps );
// propagate error
if( nmcsrc == NULL )
*src = NULL;
delete[] local_src;
return result;
}
// FIXME: use wcrtomb and avoid copy
// use wcsrtombs which is available, first copy first nwc elements of src
size_t wcsnrtombs( char *__restrict__ dst, const wchar_t **__restrict__ src,
size_t nwc, size_t len, mbstate_t *__restrict__ ps )
{
wchar_t* local_src = new wchar_t[nwc];
wchar_t* nwcsrc = local_src;
wcsncpy(nwcsrc, *src, nwc);
nwcsrc[nwc] = '\0';
const size_t result = wcsrtombs( dst, const_cast<const wchar_t **>(&nwcsrc), len, ps );
// propogate error
if( nwcsrc == NULL )
*src = NULL;
delete[] nwcsrc;
return result;
}

View File

@@ -147,7 +147,7 @@ system_error::__init(const error_code& ec, string what_arg)
what_arg += ": ";
what_arg += ec.message();
}
return _STD::move(what_arg);
return _VSTD::move(what_arg);
}
system_error::system_error(error_code ec, const string& what_arg)

View File

@@ -12,7 +12,9 @@
#include "vector"
#include "future"
#include <sys/types.h>
#if !_WIN32
#include <sys/sysctl.h>
#endif // _WIN32
_LIBCPP_BEGIN_NAMESPACE_STD

View File

@@ -18,7 +18,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
int i = std::max({2, 3, 1});
assert(i == 3);
i = std::max({2, 1, 3});
@@ -31,5 +31,5 @@ int main()
assert(i == 3);
i = std::max({1, 3, 2});
assert(i == 3);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -19,7 +19,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
int i = std::max({2, 3, 1}, std::greater<int>());
assert(i == 1);
i = std::max({2, 1, 3}, std::greater<int>());
@@ -32,5 +32,5 @@ int main()
assert(i == 1);
i = std::max({1, 3, 2}, std::greater<int>());
assert(i == 1);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -18,7 +18,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
int i = std::min({2, 3, 1});
assert(i == 1);
i = std::min({2, 1, 3});
@@ -31,5 +31,5 @@ int main()
assert(i == 1);
i = std::min({1, 3, 2});
assert(i == 1);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -19,7 +19,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
int i = std::min({2, 3, 1}, std::greater<int>());
assert(i == 3);
i = std::min({2, 1, 3}, std::greater<int>());
@@ -32,5 +32,5 @@ int main()
assert(i == 3);
i = std::min({1, 3, 2}, std::greater<int>());
assert(i == 3);
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -18,12 +18,12 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
assert((std::minmax({1, 2, 3}) == std::pair<int, int>(1, 3)));
assert((std::minmax({1, 3, 2}) == std::pair<int, int>(1, 3)));
assert((std::minmax({2, 1, 3}) == std::pair<int, int>(1, 3)));
assert((std::minmax({2, 3, 1}) == std::pair<int, int>(1, 3)));
assert((std::minmax({3, 1, 2}) == std::pair<int, int>(1, 3)));
assert((std::minmax({3, 2, 1}) == std::pair<int, int>(1, 3)));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -19,12 +19,12 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
assert((std::minmax({1, 2, 3}, std::greater<int>()) == std::pair<int, int>(3, 1)));
assert((std::minmax({1, 3, 2}, std::greater<int>()) == std::pair<int, int>(3, 1)));
assert((std::minmax({2, 1, 3}, std::greater<int>()) == std::pair<int, int>(3, 1)));
assert((std::minmax({2, 3, 1}, std::greater<int>()) == std::pair<int, int>(3, 1)));
assert((std::minmax({3, 1, 2}, std::greater<int>()) == std::pair<int, int>(3, 1)));
assert((std::minmax({3, 2, 1}, std::greater<int>()) == std::pair<int, int>(3, 1)));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -18,7 +18,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
typedef std::pair<const int, double> V;
std::map<int, double> m =
{
@@ -41,5 +41,5 @@ int main()
assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -18,7 +18,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
typedef std::pair<const int, double> V;
std::map<int, double> m =
{
@@ -37,5 +37,5 @@ int main()
assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -19,7 +19,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
typedef std::pair<const int, double> V;
typedef test_compare<std::less<int> > C;
std::map<int, double, C> m({
@@ -39,5 +39,5 @@ int main()
assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1));
assert(m.key_comp() == C(3));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -20,7 +20,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
typedef std::pair<const int, double> V;
typedef test_compare<std::less<int> > C;
typedef test_allocator<std::pair<const int, double> > A;
@@ -42,5 +42,5 @@ int main()
assert(*next(m.begin(), 2) == V(3, 1));
assert(m.key_comp() == C(3));
assert(m.get_allocator() == A(6));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -18,7 +18,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
typedef std::pair<const int, double> V;
std::map<int, double> m =
{
@@ -39,5 +39,5 @@ int main()
assert(*m.begin() == V(1, 1));
assert(*next(m.begin()) == V(2, 1));
assert(*next(m.begin(), 2) == V(3, 1));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -18,7 +18,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
typedef std::multimap<int, double> C;
typedef C::value_type V;
C m = {{20, 1}};
@@ -46,5 +46,5 @@ int main()
assert(*++i == V(3, 1));
assert(*++i == V(3, 1.5));
assert(*++i == V(3, 2));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -18,7 +18,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
typedef std::multimap<int, double> C;
typedef C::value_type V;
C m =
@@ -45,5 +45,5 @@ int main()
assert(*++i == V(3, 1));
assert(*++i == V(3, 1.5));
assert(*++i == V(3, 2));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -19,7 +19,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
typedef test_compare<std::less<int> > Cmp;
typedef std::multimap<int, double, Cmp> C;
typedef C::value_type V;
@@ -50,5 +50,5 @@ int main()
assert(*++i == V(3, 1.5));
assert(*++i == V(3, 2));
assert(m.key_comp() == Cmp(4));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -20,7 +20,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
typedef test_compare<std::less<int> > Cmp;
typedef test_allocator<std::pair<const int, double> > A;
typedef std::multimap<int, double, Cmp, A> C;
@@ -53,5 +53,5 @@ int main()
assert(*++i == V(3, 2));
assert(m.key_comp() == Cmp(4));
assert(m.get_allocator() == A(5));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -18,7 +18,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
typedef std::multimap<int, double> C;
typedef C::value_type V;
C m =
@@ -49,5 +49,5 @@ int main()
assert(*++i == V(3, 1));
assert(*++i == V(3, 2));
assert(*++i == V(3, 1.5));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -18,7 +18,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
typedef std::multiset<int> C;
typedef C::value_type V;
C m = {10, 8};
@@ -34,5 +34,5 @@ int main()
assert(*++i == V(6));
assert(*++i == V(8));
assert(*++i == V(10));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -18,7 +18,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
typedef std::multiset<int> C;
typedef C::value_type V;
C m = {10, 8};
@@ -32,5 +32,5 @@ int main()
assert(*++i == V(4));
assert(*++i == V(5));
assert(*++i == V(6));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

View File

@@ -18,7 +18,7 @@
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
typedef std::multiset<int> C;
typedef C::value_type V;
C m = {1, 2, 3, 4, 5, 6};
@@ -31,5 +31,5 @@ int main()
assert(*++i == V(4));
assert(*++i == V(5));
assert(*++i == V(6));
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
}

Some files were not shown because too many files have changed in this diff Show More